GFG App
Open App
Browser
Continue

# 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 = 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