Letter Combinations of a Phone Number - Problem

Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent. Return the answer in any order.

A mapping of digits to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.

Digit Mapping:

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

Input & Output

Example 1 — Two Digits

$ Input: digits = "23"

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

💡 Note: Digit 2 maps to 'abc', digit 3 maps to 'def'. Each letter from 2 combined with each letter from 3 gives 3×3=9 combinations.

Example 2 — Empty Input

$ Input: digits = ""

› Output: []

💡 Note: Empty input string returns empty array as no digits to process.

Example 3 — Single Digit

$ Input: digits = "2"

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

💡 Note: Single digit 2 maps to letters 'a', 'b', 'c', so return each letter as separate combination.

Constraints

0 ≤ digits.length ≤ 4
digits[i] is a digit in the range ['2', '9']

Visualization

Tap to expand

Asked in

M Meta 45 a Amazon 38 G Google 32 M Microsoft 28

The key insight is to systematically generate all possible combinations by either building them iteratively or using recursive backtracking. The backtracking approach is more memory efficient as it builds one path at a time. Time: O(4^n), Space: O(n) for backtracking.

Common Approaches

✓ Dfs

⏱️ Time: N/A Space: N/A

Backtracking - Recursive Exploration

⏱️ Time: O(4^n) Space: O(n)

Start with an empty combination and recursively add one character at a time. For each digit, try all possible letters, recurse to the next digit, then backtrack to try the next letter. This explores all possible paths systematically.

Brute Force - Iterative Generation

⏱️ Time: O(4^n) Space: O(4^n)

For each digit, generate all possible combinations by taking the current results and appending each possible letter for the next digit. This creates a new set of combinations for each digit processed.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

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

char** result;
int result_count;
int result_capacity;

void backtrack(char* digits, int index, char* current_combination, int len) {
    if (index == strlen(digits)) {
        if (result_count >= result_capacity) {
            result_capacity *= 2;
            result = (char**)realloc(result, result_capacity * sizeof(char*));
        }
        result[result_count] = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result[result_count], current_combination);
        result_count++;
        return;
    }
    
    int current_digit = digits[index] - '0';
    char* letters = phone_map[current_digit];
    
    for (int i = 0; i < strlen(letters); i++) {
        current_combination[len] = letters[i];
        current_combination[len + 1] = '\0';
        backtrack(digits, index + 1, current_combination, len + 1);
    }
}

char** solution(char* digits, int* returnSize) {
    *returnSize = 0;
    
    if (strlen(digits) == 0) {
        return NULL;
    }
    
    result_capacity = 100;
    result = (char**)malloc(result_capacity * sizeof(char*));
    result_count = 0;
    
    char current_combination[20];
    current_combination[0] = '\0';
    
    backtrack(digits, 0, current_combination, 0);
    
    *returnSize = result_count;
    return result;
}

int main() {
    char digits[100];
    if (fgets(digits, sizeof(digits), stdin)) {
        // Remove newline if present
        int len = strlen(digits);
        if (len > 0 && digits[len-1] == '\n') {
            digits[len-1] = '\0';
        }
    }
    
    int returnSize;
    char** result = solution(digits, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

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