Minimum Number of Keypresses - Practice Coding Problems

Minimum Number of Keypresses - Problem

Imagine designing the optimal T9 keypad layout! You have a classic phone keypad with 9 buttons (numbered 1-9), and you need to map all 26 lowercase English letters to these buttons to minimize typing effort.

Here are the rules:
• Each button can hold at most 3 characters
• Every letter must be mapped to exactly one button
• To type the 1st character on a button: press 1 time
• To type the 2nd character on a button: press 2 times
• To type the 3rd character on a button: press 3 times

For example, if button 2 has ['a', 'b', 'c'], then typing 'a' costs 1 keypress, 'b' costs 2 keypresses, and 'c' costs 3 keypresses.

Goal: Given a string s, return the minimum total keypresses needed to type the entire string using your optimally designed keypad layout.

Input & Output

example_1.py — Basic Case

$ Input: s = "apple"

› Output: 5

💡 Note: Frequency: a(1), p(2), l(1), e(1). Assign 'p' to 1-press position (2×1=2), others to remaining 1-press positions (1×1 each=3). Total: 2+1+1+1=5

example_2.py — All Same Character

$ Input: s = "aaaaaa"

› Output: 6

💡 Note: Only character 'a' appears 6 times. Assign it to a 1-press position. Total keypresses: 6×1 = 6

example_3.py — Many Different Characters

$ Input: s = "abcdefghijklmnopqrstuvwxyz"

› Output: 60

💡 Note: All 26 letters appear once. First 9 get 1-press (9×1=9), next 9 get 2-press (9×2=18), last 8 get 3-press (8×3=24). Total: 9+18+24=51... Wait let me recalculate: 9×1 + 9×2 + 8×3 = 9+18+24=51

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Key insight: Only 26 letters exist, so sorting is O(26 log 26) = O(1)

Visualization

Tap to expand

Understanding the Visualization

Count Usage

Count how frequently each letter appears in your text

Rank by Frequency

Sort letters from most used to least used

Assign Strategically

Give the easiest positions (1-press) to most frequent letters

Calculate Cost

Sum up: frequency × position_cost for each letter

Key Takeaway

🎯 Key Insight: The greedy strategy works perfectly because we want to minimize frequency × cost. Always pair high frequency letters with low cost positions!

Asked in

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

The optimal solution uses a greedy approach: count character frequencies, sort by frequency, then assign the most frequent characters to positions requiring the fewest keypresses. First 9 characters get 1-press positions, next 9 get 2-press positions, and remaining 8 get 3-press positions. Time: O(n + 26 log 26).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(26!)	O(26)	Try every possible way to assign 26 letters to 9 buttons with at most 3 letters each
Greedy with Frequency Counting (Optimal)	O(n + 26 log 26)	O(26)	Count letter frequencies, then assign most frequent letters to positions requiring fewest keypresses

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all possible partitions of 26 letters into 9 groups of size ≤3
For each partition, try all permutations within each group
Calculate total keypresses for the input string using each arrangement
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Arrangement

Create one possible way to assign letters to 9 buttons

Calculate Cost

For each letter in input string, find its position and add keypresses

Try Next

Generate next arrangement and repeat

Code -

solution.c — C

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

int minimumKeypresses(char* s) {
    int freq[26] = {0};
    int len = strlen(s);
    
    // Count frequency
    for (int i = 0; i < len; i++) {
        freq[s[i] - 'a']++;
    }
    
    // Simple arrangement: first 9 letters get 1 press, next 9 get 2, rest get 3
    int total = 0;
    for (int i = 0; i < 26; i++) {
        int presses = (i / 9) + 1;
        if (presses > 3) presses = 3;
        total += freq[i] * presses;
    }
    
    return total;
}

Time & Space Complexity

Time Complexity

⏱️

O(26!)

We need to try all possible ways to assign and order 26 letters

✓ Linear Growth

Space Complexity

O(26)

Store current arrangement and frequency counts

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 (Try All Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler