Decode Ways II - Practice Coding Problems

Decode Ways II - Problem

Imagine you're a secret agent who needs to decode encrypted messages! 🕵️‍♂️

You have a special cipher where letters A-Z are mapped to numbers:

'A' → "1"
'B' → "2"
...
'Z' → "26"

But here's the twist: the encoded message might contain wildcard characters '*' that can represent any digit from 1 to 9 (not 0)!

Example: The string "1*" could represent "11", "12", "13", ..., "19" - that's 9 different possibilities!

Your mission: Given an encoded string s with digits and '*' characters, determine how many different ways you can decode it back into letters.

Important rules:

Leading zeros are invalid ("06" ≠ "6")
Only numbers 1-26 can be decoded to letters
Return the answer modulo 10⁹ + 7

Input & Output

example_1.py — Basic Wildcard

$ Input: s = "*"

› Output: 9

💡 Note: The wildcard '*' can represent any digit from 1-9, and each digit (1-9) corresponds to a valid letter (A-I), so there are 9 different ways to decode it.

example_2.py — Wildcard with Digit

$ Input: s = "1*"

› Output: 18

💡 Note: We can decode this as: (1) Single digits: '1' + any of '1'-'9' = 1×9 = 9 ways. (2) Two digits: '1*' can be '11'-'19' = 9 ways. Total: 9 + 9 = 18 ways.

example_3.py — Multiple Wildcards

$ Input: s = "2*"

› Output: 15

💡 Note: Single digits: '2' + any of '1'-'9' = 1×9 = 9 ways. Two digits: '2*' can be '21'-'26' (only 6 valid combinations since 27-29 > 26) = 6 ways. Total: 9 + 6 = 15 ways.

Visualization

Tap to expand

Understanding the Visualization

Setup Decoder

Initialize our decoder with base case: empty string has 1 way to decode

Handle First Character

If it's *, we have 9 ways (1-9). If it's a digit ≠ 0, we have 1 way

Process Each Position

For each new character, consider single-digit and two-digit decodings

Count Wildcard Possibilities

Multiply by valid digit combinations the wildcard can represent

Build Solution

Accumulate results in DP table, handling modular arithmetic

Key Takeaway

🎯 Key Insight: Dynamic Programming allows us to efficiently count all decoding possibilities by building solutions incrementally, handling wildcards by multiplying by their valid digit count at each step.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per position

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store intermediate results

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is a digit or '*'
No leading zeros in valid decodings
Answer should be returned modulo 10⁹ + 7

Asked in

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

The optimal solution uses Dynamic Programming with careful handling of wildcards. Key insight: at each position, consider both single-digit and two-digit decodings, multiplying by the number of valid wildcard possibilities. The DP table stores cumulative ways to decode up to each position, giving us O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Bottom-Up)	O(n)	O(n)	Build solution incrementally using DP table to handle wildcards efficiently
Brute Force (Generate All Possibilities)	O(9^k * 2^n)	O(n)	Generate all possible strings by replacing '*' and count valid decodings

Dynamic Programming (Bottom-Up) — Algorithm Steps

Create a DP array where dp[i] represents ways to decode string up to index i
Initialize base cases: empty string has 1 way, single valid digit has 1 way
For each position, consider single digit and two-digit decodings
Handle wildcards by summing over all possible digit values (1-9)
Return dp[n] as the final answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Base Cases

Set dp[0]=1 (empty string), dp[1] based on first character

Single Character Decode

Add ways from previous position if current char is valid

Two Character Decode

Add ways from two positions back if two-digit combo is valid

Handle Wildcards

Multiply by number of valid digits the wildcard can represent

Code -

solution.c — C

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

#define MOD 1000000007

int numDecodingsII(char* s) {
    int n = strlen(s);
    long long* dp = (long long*)calloc(n + 1, sizeof(long long));
    dp[0] = 1;
    
    if (s[0] == '*') {
        dp[1] = 9;
    } else if (s[0] != '0') {
        dp[1] = 1;
    } else {
        dp[1] = 0;
    }
    
    for (int i = 2; i <= n; i++) {
        char curr = s[i-1];
        char prev = s[i-2];
        
        // Single character decode
        if (curr == '*') {
            dp[i] = (dp[i] + 9 * dp[i-1]) % MOD;
        } else if (curr != '0') {
            dp[i] = (dp[i] + dp[i-1]) % MOD;
        }
        
        // Two character decode
        if (prev == '*') {
            if (curr == '*') {
                dp[i] = (dp[i] + 15 * dp[i-2]) % MOD;
            } else if (curr <= '6') {
                dp[i] = (dp[i] + 2 * dp[i-2]) % MOD;
            } else {
                dp[i] = (dp[i] + dp[i-2]) % MOD;
            }
        } else if (prev == '1') {
            if (curr == '*') {
                dp[i] = (dp[i] + 9 * dp[i-2]) % MOD;
            } else {
                dp[i] = (dp[i] + dp[i-2]) % MOD;
            }
        } else if (prev == '2') {
            if (curr == '*') {
                dp[i] = (dp[i] + 6 * dp[i-2]) % MOD;
            } else if (curr <= '6') {
                dp[i] = (dp[i] + dp[i-2]) % MOD;
            }
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    char s[1001];
    scanf("%s", s);
    
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    
    printf("%d\n", numDecodingsII(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, constant work per position

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store intermediate results

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is a digit or '*'
No leading zeros in valid decodings
Answer should be returned modulo 10⁹ + 7

67.8K Views

High 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Bottom-Up) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler