# Decode Ways LeetCode Solution

Here, We see Decode Ways LeetCode Solution. This Leetcode problem is done in many programming languages like C++, Java, JavaScript, Python, etc. with different approaches.

# List of all LeetCode Solution

## Problem Statement

A message containing letters from `A-Z` can be encoded into numbers using the following mapping:

```'A' -> "1"
'B' -> "2"
...
'Z' -> "26"
```

To decode an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, `"11106"` can be mapped into:

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

Note that the grouping `(1 11 06)` is invalid because `"06"` cannot be mapped into `'F'` since `"6"` is different from `"06"`.

Given a string `s` containing only digits, return the number of ways to decode it.

The test cases are generated so that the answer fits in a 32-bit integer.

```Example 1:

Input: s = "12"
Output: 2
Explanation: "12" could be decoded as "AB" (1 2) or "L" (12).

Example 2:

Input: s = "226"
Output: 3
Explanation: "226" could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).

Example 3:

Input: s = "06"
Output: 0
Explanation: "06" cannot be mapped to "F" because of the leading zero ("6" is different from "06").
```

## Decode Ways Leetcode Solution C++

``````class Solution {
public:
int numDecodings(string s) {
if (s[0] == '0') return 0;
if (s.size() == 1) return 1;
int len = s.size(), dp[len];
dp[0] = 1;
dp[1] = (s[0] == '1' || s[0] == '2' && s[1] < '7' ? 1 : 0) + (s[1] != '0');
for (int i = 2; i < len; i++) {
if (s[i] == '0' && (s[i - 1] > '2' || s[i - 1] == '0')) return 0;
dp[i] = s[i] != '0' ? dp[i - 1] : 0;
if (s[i - 1] == '1' || s[i - 1] == '2' && s[i] < '7') dp[i] += dp[i - 2];
}
return dp[len - 1];
}
};```Code language: PHP (php)```

## Decode Ways Leetcode Solution Java

``````class Solution {
public int numDecodings(String s) {
Integer[] memo = new Integer[s.length() + 1];
return numDecodings(s, 0, memo);
}

private int numDecodings(String s, int index, Integer[] memo) {
if (index == s.length()) {
return 1;
}
if (s.charAt(index) == '0') {
return 0;
}
if (memo[index] != null) {
return memo[index];
}
int way1 = numDecodings(s, index + 1, memo);
int way2 = 0;
if (index < s.length() - 1 && Integer.parseInt(s.substring(index, index + 2)) <= 26) {
way2 = numDecodings(s, index + 2, memo);
}
memo[index] = way1 + way2;
return memo[index];
}
}```Code language: JavaScript (javascript)```

## Decode Ways Leetcode Solution JavaScript

``````var numDecodings = function(s) {
if (s == null || s.length === 0) return 0;
if (s[0] === '0') return 0;

const dp = new Array(s.length + 1).fill(0);

dp[0] = 1;
dp[1] = 1;

for (let i = 2; i <= s.length; i++) {
const a = Number(s.slice(i - 1, i));  // last one digit
if (a >= 1 && a <= 9) {
dp[i] += dp[i - 1];
}

const b = Number(s.slice(i - 2, i));  // last two digits
if (b >= 10 && b <= 26) {
dp[i] += dp[i - 2];
}
}
return dp[s.length];
};```Code language: JavaScript (javascript)```

## Decode Ways Leetcode Solution Python

``````class Solution(object):
def numDecodings(self, s):
if not s:
return 0

dp = [0 for x in range(len(s) + 1)]

dp[0] = 1
dp[1] = 0 if s[0] == "0" else 1   #(1)

for i in range(2, len(s) + 1):
# One step jump
if 0 < int(s[i-1:i]) <= 9:    #(2)
dp[i] += dp[i - 1]
# Two step jump
if 10 <= int(s[i-2:i]) <= 26: #(3)
dp[i] += dp[i - 2]
return dp[len(s)]``````
Scroll to Top