Related Articles

# 2 Keys Keyboard Problem

• Difficulty Level : Easy
• Last Updated : 09 Jul, 2021

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)

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.

My Personal Notes arrow_drop_up