Open In App

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