Decrypt String from Alphabet to Integer Mapping

Decrypt String from Alphabet to Integer Mapping - Problem

String Easy

You are given a string s formed by digits and '#'. We want to map s to English lowercase characters as follows:

Characters ('a' to 'i') are represented by ('1' to '9') respectively.

Characters ('j' to 'z') are represented by ('10#' to '26#') respectively.

Return the string formed after mapping.

The test cases are generated so that a unique mapping will always exist.

Input & Output

Example 1 — Basic Mixed Pattern

$ Input: s = "10#11#12"

› Output: "jkab"

💡 Note: 10# maps to 'j' (10th letter), 11# maps to 'k' (11th letter), then we have '12' remaining without #, so these are processed as individual digits: 1→'a', 2→'b'. Final result: jkab

Example 2 — Only Single Digits

$ Input: s = "1326#"

› Output: "acz"

💡 Note: 1→'a', 3→'c', 26#→'z' (26th letter). The digits 1 and 3 are single digits since they're not part of a ## pattern.

Example 3 — Only Hash Patterns

$ Input: s = "25#"

› Output: "y"

💡 Note: 25# maps to 'y' (25th letter of alphabet). This is the simplest case with just one encoded character.

Constraints

1 ≤ s.length ≤ 1000
s consists only of digits and the '#' letter
s will be a valid string such that mapping is always possible

Visualization

Tap to expand

Asked in

a Amazon 25 M Microsoft 18

The key insight is to scan from right to left - when we see '#', we know the previous 2 digits form a code. Best approach uses right-to-left scanning for cleaner logic. Time: O(n), Space: O(1)

Common Approaches

✓ Left to Right Scanning

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

Iterate through the string from left to right. At each position, check if the next two characters form a pattern ending with #. If so, decode the two-digit number, otherwise decode the single digit.

Right to Left Scanning

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

Process the string from right to left. When we encounter a '#', we know the previous two characters form a two-digit code. Otherwise, we have a single digit. This eliminates the need to look ahead.

Left to Right Scanning — Algorithm Steps

Iterate through string from left to right
Check if current position + 2 forms a # pattern
Decode accordingly and skip appropriate positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Begin at position 0, check if position+2 has #

Decode

If # found, decode 2 digits, else decode 1 digit

Advance

Move index by 3 for #pattern or 1 for single digit

Code -

solution.c — C

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

char* solution(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resIdx = 0;
    int i = 0;
    
    while (i < len) {
        if (i + 2 < len && s[i + 2] == '#') {
            // Two digit number followed by #
            int num = (s[i] - '0') * 10 + (s[i + 1] - '0');
            result[resIdx++] = 'a' + num - 1;
            i += 3;
        } else {
            // Single digit
            int num = s[i] - '0';
            result[resIdx++] = 'a' + num - 1;
            i += 1;
        }
    }
    result[resIdx] = '\0';
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

892 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

Left to Right Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler