2 Keys Keyboard

2 Keys Keyboard - Problem

There is only one character 'A' on the screen of a notepad. You can perform one of two operations on this notepad for each step:

Copy All: You can copy all the characters present on the screen (a partial copy is not allowed).
Paste: You can paste the characters which are copied last time.

Given an integer n, return the minimum number of operations to get the character 'A' exactly n times on the screen.

Input & Output

Example 1 — Basic Case

$ Input: n = 3

› Output: 3

💡 Note: Initially we have 1 'A'. Copy All (1 op) → clipboard has 'A', screen has 'A'. Paste (1 op) → screen has 'AA'. Paste (1 op) → screen has 'AAA'. Total: 3 operations.

Example 2 — Composite Number

$ Input: n = 9

› Output: 6

💡 Note: Optimal path: Copy 1A → Paste to get 3A (3 ops), then Copy 3A → Paste to get 6A → Paste to get 9A (3 more ops). Total: 6 operations. This equals 3+3 (prime factors of 9 = 3²).

Example 3 — Prime Number

$ Input: n = 7

› Output: 7

💡 Note: Since 7 is prime, we can only paste one by one: Copy 1A, then paste 6 times to get 7A. Total: 7 operations.

Constraints

1 ≤ n ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 A Amazon 22

The key insight is that this problem is equivalent to prime factorization. The minimum operations needed equals the sum of all prime factors of n (including duplicates). Best approach uses prime factorization in O(√n) time and O(1) space.

Common Approaches

✓ 1D Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

We build up the solution from smaller values. For each i, we check all its divisors j and see if copying j characters and pasting i/j-1 times gives a better result.

Brute Force Recursion

⏱️ Time: O(2^n) Space: O(n)

At each step, we can either copy all current characters or paste the previously copied characters. We recursively explore all possibilities and return the minimum operations needed.

Memoization (Top-Down DP)

⏱️ Time: O(n²) Space: O(n²)

We optimize the recursive solution by storing results of previously computed states. Each state is defined by current screen count and clipboard count.

Prime Factorization (Optimal)

⏱️ Time: O(√n) Space: O(1)

This problem is equivalent to finding the sum of prime factors. To get n characters optimally, we need to factorize n and the sum of all prime factors gives us the answer.

1D Dynamic Programming — Algorithm Steps

Initialize dp array where dp[i] = min operations for i characters
For each i from 2 to n, check all divisors
For divisor j, consider dp[j] + i/j operations
Take minimum across all divisors

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

dp[1] = 0, others = infinity

Fill DP Table

For each i, check all divisors j

Optimal Result

dp[n] contains minimum operations

Code -

solution.c — C

#include <stdio.h>
#include <limits.h>

int solution(int n) {
    if (n == 1) return 0;
    
    int dp[n + 1];
    for (int i = 0; i <= n; i++) {
        dp[i] = INT_MAX;
    }
    dp[1] = 0;
    
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j < i; j++) {
            if (i % j == 0) {
                // Copy j characters, then paste (i/j - 1) times
                int ops = dp[j] + i / j;
                if (ops < dp[i]) {
                    dp[i] = ops;
                }
            }
        }
    }
    
    return dp[n];
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", solution(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each i from 1 to n, we check all potential divisors from 1 to i

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n to store minimum operations for each count

⚠ Quadratic Space

78.6K Views

Medium Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

1D Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler