Letter Combinations of a Phone Number - Practice Coding Problems

Letter Combinations of a Phone Number - Problem

Letter Combinations of a Phone Number

Remember the old phone keypads where you had to press keys multiple times to type letters? This problem takes us back to that era!

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. The mapping follows the classic telephone keypad:

2: ABC, 3: DEF, 4: GHI, 5: JKL, 6: MNO, 7: PQRS, 8: TUV, 9: WXYZ

For example, if someone gives you "23", you need to find all ways to combine letters from key 2 (A, B, C) with letters from key 3 (D, E, F). The result would be: ["AD", "AE", "AF", "BD", "BE", "BF", "CD", "CE", "CF"]

Goal: Generate all possible text combinations that could be typed using the given sequence of key presses.
Input: A string of digits (2-9)
Output: Array of all possible letter combinations

Input & Output

example_1.py — Basic Case

$ Input: digits = "23"

› Output: ["ad","ae","af","bd","be","bf","cd","ce","cf"]

💡 Note: Digit '2' maps to 'abc' and digit '3' maps to 'def'. We form all combinations by pairing each letter from '2' with each letter from '3': a with d/e/f, b with d/e/f, c with d/e/f.

example_2.py — Empty Input

$ Input: digits = ""

› Output: []

💡 Note: When the input string is empty, there are no digits to process, so we return an empty array.

example_3.py — Single Digit

$ Input: digits = "2"

› Output: ["a","b","c"]

💡 Note: For a single digit '2', we simply return all the letters it maps to: 'a', 'b', and 'c'.

Constraints

0 ≤ digits.length ≤ 4
digits[i] is a digit in the range ['2', '9']
The maximum number of combinations is 4⁴ = 256 (when all digits are 7 or 9)

Visualization

Tap to expand

Choose: Pick a letter for current digit (e.g., 'A' for digit '2')2. Explore: Recursively solve for remaining digits ('3' → D, E, F)3. Collect: When no more digits, add combination to results4. Backtrack: Return to previous choice and try next option5. Repeat: Continue until all paths in the decision tree are explored

Understanding the Visualization

Map digits to letters

Create the phone keypad mapping: 2→ABC, 3→DEF, etc.

Start recursive exploration

Begin at the root with empty combination, process first digit

Branch for each choice

For each possible letter, create a branch and recurse to next digit

Collect complete paths

When all digits are processed, add the combination to results

Backtrack and continue

Return to previous level and try next option until all paths explored

Key Takeaway

🎯 Key Insight: Use backtracking to systematically explore all possible paths in the decision tree, building combinations one character at a time and collecting results when complete paths are found.

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The backtracking approach is optimal for this problem. We build combinations character by character, exploring all possible paths in the decision tree. The key insight is to use recursive backtracking to generate combinations incrementally, making one choice at a time for each digit and exploring all possibilities systematically.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(3^N × 4^M)	O(3^N × 4^M)	Use recursive backtracking to build combinations character by character

Backtracking (Optimal) — Algorithm Steps

Create a mapping from digits to their corresponding letters
Define a backtrack function that builds combinations recursively
For each digit, try all its possible letters
Add current letter to the path and recurse to the next digit
When we've processed all digits, add the complete combination to results
Backtrack by removing the current choice and trying the next option

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at root

Begin with empty string, first digit '2'

Branch on first digit

Try each letter: A, B, C

Recurse for each branch

For each choice, explore next digit '3': D, E, F

Collect leaf nodes

Complete paths become our final combinations

Code -

solution.c — C

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

char phoneMap[10][5] = {
    "", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"
};

int totalCombinations;
char** result;
int resultIndex;

void backtrack(char* digits, int index, char* current, int len) {
    if (index == len) {
        result[resultIndex] = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result[resultIndex], current);
        resultIndex++;
        return;
    }
    
    int digit = digits[index] - '0';
    char* letters = phoneMap[digit];
    
    for (int i = 0; i < strlen(letters); i++) {
        current[index] = letters[i];
        current[index + 1] = '\0';
        backtrack(digits, index + 1, current, len);
    }
}

char** letterCombinations(char* digits, int* returnSize) {
    int len = strlen(digits);
    if (len == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    totalCombinations = 1;
    for (int i = 0; i < len; i++) {
        totalCombinations *= strlen(phoneMap[digits[i] - '0']);
    }
    
    result = (char**)malloc(totalCombinations * sizeof(char*));
    resultIndex = 0;
    
    char current[len + 1];
    current[0] = '\0';
    
    backtrack(digits, 0, current, len);
    
    *returnSize = totalCombinations;
    return result;
}

int main() {
    char digits[10];
    scanf("%s", digits);
    if (digits[0] == '"') {
        memmove(digits, digits + 1, strlen(digits));
        digits[strlen(digits) - 1] = '\0';
    }
    
    int returnSize;
    char** combinations = letterCombinations(digits, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", combinations[i]);
        if (i < returnSize - 1) printf(",");
        free(combinations[i]);
    }
    printf("]\n");
    free(combinations);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^N × 4^M)

Where N is the number of digits mapping to 3 letters (2,3,4,5,6,8) and M is the number of digits mapping to 4 letters (7,9). We generate all possible combinations.

✓ Linear Growth

Space Complexity

O(3^N × 4^M)

Space to store all combinations plus O(N) recursion stack depth where N is the number of digits

✓ Linear Space

89.3K Views

High Frequency

~15 min Avg. Time

1.8K 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

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler