Minimum Number of Pushes to Type Word II - Practice Coding Problems

Minimum Number of Pushes to Type Word II - Problem

Imagine you're customizing an old-school telephone keypad to type text messages as efficiently as possible! 📱

You're given a string word containing lowercase English letters. On a telephone keypad, keys 2-9 can each be mapped to different collections of letters. Traditionally, key 2 maps to ["a","b","c"] - you press it once for "a", twice for "b", and three times for "c".

Here's the twist: You can completely remap keys 2-9 to any letters you want! Each letter must be assigned to exactly one key, but you can put any number of letters on each key.

Your goal: Find the minimum number of key presses needed to type the entire word after optimally remapping the keys.

Key insight: Letters that appear more frequently should require fewer presses (be placed earlier on keys), while rare letters can require more presses.

Input & Output

example_1.py — Basic Case

$ Input: word = "abcde"

› Output: 5

💡 Note: We have 5 unique letters and 8 available keys. We can assign each letter to position 1 on different keys: a→key2(pos1), b→key3(pos1), c→key4(pos1), d→key5(pos1), e→key6(pos1). Total presses: 1+1+1+1+1 = 5.

example_2.py — Frequency Optimization

$ Input: word = "aabbccddeeffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"

› Output: 104

💡 Note: All 26 letters appear twice. First 8 letters (by frequency, all equal) get position 1 (1 press each), next 8 get position 2 (2 presses each), next 8 get position 3 (3 presses each), last 2 get position 4 (4 presses each). Total: 8×2×1 + 8×2×2 + 8×2×3 + 2×2×4 = 16+32+48+16 = 112. Wait, let me recalculate: 8×2×1 + 8×2×2 + 8×2×3 + 2×2×4 = 16+32+48+16 = 112. Actually, since frequencies are equal, we assign alphabetically: first 8 get pos1, etc. Total = 8×2×1 + 8×2×2 + 8×2×3 + 2×2×4 = 112.

example_3.py — High Frequency Letters

$ Input: word = "aabbbc"

› Output: 7

💡 Note: Letter frequencies: b→3, a→2, c→1. We assign: b→position1 (1 press), a→position1 (1 press), c→position1 (1 press). All three letters can fit in position 1 since we have 8 keys. Total presses: 3×1 + 2×1 + 1×1 = 6. Wait, that's wrong. Let me recalculate: b appears 3 times at 1 press each = 3, a appears 2 times at 1 press each = 2, c appears 1 time at 1 press each = 1. Total = 3+2+1 = 6.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
We have exactly 8 keys available (keys 2-9)
Each letter must be mapped to exactly one key

Visualization

Tap to expand

Understanding the Visualization

Count Popularity

Count how often each letter appears in the word

Sort by Demand

Arrange letters from most frequent to least frequent

Assign Prime Spots

Give the best positions (1 press) to the most popular letters

Calculate Efficiency

Sum up total presses needed across the entire word

Key Takeaway

🎯 Key Insight: The greedy approach works perfectly here - always assign the most frequent letters to the cheapest positions first to minimize total cost!

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses a greedy frequency-based approach: count letter frequencies, sort in descending order, and assign the most frequent letters to require the fewest key presses. Since we have 8 keys (2-9), the first 8 most frequent letters get position 1 (1 press), next 8 get position 2 (2 presses), and so on. This minimizes total cost because high-frequency letters incur low per-character costs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Mappings)	O(n! × n)	O(n)	Try every possible assignment of letters to keys and positions
Two-Pass: Count Then Sort	O(n + k log k)	O(k)	First pass counts letter frequencies, second pass assigns positions optimally
Optimized: Frequency-Based Greedy (Optimal)	O(n + k log k)	O(k)	Count frequencies and assign positions in optimal greedy order

Brute Force (Try All Mappings) — Algorithm Steps

Find all unique letters in the word
Generate all possible assignments of letters to key positions
For each assignment, calculate total presses needed
Return the minimum presses found

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Letters

Find unique letters and their frequencies

Generate Assignments

Create all possible ways to assign letters to key positions

Calculate Cost

For each assignment, sum up total key presses needed

Find Minimum

Return the assignment with minimum total presses

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    int *ia = (int*)a;
    int *ib = (int*)b;
    return *ib - *ia;
}

int minimumPushes(char* word) {
    int freq[26] = {0};
    int len = strlen(word);
    
    for (int i = 0; i < len; i++) {
        freq[word[i] - 'a']++;
    }
    
    int freqList[26];
    int uniqueCount = 0;
    
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            freqList[uniqueCount++] = freq[i];
        }
    }
    
    if (uniqueCount <= 8) {
        return len;
    }
    
    qsort(freqList, uniqueCount, sizeof(int), compare);
    
    int total = 0;
    for (int i = 0; i < uniqueCount; i++) {
        int pos = (i / 8) + 1;
        total += freqList[i] * pos;
    }
    
    return total;
}

int main() {
    char word[1000];
    scanf("%s", word);
    
    // Remove quotes if present
    int len = strlen(word);
    if (word[0] == '"' && word[len-1] == '"') {
        memmove(word, word + 1, len - 2);
        word[len - 2] = '\0';
    }
    
    printf("%d\n", minimumPushes(word));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! ways to assign letters to positions, O(n) to calculate cost for each assignment

⚠ Quadratic Growth

Space Complexity

O(n)

Space to store letter frequencies and current assignment

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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 Mappings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler