2 Keys Keyboard - Practice Coding Problems

2 Keys Keyboard - Problem

Imagine you're working with a simple text editor that starts with a single character 'A' on the screen. This editor has a unique constraint - it only has two keys:

Copy All: Copies all characters currently on the screen to the clipboard (partial copying is not allowed)
Paste: Pastes whatever was last copied

Your goal is to find the minimum number of operations needed to get exactly n copies of the character 'A' on the screen.

Example: To get 3 A's:

Start: A
Copy All: A (clipboard now has 'A')
Paste: AA
Paste: AAA

Total: 3 operations

Input & Output

example_1.py — Simple case

$ Input: n = 3

› Output: 3

💡 Note: Start with A. Copy All (1 op) → clipboard has A. Paste (1 op) → AA. Paste (1 op) → AAA. Total: 3 operations. Prime factorization: 3 is prime, so answer is 3.

example_2.py — Composite number

$ Input: n = 9

› Output: 6

💡 Note: 9 = 3 × 3, so we need sum of prime factors = 3 + 3 = 6. Sequence: A → Copy+Paste+Paste → AAA → Copy+Paste+Paste → AAAAAAAAA (9 A's).

example_3.py — Edge case

$ Input: n = 1

› Output: 0

💡 Note: We already have 1 A on the screen, so no operations needed.

Visualization

Tap to expand

Understanding the Visualization

Factory Setup

Start with 1 item on the production line

Create Template

Copy All creates a template of your current production

Scale Production

Paste adds one template's worth of items to your line

Optimize Strategy

Prime factorization tells us the optimal copy-paste sequence

Key Takeaway

🎯 Key Insight: The minimum operations equals the sum of prime factors because each prime factor represents the most efficient copy-paste sequence for that multiplication step.

Time & Space Complexity

Time Complexity

⏱️

O(√n)

We only need to check factors up to √n, as larger factors would have been found as quotients

✓ Linear Growth

Space Complexity

O(1)

Only uses a few variables, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ n ≤ 1000
n is a positive integer
Time limit: 1 second per test case

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 15

The optimal solution uses prime factorization with O(√n) time complexity. The key insight is that the minimum operations equals the sum of all prime factors of n, where each prime factor represents an optimal copy-paste sequence.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-up)	O(n²)	O(n)	Build solutions from smaller subproblems using DP table
Prime Factorization (Optimal)	O(√n)	O(1)	Sum of all prime factors gives the minimum operations

Dynamic Programming (Bottom-up) — Algorithm Steps

Create DP array where dp[i] represents min operations for i A's
Initialize dp[1] = 0 (we start with 1 A)
For each i from 2 to n, try all possible factors
If j is a factor of i, we can reach i by: dp[j] + (i/j operations)
The i/j represents: 1 copy + (i/j - 1) pastes
Take minimum across all valid factors

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[1] = 0, others to infinity

Fill Table

For each i, try all factors j < i

Update Minimum

dp[i] = min(dp[i], dp[j] + i/j)

Final Answer

dp[n] contains the minimum operations

Code -

solution.c — C

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

int minSteps(int n) {
    if (n == 1) return 0;
    
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 0; i <= n; i++) {
        dp[i] = n; // Initialize with max possible value
    }
    dp[1] = 0;
    
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j < i; j++) {
            if (i % j == 0) {
                int cost = dp[j] + i / j;
                if (cost < dp[i]) {
                    dp[i] = cost;
                }
            }
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each number i, we check all potential factors j from 1 to i, leading to nested loops

⚠ Quadratic Growth

Space Complexity

O(n)

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

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
n is a positive integer
Time limit: 1 second per test case

67.4K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Bottom-up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler