Description#
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.
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 <= 2000key consists of lowercase English letters and ' '.key contains every letter in the English alphabet ('a' to 'z') at least once.1 <= message.length <= 2000message consists of lowercase English letters and ' '.
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
| 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)
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| 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)
}
|
1
2
3
4
5
6
7
8
9
10
11
| 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('');
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| 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()
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| char* decodeMessage(char* key, char* message) {
int m = strlen(key);
int n = strlen(message);
char d[26];
memset(d, ' ', 26);
for (int i = 0, j = 0; i < m; i++) {
if (key[i] == ' ' || d[key[i] - 'a'] != ' ') {
continue;
}
d[key[i] - 'a'] = 'a' + j++;
}
char* ans = malloc(n + 1);
for (int i = 0; i < n; i++) {
ans[i] = message[i] == ' ' ? ' ' : d[message[i] - 'a'];
}
ans[n] = '\0';
return ans;
}
|
