# 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 = 3Output:3Explanation:

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 = 7Output:7

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

- If
**N = P**where_{1}*P_{2}*P_{m}**{P**are the prime numbers then one can perform the following moves:_{1}, P_{2}, …, P_{m}}- First, copy the string and then paste it
**(P**times._{1}– 1) - Similarly, again copying the string and pasting it for
**(P**times._{2}– 1) - Performing
**M**times with the remaining prime number, one will get the string with**N**number of**A’s**.

- First, copy the string and then paste it
- Therefore, the total number of minimum moves needed is given by
**(P**._{1}+ P_{2}+ … + 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.