Decrypt String from Alphabet to Integer Mapping

Decrypt String from Alphabet to Integer Mapping - Problem

String Easy

You're a cryptographer who has intercepted an encoded message! 🕵️‍♂️

The message is a string s containing only digits and '#' symbols. Your mission is to decrypt it back to readable English lowercase letters using this special mapping:

Single digits ('1' to '9') represent letters ('a' to 'i') respectively
Two digits followed by '#' ('10#' to '26#') represent letters ('j' to 'z') respectively

Example: The encrypted string "10#11#12" decodes to "jkl" because:

10# → 'j' (10th letter)
11# → 'k' (11th letter)
12# → 'l' (12th letter)

🎯 Your goal: Return the decrypted string. The input is guaranteed to have a unique valid decoding!

Input & Output

example_1.py — Basic Mixed Encoding

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

› Output: "jkl"

💡 Note: 10# maps to 'j' (10th letter), 11# maps to 'k' (11th letter), 12# maps to 'l' (12th letter). No single digits in this example.

example_2.py — Single Digits Only

$ Input: s = "1326#"

› Output: "acz"

💡 Note: 1 maps to 'a' (1st letter), 3 maps to 'c' (3rd letter), 26# maps to 'z' (26th letter). Mixed single digits and one two-digit mapping.

example_3.py — All Single Digits

$ Input: s = "123456789"

› Output: "abcdefghi"

💡 Note: Each digit 1-9 maps directly to letters a-i respectively. No '#' symbols present, so all are single-digit mappings.

Constraints

1 ≤ s.length ≤ 1000
s consists of digits and the '#' symbol
s will be a valid string such that mapping is always possible
The mapping is always unique (no ambiguous cases)

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Recognize that '#' marks the end of two-digit codes

Process Backwards

Start from the end and work backwards through the string

Decode Each Part

Convert numbers to their corresponding alphabet positions

Assemble Message

Build the final decoded message

Key Takeaway

🎯 Key Insight: By processing the string backwards, we can easily distinguish between single-digit codes (1-9) and two-digit codes (10#-26#) without any ambiguity!

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal solution processes the string from right to left, using the '#' character as a guide. When we encounter '#', we know the previous two digits form a two-digit mapping (10-26 → j-z). Otherwise, we process single digits (1-9 → a-i). This approach runs in O(n) time with O(n) space and avoids the complexity of trying all possible splits.

Common Approaches

Approach	Time	Space	Notes
✓ Reverse Iteration (Optimal)	O(n)	O(n)	Process the string from right to left, using '#' as a guide to decode efficiently
Brute Force (Try All Splits)	O(2^n)	O(n)	Try all possible ways to split the string and check which one gives valid mappings

Reverse Iteration (Optimal) — Algorithm Steps

Start from the end of the string
If current character is '#', take the previous 2 digits as a number and map to letter
If current character is a digit and we haven't just processed a '#', map single digit to letter
Build result string and reverse it at the end
Return the decoded string

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from End

Begin at the last character of "10#11#12"

Check for '#'

If '#' found, take previous 2 digits as one mapping

Build Result

Add decoded characters and continue backwards

Reverse Result

Since we built backwards, reverse to get final answer

Code -

solution.c — C

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

char* freqAlphabets(char* s) {
    int len = strlen(s);
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultIndex = 0;
    int i = len - 1;
    
    while (i >= 0) {
        if (s[i] == '#') {
            // Two-digit mapping
            int num = (s[i-2] - '0') * 10 + (s[i-1] - '0');
            result[resultIndex++] = 'a' + num - 1;
            i -= 3;
        } else {
            // Single-digit mapping
            int num = s[i] - '0';
            result[resultIndex++] = 'a' + num - 1;
            i--;
        }
    }
    
    result[resultIndex] = '\0';
    
    // Reverse the result
    for (int j = 0; j < resultIndex / 2; j++) {
        char temp = result[j];
        result[j] = result[resultIndex - 1 - j];
        result[resultIndex - 1 - j] = temp;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, where n is the length of input string

✓ Linear Growth

Space Complexity

O(n)

We need space for the result string, which can be at most n characters

⚡ Linearithmic Space

95.0K Views

Medium Frequency

~15 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

Reverse Iteration (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler