Decode Ways

Decode Ways - Problem

You have intercepted a secret message encoded as a string of numbers. The message is decoded via the following mapping:

"1" -> 'A', "2" -> 'B', ..., "25" -> 'Y', "26" -> 'Z'

However, while decoding the message, you realize that there are many different ways you can decode the message because some codes are contained in other codes ("2" and "5" vs "25").

For example, "11106" can be decoded into:

"AAJF" with the grouping (1, 1, 10, 6)
"KJF" with the grouping (11, 10, 6)

The grouping (1, 11, 06) is invalid because "06" is not a valid code (only "6" is valid).

Note: There may be strings that are impossible to decode.

Given a string s containing only digits, return the number of ways to decode it. If the entire string cannot be decoded in any valid way, return 0.

Input & Output

Example 1 — Basic Case

$ Input: s = "12"

› Output: 2

💡 Note: Two ways to decode: "1"+"2" → AB, or "12" → L. Both are valid decodings.

Example 2 — Multiple Options

$ Input: s = "226"

› Output: 3

💡 Note: Three ways: "2"+"2"+"6" → BBF, "2"+"26" → BZ, "22"+"6" → VF. All valid decodings.

Example 3 — Leading Zero

$ Input: s = "06"

› Output: 0

💡 Note: Cannot decode because "06" is invalid (leading zero) and "0" alone is invalid. No valid decodings.

Constraints

1 ≤ s.length ≤ 100
s contains only digits
s may have leading zeros

Visualization

Tap to expand

Asked in

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

The key insight is that each position depends on the previous 1-2 positions, making it a perfect dynamic programming problem. The optimal approach uses space-optimized DP with two variables. Time: O(n), Space: O(1).

Common Approaches

✓ Dynamic Programming

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

Create a DP array where dp[i] represents the number of ways to decode string from index i to end. Fill from right to left using recurrence relation.

Memoized Recursion

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

Same recursive approach but store results in a memo table to avoid redundant calculations. Each unique starting index is computed only once.

Recursive Brute Force

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

At each position, try taking 1 digit or 2 digits (if valid) and recursively solve for the remaining string. Count all valid complete decodings.

Space-Optimized DP

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

Since we only need the next two DP values to compute current value, we can use two variables instead of a full array, reducing space complexity to O(1).

Dynamic Programming — Algorithm Steps

Create dp array of size n+1
Initialize dp[n] = 1 (empty string)
Fill dp[i] using dp[i+1] and dp[i+2]
Return dp[0]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set dp[n] = 1 for empty string

Fill DP

Work backwards, computing dp[i] from dp[i+1] and dp[i+2]

Result

Return dp[0] as final answer

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    if (n == 0 || s[0] == '0') {
        return 0;
    }
    
    int* dp = (int*)calloc(n + 1, sizeof(int));
    dp[n] = 1;
    
    for (int i = n - 1; i >= 0; i--) {
        if (s[i] == '0') {
            dp[i] = 0;
        } else {
            dp[i] = dp[i + 1];
            if (i + 1 < n) {
                int twoDigit = (s[i] - '0') * 10 + (s[i + 1] - '0');
                if (twoDigit >= 10 && twoDigit <= 26) {
                    dp[i] += dp[i + 2];
                }
            }
        }
    }
    
    int result = dp[0];
    free(dp);
    return result;
}

int main() {
    char s[101];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string, constant work per position

✓ Linear Growth

Space Complexity

O(n)

DP array stores result for each position

⚡ Linearithmic Space

89.3K Views

High Frequency

~25 min Avg. Time

2.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

Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler