Decode the Message

Decode the Message - Problem

You are given the strings key and message, which represent a cipher key and a secret message, respectively. The steps to decode message are as follows:

Use the first appearance of all 26 lowercase English letters in key as the order of the substitution table.
Align the substitution table with the regular English alphabet.
Each letter in message is then substituted using the table.
Spaces ' ' are transformed to themselves.

For example, given key = "happy boy" (actual key would have at least one instance of each letter in the alphabet), we have the partial substitution table of ('h' -> 'a', 'a' -> 'b', 'p' -> 'c', 'y' -> 'd', 'b' -> 'e', 'o' -> 'f').

Return the decoded message.

Input & Output

Example 1 — Basic Substitution

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

› Output: this is a secret

💡 Note: Key contains all 26 letters. First unique chars: t→a, h→b, e→c, q→d, u→e, i→f, c→g, k→h, etc. Decoding 'v'→'s', 'k'→'h', 'b'→'i', 's'→'t' gives 'this is a secret'

Example 2 — With Spaces

$ Input: key = "happy boy", message = "h p"

› Output: a c

💡 Note: Key gives mapping h→a, a→b, p→c, y→d, b→e, o→f. Message 'h p' becomes 'a c' (spaces preserved)

Example 3 — Single Character

$ Input: key = "abcdefghijklmnopqrstuvwxyz", message = "z"

› Output: z

💡 Note: Key is regular alphabet, so z→z (26th letter maps to 26th position)

Constraints

1 ≤ key.length ≤ 10⁵
1 ≤ message.length ≤ 10⁴
key contains every letter of the English alphabet at least once
key and message consist of lowercase English letters and spaces

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to build a substitution table by mapping the first occurrence of each unique character in the key to the regular alphabet order. The optimal approach uses a hash map for O(1) character lookup. Time: O(n+m), Space: O(1).

Common Approaches

✓ Brute Force Character Lookup

⏱️ Time: O(n × m) Space: O(n)

Extract unique characters from key in order, then for each character in message, search through the unique key to find its position and map to corresponding alphabet letter.

Hash Map Substitution

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

First pass through the key to build a substitution map from cipher characters to alphabet characters. Then use the map to decode the message in O(1) time per character.

Brute Force Character Lookup — Algorithm Steps

Step 1: Extract unique characters from key in order of appearance
Step 2: For each character in message, find its position in unique key
Step 3: Map position to corresponding alphabet letter

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Unique Key

Build array of unique characters from key

Search Each Character

For each message character, search through unique key

Map to Alphabet

Convert position to corresponding alphabet letter

Code -

solution.c — C

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

char* solution(char* key, char* message) {
    // Extract unique characters from key in order
    char uniqueKey[26];
    bool seen[26] = {false};
    int uniqueCount = 0;
    
    for (int i = 0; key[i]; i++) {
        char c = key[i];
        if (c >= 'a' && c <= 'z' && !seen[c - 'a']) {
            uniqueKey[uniqueCount++] = c;
            seen[c - 'a'] = true;
        }
    }
    
    int len = strlen(message);
    char* result = malloc(len + 1);
    int resultIdx = 0;
    
    for (int i = 0; message[i]; i++) {
        char c = message[i];
        if (c == ' ') {
            result[resultIdx++] = ' ';
        } else {
            // Find position in unique key
            int pos = -1;
            for (int j = 0; j < uniqueCount; j++) {
                if (uniqueKey[j] == c) {
                    pos = j;
                    break;
                }
            }
            if (pos != -1) {
                // Map to alphabet
                result[resultIdx++] = 'a' + pos;
            }
        }
    }
    
    result[resultIdx] = '\0';
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m characters in message, search through n unique characters in key

✓ Linear Growth

Space Complexity

O(n)

Store unique characters from key and result string

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 min Avg. Time

845 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

Brute Force Character Lookup — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler