##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2325.html

# 2325. Decode the Message

• Difficulty: Easy.
• Related Topics: Hash Table, String.
• Similar Questions: .

## 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 = "**hap**p**y** **bo**y" (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.

Example 1:

Input: key = "the quick brown fox jumps over the lazy dog", message = "vkbs bs t suepuv"
Output: "this is a secret"
Explanation: The diagram above shows the substitution table.
It is obtained by taking the first appearance of each letter in "the quick brown fox jumps over the lazy dog".


Example 2:

Input: key = "eljuxhpwnyrdgtqkviszcfmabo", message = "zwx hnfx lqantp mnoeius ycgk vcnjrdb"
Output: "the five boxing wizards jump quickly"
Explanation: The diagram above shows the substitution table.
It is obtained by taking the first appearance of each letter in "eljuxhpwnyrdgtqkviszcfmabo".


Constraints:

• 26 <= key.length <= 2000

• key consists of lowercase English letters and ' '.

• key contains every letter in the English alphabet ('a' to 'z') at least once.

• 1 <= message.length <= 2000

• message consists of lowercase English letters and ' '.

## Solution (Java, C++, Python)

• class Solution {
public String decodeMessage(String key, String message) {
StringBuilder sb = new StringBuilder();
Map<Character, Character> temp = new HashMap<>();
char[] alphabet = new char[26];
int itr = 0;
for (char c = 'a'; c <= 'z'; ++c) {
alphabet[c - 'a'] = c;
}
for (int i = 0; i < key.length(); i++) {
if (!temp.containsKey(key.charAt(i)) && key.charAt(i) != ' ') {
temp.put(key.charAt(i), alphabet[itr++]);
}
}
for (int j = 0; j < message.length(); j++) {
if (message.charAt(j) == ' ') {
sb.append(' ');
} else {
char result = temp.get(message.charAt(j));
sb.append(result);
}
}
return sb.toString();
}
}

############

class Solution {
public String decodeMessage(String key, String message) {
char[] d = new char[128];
d[' '] = ' ';
for (int i = 0, j = 0; i < key.length(); ++i) {
char c = key.charAt(i);
if (d[c] == 0) {
d[c] = (char) ('a' + j++);
}
}
char[] ans = message.toCharArray();
for (int i = 0; i < ans.length; ++i) {
ans[i] = d[ans[i]];
}
return String.valueOf(ans);
}
}

• class Solution:
def decodeMessage(self, key: str, message: str) -> str:
d = {" ": " "}
i = 0
for c in key:
if c not in d:
d[c] = ascii_lowercase[i]
i += 1
return "".join(d[c] for c in message)

############

# 2325. Decode the Message
# https://leetcode.com/problems/decode-the-message

class Solution:
def decodeMessage(self, key: str, message: str) -> str:
mp = {}

for x in key:
if x == " ": continue

if x not in mp:
mp[x] = chr(ord('a') + len(mp))

res = ""

for x in message:
if x == " ":
res += x
else:
res += mp[x]

return res


• class Solution {
public:
string decodeMessage(string key, string message) {
char d[128]{};
d[' '] = ' ';
char i = 'a';
for (char& c : key) {
if (!d[c]) {
d[c] = i++;
}
}
for (char& c : message) {
c = d[c];
}
return message;
}
};

• func decodeMessage(key string, message string) string {
d := [128]byte{}
d[' '] = ' '
for i, j := 0, 0; i < len(key); i++ {
if d[key[i]] == 0 {
d[key[i]] = byte('a' + j)
j++
}
}
ans := []byte(message)
for i, c := range ans {
ans[i] = d[c]
}
return string(ans)
}

• function decodeMessage(key: string, message: string): string {
const d = new Map<string, string>();
for (const c of key) {
if (c === ' ' || d.has(c)) {
continue;
}
d.set(c, String.fromCharCode('a'.charCodeAt(0) + d.size));
}
d.set(' ', ' ');
return [...message].map(v => d.get(v)).join('');
}


• use std::collections::HashMap;
impl Solution {
pub fn decode_message(key: String, message: String) -> String {
let mut d = HashMap::new();
for c in key.as_bytes() {
if *c == b' ' || d.contains_key(c) {
continue;
}
d.insert(c, char::from((97 + d.len()) as u8));
}
message
.as_bytes()
.iter()
.map(|c| d.get(c).unwrap_or(&' '))
.collect()
}
}



Explain:

nope.

Complexity:

• Time complexity : O(n).
• Space complexity : O(n).