Minimum Number of Keypresses

Minimum Number of Keypresses - Problem

You have a keypad with 9 buttons, numbered from 1 to 9, each mapped to lowercase English letters. You can choose which characters each button is matched to as long as:

All 26 lowercase English letters are mapped to.
Each character is mapped to by exactly 1 button.
Each button maps to at most 3 characters.

To type the first character matched to a button, you press the button once. To type the second character, you press the button twice, and so on.

Given a string s, return the minimum number of keypresses needed to type s using your keypad.

Note that the characters mapped to by each button, and the order they are mapped in cannot be changed.

Input & Output

Example 1 — Basic Case

$ Input: s = "abcde"

› Output: 5

💡 Note: Each letter appears once. Assign each to position 1 of different buttons: a(1), b(1), c(1), d(1), e(1) = 1+1+1+1+1 = 5 keypresses.

Example 2 — Repeated Letters

$ Input: s = "aabbcccdddd"

› Output: 11

💡 Note: Frequencies: d(4), c(3), a(2), b(2). Assign most frequent to position 1: d(1)×4 + c(1)×3 + a(1)×2 + b(1)×2 = 4+3+2+2 = 11.

Example 3 — Many Unique Letters

$ Input: s = "abcdefghijk"

› Output: 13

💡 Note: 11 unique letters, each appears once. First 9 letters get position 1 (9 keypresses), remaining 2 letters get position 2 (2×2=4 keypresses). Total: 9+4=13.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only

Visualization

Tap to expand

Asked in

G Google 25 f Meta 20 a Amazon 15

The key insight is that we want to minimize total keypresses by assigning the most frequent letters to positions requiring fewer presses. The optimal approach uses frequency counting + greedy assignment: count letter frequencies, sort by frequency descending, then assign the most frequent letters to button position 1, next most frequent to position 2, etc. Time: O(n + k log k), Space: O(k) where k ≤ 26.

Common Approaches

✓ Brute Force - Random Assignment

⏱️ Time: O(26!) Space: O(26)

Generate all possible ways to assign 26 letters to 9 buttons (max 3 per button), then calculate keypresses for each assignment and return minimum.

Frequency Count + Greedy Assignment

⏱️ Time: O(n + k log k) Space: O(k)

Count how often each letter appears in the string, sort by frequency, then greedily assign most frequent letters to button position 1, next most frequent to position 2, etc.

Brute Force - Random Assignment — Algorithm Steps

Generate all valid letter-to-button assignments
For each assignment, calculate total keypresses for string s
Return minimum keypresses found

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how often each letter appears

Try Random Assignments

Randomly assign letters to button positions

Calculate & Compare

Sum keypresses and keep minimum

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);  // Descending order
}

int solution(char* s) {
    int freq[26] = {0};
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Get all non-zero frequencies
    int frequencies[26];
    int count = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            frequencies[count++] = freq[i];
        }
    }
    
    // Sort frequencies in descending order
    qsort(frequencies, count, sizeof(int), compare);
    
    int totalPresses = 0;
    int pos = 1;
    int countAtPos = 0;
    
    for (int i = 0; i < count; i++) {
        totalPresses += frequencies[i] * pos;
        countAtPos++;
        
        // Each position can have at most 9 characters
        if (countAtPos == 9) {
            pos++;
            countAtPos = 0;
        }
    }
    
    return totalPresses;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(26!)

Factorial combinations of assigning 26 letters to button positions

✓ Linear Growth

Space Complexity

O(26)

Storage for current assignment mapping

✓ Linear Space

23.8K Views

Medium Frequency

~15 min Avg. Time

850 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

Brute Force - Random Assignment — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler