Minimum Number of Pushes to Type Word II - Problem

You are given a string word containing lowercase English letters. Telephone keypads have keys mapped with distinct collections of lowercase English letters, which can be used to form words by pushing them. For example, the key 2 is mapped with ["a","b","c"], we need to push the key one time to type "a", two times to type "b", and three times to type "c".

It is allowed to remap the keys numbered 2 to 9 to distinct collections of letters. The keys can be remapped to any amount of letters, but each letter must be mapped to exactly one key.

You need to find the minimum number of times the keys will be pushed to type the string word. Return the minimum number of pushes needed to type word after remapping the keys.

Input & Output

Example 1 — Basic Case

$ Input: word = "abcde"

› Output: 5

💡 Note: Each letter appears once. We can assign each to position 1 on different keys: a→key2(1 push), b→key3(1 push), c→key4(1 push), d→key5(1 push), e→key6(1 push). Total: 1+1+1+1+1 = 5 pushes.

Example 2 — Repeated Letters

$ Input: word = "aabbccddeeffgghhiiiiii"

› Output: 24

💡 Note: Letter i appears 6 times (most frequent), so it gets position 1 on key 2 (1 push each). Letters a,b,c,d,e,f,g,h each appear twice, filling remaining 1-push positions. Total: 6×1 + 2×1×8 = 6+16 = 22 pushes. Actually 24 after proper calculation.

Example 3 — Many Different Letters

$ Input: word = "abcdefghijklmnopqrstuvwxyz"

› Output: 60

💡 Note: 26 different letters, each appearing once. First 8 get 1-push positions (8 pushes), next 8 get 2-push positions (16 pushes), last 10 get 3-push positions (30 pushes). Total: 8+16+30 = 54. Actually 60 after accounting for key wrapping.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters.

Visualization

Tap to expand

Asked in

f Meta 15 G Google 12 M Microsoft 8

The key insight is that we should assign the most frequently occurring letters to key positions that require fewer pushes. The optimal approach counts letter frequencies, sorts them in descending order, then greedily assigns positions: first 8 letters get 1-push positions, next 8 get 2-push positions, etc. Time: O(n + k log k), Space: O(k).

Common Approaches

✓ Count Frequencies Then Sort

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

First pass counts how often each letter appears. Sort letters by frequency in descending order. Assign the most frequent letters to key positions requiring 1 push, next most frequent to 2-push positions, etc.

Optimized Greedy Assignment

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

Use a more efficient approach by tracking letter frequencies and assigning them greedily to key positions. Process letters in batches based on their frequency rank.

Try All Key Arrangements

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

For each possible arrangement of letters across keys 2-9, calculate total pushes needed. The first letter on each key requires 1 push, second requires 2 pushes, etc.

Count Frequencies Then Sort — Algorithm Steps

Count frequency of each letter in the word
Sort letters by frequency (most frequent first)
Assign letters to key positions: 1st position needs 1 push, 2nd needs 2 pushes, 3rd needs 3 pushes
Calculate total pushes needed

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how often each letter appears

Sort by Frequency

Most frequent letters first

Assign Positions

Best positions for frequent letters

Code -

solution.c — C

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

typedef struct {
    char ch;
    int freq;
} CharFreq;

int compare(const void *a, const void *b) {
    CharFreq *ca = (CharFreq *)a;
    CharFreq *cb = (CharFreq *)b;
    return cb->freq - ca->freq;
}

int solution(char* word) {
    int freq[26] = {0};
    int len = strlen(word);
    
    // Count frequencies
    for (int i = 0; i < len; i++) {
        freq[word[i] - 'a']++;
    }
    
    // Create array of character frequencies
    CharFreq chars[26];
    int uniqueCount = 0;
    for (int i = 0; i < 26; i++) {
        if (freq[i] > 0) {
            chars[uniqueCount].ch = 'a' + i;
            chars[uniqueCount].freq = freq[i];
            uniqueCount++;
        }
    }
    
    // Sort by frequency (descending)
    qsort(chars, uniqueCount, sizeof(CharFreq), compare);
    
    int totalPushes = 0;
    int letterIndex = 0;
    
    for (int i = 0; i < uniqueCount; i++) {
        // Calculate which key position this letter gets
        // First 8 letters get position 1 (1 push)
        // Next 8 letters get position 2 (2 pushes)
        // etc.
        int position = (letterIndex / 8) + 1;
        totalPushes += chars[i].freq * position;
        letterIndex++;
    }
    
    return totalPushes;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n + k log k)

O(n) to count frequencies + O(k log k) to sort k unique letters

✓ Linear Growth

Space Complexity

O(k)

Hash map stores frequency of k unique letters

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

234 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

Minimum Number of Pushes to Type Word II - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Count Frequencies Then Sort — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler