4 Keys Keyboard - Practice Coding Problems

4 Keys Keyboard - Problem

4 Keys Keyboard - Maximize Character Output

Imagine you have a special keyboard with only four keys that can help you print the maximum number of 'A' characters on screen:

Key A: Print one 'A' on the screen
Ctrl-A: Select all text currently on screen
Ctrl-C: Copy the selected text to clipboard
Ctrl-V: Paste clipboard content, appending it to existing text

Given an integer n representing the maximum number of key presses allowed, your goal is to find the maximum number of 'A' characters you can display on screen.

Key Strategy: At some point, it becomes more efficient to use the copy-paste sequence (Ctrl-A, Ctrl-C, Ctrl-V, Ctrl-V, ...) rather than just pressing 'A' repeatedly. The challenge is determining the optimal switching point!

Input & Output

example_1.py — Small Input

$ Input: n = 3

› Output: 3

💡 Note: We can only press A 3 times: A A A. Copy-paste would require at least 4 operations (A, Ctrl-A, Ctrl-C, Ctrl-V), so it's not beneficial.

example_2.py — Optimal Copy-Paste

$ Input: n = 7

› Output: 9

💡 Note: Optimal strategy: A A A (3 A's), then Ctrl-A Ctrl-C V V. This gives us 3 + 3 + 3 = 9 A's total. The sequence uses exactly 7 operations: A A A Ctrl-A Ctrl-C V V.

example_3.py — Larger Input

$ Input: n = 9

› Output: 12

💡 Note: Best strategy: A A A A (4 A's), then Ctrl-A Ctrl-C V V V. This gives us 4 × 3 = 12 A's total, using all 9 operations optimally.

Visualization

Tap to expand

Understanding the Visualization

Start Simple

For small n (≤3), just press A repeatedly

Consider Copy-Paste

At n=4+, evaluate: continue pressing A vs. copy-paste strategy

Find Break-Even Point

Copy-paste needs 3 operations minimum (Ctrl-A, Ctrl-C, Ctrl-V)

Optimal Strategy

Use DP to find best copy source for each position

Maximum Result

Choose strategy that gives maximum A's for given operations

Key Takeaway

🎯 Key Insight: The optimal strategy balances between building a good copy source and having enough operations left to paste multiple times. Usually copying when you have around n/3 to n/2 A's works best.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we check all previous positions as potential copy sources

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store results for all positions from 1 to n

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 50
You can only use the four specified keys
All operations take exactly one key press
The screen starts empty

Asked in

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

The optimal solution uses dynamic programming to build up results from smaller subproblems. The key insight is recognizing when copy-paste becomes more efficient than just pressing 'A'. For any position, we either add one more 'A' or use a previous state as our copy source. Time complexity: O(n²), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(n²)	O(n)	Build solution using previously computed optimal results
Brute Force (Try All Copy Points)	O(n³)	O(1)	Try every possible point to start copy-paste sequence

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create DP array where dp[i] = max A's with i key presses
Base cases: dp[1]=1, dp[2]=2, dp[3]=3 (just press A)
For each i from 4 to n, consider all possible copy sources
For each copy source j, calculate: copy j A's then paste with remaining operations
Take maximum across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Base Cases

dp[1]=1, dp[2]=2, dp[3]=3

dp[4]

max(dp[3]+1, copy from dp[1]) = max(4, 3) = 4

dp[5]

max(dp[4]+1, copy from dp[1], dp[2]) = max(5, 4, 4) = 5

dp[6]

max(dp[5]+1, copies) = max(6, 5, 6, 6) = 6

dp[7]

max(dp[6]+1, copies) = max(7, 6, 8, 9) = 9

Code -

solution.c — C

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

int max(int a, int b) {
    return a > b ? a : b;
}

int maxA(int n) {
    if (n <= 3) return n;
    
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 1; i <= 3; i++) {
        dp[i] = i;
    }
    
    for (int i = 4; i <= n; i++) {
        dp[i] = dp[i - 1] + 1;
        
        for (int j = 1; j < i - 2; j++) {
            int remainingOps = i - j - 2;
            if (remainingOps > 0) {
                int totalAs = dp[j] * (1 + remainingOps);
                dp[i] = max(dp[i], totalAs);
            }
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we check all previous positions as potential copy sources

⚠ Quadratic Growth

Space Complexity

O(n)

DP array to store results for all positions from 1 to n

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 50
You can only use the four specified keys
All operations take exactly one key press
The screen starts empty

38.0K Views

Medium Frequency

~18 min Avg. Time

950 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