Count Number of Texts

Count Number of Texts - Problem

Alice is texting Bob using her phone. The mapping of digits to letters is shown below:

Digit to Letter Mapping:

2: abc
3: def
4: ghi
5: jkl
6: mno
7: pqrs
8: tuv
9: wxyz

In order to add a letter, Alice has to press the key of the corresponding digit i times, where i is the position of the letter in the key.

For example, to add the letter 's', Alice has to press '7' four times. Similarly, to add the letter 'k', Alice has to press '5' twice.

Note: The digits '0' and '1' do not map to any letters, so Alice does not use them.

However, due to an error in transmission, Bob did not receive Alice's text message but received a string of pressed keys instead.

For example, when Alice sent the message "bob", Bob received the string "2266622".

Given a string pressedKeys representing the string received by Bob, return the total number of possible text messages Alice could have sent.

Since the answer may be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

$ Input: pressedKeys = "22"

› Output: 2

💡 Note: Two ways to decode "22": 1) Press '2' once for 'a', then '2' once for 'a' → "aa", 2) Press '2' twice for 'b' → "b"

Example 2 — Multiple Digits

$ Input: pressedKeys = "222"

› Output: 3

💡 Note: Three ways: 1) "aaa" (2+2+2), 2) "ab" (2+22), 3) "ba" (22+2). Cannot use 222 as '2' key has only 3 letters (abc)

Example 3 — Different Digits

$ Input: pressedKeys = "23"

› Output: 1

💡 Note: Only one way: 1) "ad" (2+3). Cannot combine different digits or split differently.

Constraints

1 ≤ pressedKeys.length ≤ 10⁵
pressedKeys consists of digits ["2", "9"]
pressedKeys only contains valid phone keypad digits

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is recognizing this as a decode ways problem where we count valid ways to split consecutive same digits. Best approach uses dynamic programming to build solution bottom-up. Time: O(n), Space: O(n)

Common Approaches

✓ Sort First

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

Dynamic Programming (Bottom-Up)

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

Create a DP array where dp[i] represents the number of valid decodings starting from position i. Fill the array from right to left, where each position's value depends on the valid ways to extend from that position.

Memoized Recursion

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

Same recursive approach as brute force, but store results of each starting position in a cache. When we encounter the same starting position again, return the cached result instead of recalculating.

Recursive Brute Force

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

For each position, try taking 1, 2, 3, or 4 consecutive same digits (depending on the digit) and recursively solve for the remaining string. This explores all possible combinations but recalculates the same subproblems multiple times.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_LEN 10000

static char pressedKeys[MAX_LEN];
static int memo[MAX_LEN];
static int memo_set[MAX_LEN];
static int n;

int getValidLength(char digit) {
    switch (digit) {
        case '2': case '3': case '4': case '5': case '6': case '8': return 3;
        case '7': case '9': return 4;
        default: return 0;
    }
}

int dp(int index) {
    if (index == n) {
        return 1;
    }
    
    if (memo_set[index]) {
        return memo[index];
    }
    
    char digit = pressedKeys[index];
    int max_len = getValidLength(digit);
    if (max_len == 0) {
        memo[index] = 0;
        memo_set[index] = 1;
        return 0;
    }
    
    long long count = 0;
    int max_possible = (max_len < n - index) ? max_len : (n - index);
    
    for (int length = 1; length <= max_possible; length++) {
        int valid = 1;
        for (int i = index; i < index + length; i++) {
            if (pressedKeys[i] != digit) {
                valid = 0;
                break;
            }
        }
        
        if (valid) {
            count = (count + dp(index + length)) % MOD;
        } else {
            break;
        }
    }
    
    memo[index] = count;
    memo_set[index] = 1;
    return count;
}

int solution(char* keys) {
    strcpy(pressedKeys, keys);
    n = strlen(pressedKeys);
    
    memset(memo, 0, sizeof(memo));
    memset(memo_set, 0, sizeof(memo_set));
    
    return dp(0);
}

int main() {
    char input[MAX_LEN];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    int len = strlen(input);
    if (len > 0 && input[len-1] == '\n') {
        input[len-1] = '\0';
    }
    
    int result = solution(input);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

85.0K Views

Medium Frequency

~25 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