Count Number of Texts - Practice Coding Problems

Count Number of Texts - Problem

Alice is texting Bob using her old-school phone keypad. Remember those? Each number key maps to multiple letters, and to type a specific letter, you need to press the key multiple times!

The keypad mapping works like this:

Key 2: ABC (press 1×=A, 2×=B, 3×=C)
Key 3: DEF (press 1×=D, 2×=E, 3×=F)
Key 4: GHI (press 1×=G, 2×=H, 3×=I)
Key 5: JKL (press 1×=J, 2×=K, 3×=L)
Key 6: MNO (press 1×=M, 2×=N, 3×=O)
Key 7: PQRS (press 1×=P, 2×=Q, 3×=R, 4×=S)
Key 8: TUV (press 1×=T, 2×=U, 3×=V)
Key 9: WXYZ (press 1×=W, 2×=X, 3×=Y, 4×=Z)

For example, to type "bob", Alice would press: 2-22-666-2-22 → "2266622"

The Problem: Due to transmission errors, Bob only received the sequence of pressed keys (like "2266622") but lost the information about where one letter ends and another begins!

Given a string pressedKeys, return the total number of possible text messages Alice could have sent. Since the answer can be huge, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: pressedKeys = "22"

› Output: 2

💡 Note: Alice could have sent "aa" (press 2 twice) or "b" (press 2 twice). Both interpretations are valid.

example_2.py — Multiple Options

$ Input: pressedKeys = "222"

› Output: 3

💡 Note: Three possible messages: "aaa" (2+2+2), "ab" (2+22), or "ba" (22+2). Each grouping represents valid letter combinations.

example_3.py — Complex Sequence

$ Input: pressedKeys = "2266622"

› Output: 6

💡 Note: Multiple valid interpretations exist. For example: "bob" (22+666+22), "aoo" (2+666+22), "anm" (2+66+6+22), etc. Each valid parsing contributes to the total count.

Constraints

1 ≤ pressedKeys.length ≤ 10⁵
pressedKeys only contains digits [2-9]
Each digit corresponds to letters as on traditional phone keypads
Keys 7 and 9 have 4 letters each (PQRS, WXYZ)
All other keys have 3 letters each

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Each sequence of identical digits can form different letters based on length

Build Solutions Incrementally

Use DP to count ways: dp[i] = sum of dp[i-len] for all valid letter lengths

Handle Special Cases

Keys 7 and 9 have 4 letters (PQRS, WXYZ) while others have 3

Optimize with Modular Arithmetic

Keep results manageable with MOD = 10^9 + 7

Key Takeaway

🎯 Key Insight: This is a classic dynamic programming problem where we build up solutions by considering all valid ways to form letters at each position. The constraint that consecutive identical digits form letters makes this similar to the "Decode Ways" problem with additional rules.

Asked in

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

This problem is solved optimally using Dynamic Programming in O(n) time. The key insight is that the number of ways to decode a string ending at position i depends on how many ways we can decode smaller substrings. For each position, we try all valid letter lengths (1-3 for most keys, 1-4 for keys 7 and 9) and sum up the possibilities from previous positions. Memoization or bottom-up DP both work effectively.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(n)	O(n)	Build solution iteratively using dynamic programming table

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create a DP array where dp[i] represents ways to decode string[0:i]
Initialize dp[0] = 1 (empty string has 1 way)
For each position i, try all valid letter lengths ending at i
If characters are same within the letter length, add dp[i-length] to dp[i]
Return dp[n] as final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP array

dp[0] = 1 (empty string), all others start at 0

Process each position

For each position i, consider all valid letter lengths

Check character consistency

Ensure all characters in the letter range are identical

Update DP value

Add dp[i-length] to dp[i] for each valid letter

Code -

solution.c — C

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

#define MOD 1000000007

int min(int a, int b) {
    return a < b ? a : b;
}

int countTexts(char* pressedKeys) {
    int n = strlen(pressedKeys);
    
    // dp[i] = number of ways to decode pressedKeys[0:i]
    long long dp[n + 1];
    for (int i = 0; i <= n; i++) dp[i] = 0;
    dp[0] = 1; // Empty string has 1 way
    
    for (int i = 1; i <= n; i++) {
        char digit = pressedKeys[i - 1];
        int maxLen = (digit == '7' || digit == '9') ? 4 : 3;
        
        // Try all possible letter lengths ending at position i
        for (int length = 1; length <= min(maxLen, i); length++) {
            int valid = 1;
            for (int j = i - length; j < i; j++) {
                if (pressedKeys[j] != digit) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) {
                dp[i] = (dp[i] + dp[i - length]) % MOD;
            } else {
                break;
            }
        }
    }
    
    return (int) dp[n];
}

int main() {
    printf("%d\n", countTexts("22"));      // 2
    printf("%d\n", countTexts("222"));     // 3
    printf("%d\n", countTexts("2266622")); // 6
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, with at most 4 operations per position

✓ Linear Growth

Space Complexity

O(n)

DP array stores one value per string position

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler