Decode the Message - Practice Coding Problems

Decode the Message - Problem

You're a cryptographer tasked with decoding secret messages! 🕵️‍♀️

Given a key string and an encoded message, your job is to decode the message using a substitution cipher. Here's how the cipher works:

Extract the cipher alphabet: Use the first appearance of each of the 26 lowercase letters in the key to create your substitution table
Map to regular alphabet: The first unique letter maps to 'a', second to 'b', and so on
Decode the message: Replace each letter in the message using your substitution table
Preserve spaces: Spaces remain unchanged

Example: If key = "happy boy", the unique letters in order are: h, a, p, y, b, o
This creates the mapping: h→a, a→b, p→c, y→d, b→e, o→f

Goal: Return the fully decoded message as a string.

Input & Output

example_1.py — Basic Decoding

$ Input: key = "the quick brown fox jumps over the lazy dog", message = "vkbs bs t suepuv"

› Output: "this is a secret"

💡 Note: The key contains all 26 letters. First occurrence order: t→a, h→b, e→c, q→d, u→e, i→f, c→g, k→h, b→i, r→j, o→k, w→l, n→m, f→n, x→o, j→p, m→q, p→r, s→s, v→t, l→u, z→v, y→w, d→x, g→y. So 'vkbs' becomes 'this', 'bs' becomes 'is', etc.

example_2.py — Simple Case

$ Input: key = "happy boy", message = "lbkkz kt nlhr"

› Output: "sunny is cool"

💡 Note: Key has unique letters: h→a, a→b, p→c, y→d, b→e, o→f. The mapping shows that 'l' maps to 's', 'b' maps to 'u', 'k' maps to 'n', 'k' maps to 'n', 'z' maps to 'y', creating 'sunny is cool'.

example_3.py — Edge Case with Spaces

$ Input: key = "abc defghijklmnopqrstuvwxyz", message = "a b c"

› Output: "a b c"

💡 Note: The key maps a→a, b→b, c→c (first three letters map to themselves). The message 'a b c' decodes to 'a b c' with spaces preserved.

Constraints

1 ≤ key.length ≤ 100
key consists of lowercase English letters and spaces
key contains every letter of the English alphabet at least once
1 ≤ message.length ≤ 1000
message consists of lowercase English letters and spaces

Visualization

Tap to expand

Understanding the Visualization

Extract Unique Characters

From key 'happy boy', extract unique chars in order: h, a, p, y, b, o

Build Cipher Mapping

Map each unique char to alphabet: h→a, a→b, p→c, y→d, b→e, o→f

Decode Message

Use mapping to decode each character, preserving spaces

Return Result

Combine decoded characters into final secret message

Key Takeaway

🎯 Key Insight: The substitution cipher is like a decoder ring - once you align the rings properly (build the mapping table), decoding becomes a simple lookup operation for each character!

Asked in

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

The optimal solution uses a two-pass hash table approach. First, build a substitution table by iterating through the key and mapping each unique character to consecutive alphabet letters. Then, decode the message using O(1) hash table lookups. This achieves O(n + m) time complexity and O(1) space complexity (since we store at most 26 mappings).

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Optimal)	O(n + m)	O(1)	Build substitution table first, then decode message using O(1) lookups
Brute Force (Character-by-Character Search)	O(n*m)	O(1)	For each character in message, search through the entire key to find its position

Two-Pass Hash Table (Optimal) — Algorithm Steps

Create empty hash map for substitution table
Iterate through key, tracking unique characters seen
For each new unique character, map it to next alphabet letter
Iterate through message
For each character, look up in substitution table (or keep space as-is)
Build and return decoded message

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Substitution Table

Scan key 'happy boy' once: h→a, a→b, p→c, y→d, b→e, o→f

Decode Using Table

For each character in message, use O(1) hash table lookup

Complete Decoding

Process entire message efficiently with pre-built mapping

Code -

solution.c — C

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

char* decodeMessage(char* key, char* message) {
    // First pass: build substitution table (using array for simplicity)
    char charMap[26];
    bool used[26] = {false};
    int alphabetIndex = 0;
    
    // Initialize mapping
    for (int i = 0; i < 26; i++) {
        charMap[i] = 0;
    }
    
    for (int i = 0; key[i]; i++) {
        if (key[i] != ' ' && !used[key[i] - 'a']) {
            charMap[key[i] - 'a'] = 'a' + alphabetIndex;
            used[key[i] - 'a'] = true;
            alphabetIndex++;
        }
    }
    
    // Second pass: decode message
    int msgLen = strlen(message);
    char* result = (char*)malloc((msgLen + 1) * sizeof(char));
    
    for (int i = 0; i < msgLen; i++) {
        if (message[i] == ' ') {
            result[i] = ' ';
        } else {
            result[i] = charMap[message[i] - 'a'];
        }
    }
    
    result[msgLen] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

First pass through key (m) to build table, second pass through message (n) to decode

✓ Linear Growth

Space Complexity

O(1)

Hash table stores at most 26 character mappings, which is constant space

✓ Linear Space

58.0K Views

Medium Frequency

~12 min Avg. Time

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

Two-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler