Decode Ways - Practice Coding Problems

Decode Ways - Problem

Secret Agent Decoder Challenge!

You're a secret agent who has intercepted an encrypted message consisting only of digits. The encryption follows a simple pattern where numbers map to letters: "1" → 'A', "2" → 'B', ..., "26" → 'Z'.

However, there's a twist! 🕵️ The same encoded string can often be decoded in multiple different ways because some codes overlap. For example:

• The string "12" could be decoded as "AB" (1→A, 2→B) or as "L" (12→L)
• The string "226" has 3 ways: "BBF" (2,2,6), "BZ" (2,26), or "VF" (22,6)

Important rules:
• Only numbers 1-26 are valid codes
• Leading zeros make a code invalid ("06" is invalid, but "6" is valid)
• If no valid decoding exists, return 0

Goal: Count the total number of different ways to decode the given string.

Input & Output

example_1.py — Basic case

$ Input: "12"

› Output: 2

💡 Note: Two ways to decode: "AB" (1,2) or "L" (12). Both are valid since 1≤12≤26.

example_2.py — Multiple possibilities

$ Input: "226"

› Output: 3

💡 Note: Three ways: "BBF" (2,2,6), "BZ" (2,26), or "VF" (22,6). All combinations form valid letter codes.

example_3.py — Invalid zero case

$ Input: "06"

› Output: 0

💡 Note: No valid decoding exists. "06" is invalid due to leading zero, and we can't decode an empty first part.

Visualization

Tap to expand

Understanding the Visualization

Start with blocks

Each digit is a potential block of size 1, pairs of digits are blocks of size 2

Check validity

Single blocks (1-9) are always valid, double blocks (10-26) are sometimes valid

Count combinations

Use DP to count all valid ways to combine blocks to build the complete structure

Build solution

Each position's count = ways using single block + ways using double block

Key Takeaway

🎯 Key Insight: This problem has optimal substructure - the number of ways to decode any position depends only on the ways to decode the next 1-2 positions, making it perfect for dynamic programming!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is computed only once and cached, so we do O(n) work total

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores results for up to n different positions, plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s contains only digits
s may contain leading zero(s)

Asked in

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

The optimal solution uses bottom-up dynamic programming in O(n) time. We build a DP array where dp[i] represents the number of ways to decode from index i to the end. The key insight is that each position's result depends only on the next two positions, making this a classic DP problem with optimal substructure.

Common Approaches

Approach	Time	Space	Notes
✓ Recursive with Memoization (Top-Down DP)	O(n)	O(n)	Optimize brute force by caching results to avoid recomputing subproblems
Recursive Brute Force	O(2^n)	O(n)	Try all possible ways to split the string using recursion
Bottom-Up Dynamic Programming (Optimal)	O(n)	O(n)	Build solution iteratively from smallest subproblems to avoid recursion

Recursive with Memoization (Top-Down DP) — Algorithm Steps

Use the same recursive approach as brute force
Add a memoization table (dictionary/map) to cache results
Before computing, check if result exists in cache
After computing, store result in cache
Return cached results for repeated subproblems

Visualization

Tap to expand

Step-by-Step Walkthrough

First computation

Compute dp(0) for "226" and cache result

Cache subproblems

Store results for dp(1), dp(2), dp(3) as we compute them

Reuse cached values

Any repeated calls return cached results instantly

Code -

solution.c — C

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

int memo[101];
int computed[101];

int dp(char* s, int index, int len) {
    if (index == len) {
        return 1;
    }
    
    if (computed[index]) {
        return memo[index];
    }
    
    if (s[index] == '0') {
        memo[index] = 0;
        computed[index] = 1;
        return 0;
    }
    
    int ways = 0;
    
    // Single digit
    ways += dp(s, index + 1, len);
    
    // Two digits
    if (index + 1 < len) {
        int twoDigit = (s[index] - '0') * 10 + (s[index + 1] - '0');
        if (twoDigit >= 10 && twoDigit <= 26) {
            ways += dp(s, index + 2, len);
        }
    }
    
    memo[index] = ways;
    computed[index] = 1;
    return ways;
}

int numDecodings(char* s) {
    memset(computed, 0, sizeof(computed));
    return dp(s, 0, strlen(s));
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each position is computed only once and cached, so we do O(n) work total

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores results for up to n different positions, plus recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ s.length ≤ 100
s contains only digits
s may contain leading zero(s)

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

Recursive with Memoization (Top-Down DP) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler