Javascript – find all Possible Decoding of given digit sequence

Your idea with recursion is fine, and yes, this only needs one index (since there is only one string to iterate). At each stage your function will try the two possibilities. But that is where you have a bug: before looking into the case where you take two digits, you should ensure that the string still has that many characters available.

In that case + str[i + 1] will be undefined, and although you have provision for that case with || '' this means you make the recursive call with newStr itself (nothing appended to it), while still skipping the last character at i. In your example this means you output first aabc (correct), but then also aab, skipping the input "3" because there was no second character following it.

The fix is to replace this:

encrypt(str, i + 2, newStr + (alphabetMap[str[i] + str[i + 1]] || ''));

with this:

if (i + 2 <= str.length && alphabetMap[str[i] + str[i + 1]]){
    encrypt(str, i + 2, newStr + alphabetMap[str[i] + str[i + 1]]);
}

…so that you only apply the recursion when there are at least two digits, and that digit pair has a mapping. Now it will output the correct result. It is true you could rely on the undefined behaviour and leave out the length check, but the check on the existence of the mapping is a requirement for going into recursion. The call should not be made otherwise.

Other remarks

• Don’t use a global variable to collect the results. This is not good and would give you wrong results when you call the function multiple times from the main program.

• I would not pass the partial code (newStr) as an argument to the recursive call. It seems more elegant to have the recursive call return the possible codes for the substring it received, and let the caller do the job of prefixing those with the current letter. That way it works from the inside-out (post order processing)

• Passing the start index is fine, but JavaScript is quite efficient with slicing strings (using string kerning), so you could just pass the string slice instead of the original string. This reduces the number of arguments to just one.

• Instead of building the result in such a way that the function returns the list of codes (which is way better than populating a global variable), you could also yield the codes using a generator.

• You don’t really need the alphabet map, as it is straightforward to do the decoding directly with String.fromCharCode.

Here is how that would turn out:

function* encryptIter(str) {
    if (!str) return yield "";
    for (let len = 1; len <= 2; len++) {
        const code = String.fromCharCode(96 + +str.slice(0, len));
        if (str.length >= len && code <= "z") {
            for (const result of encrypt(str.slice(len))) {
                // Prefix the current code to the results for the shorter string
                yield code + result;
            }
        }
    }
}

const encrypt = (str) => [...encryptIter(str)];

const res = encrypt("1123");
console.log(res);