Encrypt and Decrypt Strings

Encrypt and Decrypt Strings - Problem

You are given a character array keys containing unique characters and a string array values containing strings of length 2. You are also given another string array dictionary that contains all permitted original strings after decryption.

You should implement a data structure that can encrypt or decrypt a 0-indexed string.

Encryption Process:

For each character c in the string, we find the index i satisfying keys[i] == c in keys.
Replace c with values[i] in the string.

Note that in case a character of the string is not present in keys, the encryption process cannot be carried out, and an empty string "" is returned.

Decryption Process:

For each substring s of length 2 occurring at an even index in the string, we find an i such that values[i] == s. If there are multiple valid i, we choose any one of them. This means a string could have multiple possible strings it can decrypt to.
Replace s with keys[i] in the string.

Implement the Encrypter class:

Encrypter(char[] keys, String[] values, String[] dictionary) Initializes the Encrypter class with keys, values, and dictionary.
String encrypt(String word1) Encrypts word1 with the encryption process described above and returns the encrypted string.
int decrypt(String word2) Returns the number of possible strings word2 could decrypt to that also appear in dictionary.

Input & Output

Example 1 — Basic Encryption/Decryption

$ Input: keys = ['a', 'b', 'c'], values = ["hj", "xy", "wz"], dictionary = ["ab", "bc"], operations = [["encrypt", "ab"], ["decrypt", "hjxy"]]

› Output: ["hjxy", "1"]

💡 Note: Encrypt 'ab': 'a'→"hj", 'b'→"xy", result "hjxy". Decrypt "hjxy": splits to "hj"+"xy" which could be 'a'+'b'="ab", and "ab" exists in dictionary, so count is 1.

Example 2 — Multiple Dictionary Matches

$ Input: keys = ['a', 'b'], values = ["hj", "hj"], dictionary = ["aa", "bb"], operations = [["decrypt", "hjhj"]]

› Output: ["2"]

💡 Note: Decrypt "hjhj": both 'a' and 'b' map to "hj", so "hjhj" could decode to "aa" or "bb". Both exist in dictionary, so count is 2.

Example 3 — Invalid Encryption

$ Input: keys = ['a', 'b'], values = ["hj", "xy"], dictionary = ["ab"], operations = [["encrypt", "ac"]]

› Output: [""]

💡 Note: Encrypt 'ac': 'a'→"hj" but 'c' is not in keys array, so encryption fails and returns empty string.

Constraints

1 ≤ keys.length == values.length ≤ 26
values[i].length == 2
1 ≤ dictionary.length ≤ 100
1 ≤ dictionary[i].length ≤ 100
At most 200 calls will be made to encrypt and decrypt

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22

The key insight is to pre-encrypt all dictionary words during initialization for O(1) decryption lookup. Best approach uses pre-encrypted frequency map to avoid exponential decoding generation. Time: O(d×m) init + O(n) encrypt + O(1) decrypt, Space: O(d×m)

Common Approaches

✓ Memoization

⏱️ Time: N/A Space: N/A

Dp 1d

⏱️ Time: N/A Space: N/A

Brute Force Decryption

⏱️ Time: O(n) for encrypt, O(d × 2^k) for decrypt where d is dictionary size, k is ambiguous mappings Space: O(k + v + d)

Create hash maps for encryption and decryption lookups. For each decrypt operation, try to decrypt the input and check if each possible result exists in dictionary.

Pre-encrypted Dictionary

⏱️ Time: O(d×m) initialization, O(n) encrypt, O(1) decrypt where d is dictionary size, m is average word length Space: O(d×m)

Instead of generating all possible decodings, encrypt all dictionary words during initialization and store them in a frequency map. During decryption, simply lookup the encrypted string.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

char dictionary[1000][51];
int dictSize = 0;
int memo[51];
int memoSet[51];
char* s;
int sLen;

int isInDict(char* word) {
    for (int i = 0; i < dictSize; i++) {
        if (strcmp(dictionary[i], word) == 0) {
            return 1;
        }
    }
    return 0;
}

int dp(int index) {
    if (index == sLen) {
        return 0;
    }
    
    if (memoSet[index]) {
        return memo[index];
    }
    
    // Option 1: Skip current character
    int result = 1 + dp(index + 1);
    
    // Option 2: Try dictionary words
    for (int end = index + 1; end <= sLen; end++) {
        char substring[51];
        strncpy(substring, s + index, end - index);
        substring[end - index] = '\0';
        
        if (isInDict(substring)) {
            int dpResult = dp(end);
            if (dpResult < result) {
                result = dpResult;
            }
        }
    }
    
    memo[index] = result;
    memoSet[index] = 1;
    return result;
}

int solution(char* str, char dict[][51], int dictLen) {
    s = str;
    sLen = strlen(str);
    dictSize = dictLen;
    
    for (int i = 0; i < dictLen; i++) {
        strcpy(dictionary[i], dict[i]);
    }
    
    memset(memoSet, 0, sizeof(memoSet));
    return dp(0);
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char sLine[102];
    fgets(sLine, sizeof(sLine), stdin);
    sLine[strcspn(sLine, "\n")] = 0;
    
    // Remove quotes from string
    char str[51];
    strncpy(str, sLine + 1, strlen(sLine) - 2);
    str[strlen(sLine) - 2] = '\0';
    
    char dictLine[1000];
    fgets(dictLine, sizeof(dictLine), stdin);
    
    char dict[100][51];
    int dictLen = 0;
    char* token = strtok(dictLine, "[],\" \n");
    while (token != NULL && dictLen < 100) {
        if (strlen(token) > 0) {
            strcpy(dict[dictLen++], token);
        }
        token = strtok(NULL, "[],\" \n");
    }
    
    printf("%d\n", solution(str, dict, dictLen));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~25 min Avg. Time

892 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