2 Keys Keyboard Problem

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 = P₁*P₂*P_m where {P₁, P₂, …, P_m} are the prime numbers then one can perform the following moves:
   1. First, copy the string and then paste it (P₁ – 1) times.
   2. Similarly, again copying the string and pasting it for (P₂ – 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 (P₁ + P₂ + … + P_m).

Follow the steps below to solve the problem:

• Initialize a variable, say ans as 0, that stores the resultant number of operations.
• Find the prime factors and its power of the given integer N.
• Now, iterate through all the prime factors of N and increment the value of ans by the product of the prime factor and its power.
• Finally, after completing the above steps, print the value of ans as the resultant minimum number of moves.

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)