2 Keys Keyboard Problem

• Difficulty Level : Easy
• Last Updated : 09 Jul, 2021

Given a positive integer N and a string S initially it is “A”, the task is to minimize the number of operations required to form a string consisting of N numbers of A’s by performing one of the following operations in each step:

• Copy all the characters present in the string S.
• Append all the characters to the string S which are copied last time.

Examples:

Input: N = 3
Output: 3
Explanation:
Below are the operations performed:
Operation 1: Copy the initial string S once i.e., “A”.
Operation 2: Appending the copied string i.e., “A”, to the string S modifies the string S to “AA”.
Operation 3: Appending the copied string i.e., “A”, to the string S modifies the string S to “AAA”.
Therefore, the minimum number of operations required to get 3 A’s is 3.

Input: N = 7
Output: 7

Approach: The given problem can be solved based on the following observations:

1. If N = P1*P2*Pm where {P1, P2, …, Pm} are the prime numbers then one can perform the following moves:
1. First, copy the string and then paste it (P1 – 1) times.
2. Similarly, again copying the string and pasting it for (P2 – 1) times.
3. Performing M times with the remaining prime number, one will get the string with N number of A’s.
2. Therefore, the total number of minimum moves needed is given by (P1 + P2 + … + Pm).

Follow the steps below to solve the problem:

Below is the implementation of the above approach:

C++

 // C++ program for the above approach   #include using namespace std;   // Function to find the minimum number // of steps required to form N number // of A's int minSteps(int N) {     // Stores the count of steps needed     int ans = 0;       // Traverse over the range [2, N]     for (int d = 2; d * d <= N; d++) {           // Iterate while N is divisible         // by d         while (N % d == 0) {               // Increment the value of             // ans by d             ans += d;               // Divide N by d             N /= d;         }     }       // If N is not 1     if (N != 1) {         ans += N;     }       // Return the ans     return ans; }   // Driver Code int main() {     int N = 3;     cout << minSteps(N);       return 0; }

Java

 // Java Program for the above approach import java.io.*;   class GFG {         // Function to find the minimum number     // of steps required to form N number     // of A's     static int minSteps(int N)     {         // Stores the count of steps needed         int ans = 0;           // Traverse over the range [2, N]         for (int d = 2; d * d <= N; d++) {               // Iterate while N is divisible             // by d             while (N % d == 0) {                   // Increment the value of                 // ans by d                 ans += d;                   // Divide N by d                 N /= d;             }         }           // If N is not 1         if (N != 1) {             ans += N;         }           // Return the ans         return ans;     }       // Driver Code     public static void main(String[] args)     {         int N = 3;         minSteps(N);         System.out.println(minSteps(N));     } }   // This code is contributed by lokesh potta.

Python3

 # Python3 program for the above approach # Function to find the minimum number # of steps required to form N number # of A's def minSteps( N):       # Stores the count of steps needed     ans = 0       # Traverse over the range [2, N]     d = 2     while(d * d <= N):           # Iterate while N is divisible         # by d         while (N % d == 0):               # Increment the value of             # ans by d             ans += d               # Divide N by d             N /= d         d += 1           # If N is not 1     if (N != 1):         ans += N           # Return the ans     return ans   # Driver Code N = 3 print(minSteps(N))   # This code is contributed by shivanisinghss2110

C#

 // C# program for the above approach using System;   class GFG{       // Function to find the minimum number // of steps required to form N number // of A's static int minSteps(int N) {     // Stores the count of steps needed     int ans = 0;       // Traverse over the range [2, N]     for (int d = 2; d * d <= N; d++) {           // Iterate while N is divisible         // by d         while (N % d == 0) {               // Increment the value of             // ans by d             ans += d;               // Divide N by d             N /= d;         }     }       // If N is not 1     if (N != 1) {         ans += N;     }       // Return the ans     return ans; }   // Driver Code static public void Main () {           int N = 3;     Console.Write(minSteps(N)); } }   // This code is contributed by sanjoy_62.

Javascript



Output

3

Time Complexity: O(√N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :