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

Minimum Number of Pushes to Type Word I - Problem

Imagine you have an old-school telephone keypad and need to type a word using T9-style input! 📱

You're given a string word containing distinct lowercase English letters. On a telephone keypad, each key (2-9) can be mapped to multiple letters. For example:

Key 2 might have ["a","b","c"] - press once for "a", twice for "b", three times for "c"
Key 3 might have ["d","e","f"] - press once for "d", twice for "e", etc.

The Challenge: You can remap the 8 keys (2-9) to any arrangement of letters you want! Each letter must be assigned to exactly one key, but keys can have different numbers of letters.

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

Key Insight: Since all letters in the word are distinct, this becomes an optimization problem about how to distribute letters across keys to minimize total presses!

Input & Output

example_1.py — Basic case

$ Input: word = "abc"

› Output: 3

💡 Note: We have 3 distinct letters. Optimally assign each to first position of 3 different keys: a→key2(1 press), b→key3(1 press), c→key4(1 press). Total: 1+1+1 = 3 presses.

example_2.py — More letters

$ Input: word = "abcdefghijklmnop"

› Output: 24

💡 Note: 16 distinct letters. First 8 letters get 1 press each (8 total), remaining 8 letters get 2 presses each (16 total). Total: 8+16 = 24 presses.

example_3.py — Single letter repeated

$ Input: word = "aaaaaa"

› Output: 1

💡 Note: Only 1 distinct letter 'a'. Assign it to first position of any key, requiring only 1 press total.

Constraints

1 ≤ word.length ≤ 10⁵
word consists of distinct lowercase English letters
The number of distinct letters is at most 26

Visualization

Tap to expand

Understanding the Visualization

Count Your Letters

First, figure out how many unique letters you need to type

Fill the Prime Spots

Put the first 8 letters in the best positions (1 press each) across all 8 keys

Use Second-Best Spots

Put the next 8 letters in position 2 (2 presses each) across the keys

Continue the Pattern

Keep filling positions 3, 4, etc. until all letters are assigned

Calculate Total Cost

Add up all the presses: 8×1 + 8×2 + 8×3 + ...

Key Takeaway

🎯 Key Insight: Since all letters are distinct, we use a greedy approach to place letters optimally across key positions, minimizing total presses by filling position 1 first (8 letters × 1 press), then position 2 (8 letters × 2 presses), and so on.

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal solution uses a greedy approach: since all letters are distinct, we want to minimize total key presses by placing letters optimally. With 8 keys available, we can place the first 8 letters in position 1 (1 press each), next 8 letters in position 2 (2 presses each), and so on. The formula is: Σ(⌊i/8⌋ + 1) for i = 0 to n-1, where n is the number of distinct letters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Arrangements)	O(8^n)	O(n)	Generate all possible ways to assign letters to keys and find minimum
Greedy Optimal Solution	O(n)	O(1)	Since letters are distinct, optimally distribute them to minimize total presses

Brute Force (Try All Arrangements) — Algorithm Steps

Generate all possible partitions of letters into 8 groups (keys)
For each partition, calculate total presses (position in key × frequency)
Track the minimum total presses across all partitions
Return the minimum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Unique Letters

Get all distinct letters from the word

Try Assignment 1

Assign letters to keys in one way, calculate total presses

Try Assignment 2

Try a different assignment, calculate presses

Continue...

Keep trying all possible assignments

Return Minimum

Return the assignment that gives minimum presses

Code -

solution.c — C

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

int calculatePushes(char* word, char* letters, int* assignment, int letterCount) {
    char keyLetters[8][100];
    int keyLengths[8] = {0};
    
    for (int i = 0; i < letterCount; i++) {
        int key = assignment[i];
        keyLetters[key][keyLengths[key]++] = letters[i];
    }
    
    int totalPushes = 0;
    for (int key = 0; key < 8; key++) {
        for (int pos = 0; pos < keyLengths[key]; pos++) {
            char letter = keyLetters[key][pos];
            int count = 0;
            for (int i = 0; word[i]; i++) {
                if (word[i] == letter) count++;
            }
            totalPushes += (pos + 1) * count;
        }
    }
    
    return totalPushes;
}

int findMinPushes(char* word, char* letters, int index, int* assignment, int letterCount) {
    if (index == letterCount) {
        return calculatePushes(word, letters, assignment, letterCount);
    }
    
    int minPushes = INT_MAX;
    for (int key = 0; key < 8; key++) {
        assignment[index] = key;
        int pushes = findMinPushes(word, letters, index + 1, assignment, letterCount);
        if (pushes < minPushes) {
            minPushes = pushes;
        }
    }
    
    return minPushes;
}

int minimumPushes(char* word) {
    bool seen[26] = {false};
    char letters[26];
    int letterCount = 0;
    
    for (int i = 0; word[i]; i++) {
        int idx = word[i] - 'a';
        if (!seen[idx]) {
            seen[idx] = true;
            letters[letterCount++] = word[i];
        }
    }
    
    int assignment[26];
    return findMinPushes(word, letters, 0, assignment, letterCount);
}

Time & Space Complexity

Time Complexity

⏱️

O(8^n)

Each of n letters can be assigned to any of 8 keys, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(n)

Space for storing current arrangement and tracking minimum

⚡ Linearithmic Space

24.6K 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 Arrangements) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler