Skip to content
Related Articles

Related Articles

2 Keys Keyboard Problem

Improve Article
Save Article
  • Difficulty Level : Easy
  • Last Updated : 09 Jul, 2021
Improve Article
Save Article

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 <bits/stdc++.h>
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




<script>
 
// JavaScript Program for the above approach
// Function to find the minimum number
    // of steps required to form N number
    // of A's
    function minSteps(N)
    {
        // Stores the count of steps needed
        var ans = 0;
 
        // Traverse over the range [2, N]
        for (var 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
        var N = 3;
        minSteps(N);
        document.write(minSteps(N));
   
// This code is contributed by shivanisinghss2110
 
</script>

Output

3

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!