Codestin Search App

Encrypt and Decrypt Strings - Problem

🔐 Encrypt and Decrypt Strings

You're building a custom encryption system that can both encrypt and decrypt strings using a special mapping scheme. This system is unique because decryption might have multiple valid interpretations!

Given:

A keys array of unique characters (the alphabet of your cipher)
A values array of 2-character strings (the encrypted representations)
A dictionary array of valid words that can result from decryption

Encryption Process:

For each character c in the input string:

Find the index i where keys[i] == c
Replace c with values[i]
If any character isn't found in keys, return ""

Decryption Process:

For each 2-character substring at even positions:

Find which values[i] matches this substring
Replace it with keys[i]
Count how many possible decryptions appear in the dictionary

Example: If keys = ['a', 'b'] and values = ["01", "10"], then "ab" encrypts to "0110" and "0110" could decrypt back to "ab" (if "ab" is in the dictionary).

Input & Output

example_1.py — Basic Encryption and Decryption

$ Input: keys = ['a', 'b', 'c'], values = ["ei", "zf", "ei"], dictionary = ["abcdefghijklmnop"] Operations: - encrypt("abcdefghijklmnop") - decrypt("eizfeiei")

› Output: encrypt: "eizfeiei" decrypt: 1

💡 Note: Encryption maps each character using the keys array: 'a'→'ei', 'b'→'zf', 'c'→'ei', etc. The string "abcdefghijklmnop" becomes "eizfeiei...". For decryption, "eizfeiei" can decode back to words that appear in the dictionary, and there's 1 such word.

example_2.py — Multiple Possible Decryptions

$ Input: keys = ['a', 'b'], values = ["01", "10"], dictionary = ["ab", "ba"] Operations: - encrypt("ab") - decrypt("0110")

› Output: encrypt: "0110" decrypt: 2

💡 Note: Both "ab" and "ba" encrypt to "0110" since 'a'→'01' and 'b'→'10'. When decrypting "0110", it can be split as "01"+"10" (giving "ab") and both words are in the dictionary, so the count is 2.

example_3.py — Character Not in Keys

$ Input: keys = ['a', 'b'], values = ["01", "10"], dictionary = ["abc"] Operations: - encrypt("abc") - decrypt("01")

› Output: encrypt: "" decrypt: 0

💡 Note: The character 'c' is not in the keys array, so encryption of "abc" fails and returns empty string. "01" has odd length so cannot be properly decrypted (each encrypted char is 2 digits), resulting in 0 possible decryptions.

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
keys contains unique characters
All characters in dictionary[i] are in keys

Visualization

Tap to expand

Understanding the Visualization

Build Code Book

Create hash maps: char→code and code→[possible chars]

Preprocess Dictionary

Encrypt all approved words and store their counts

Encrypt Message

For each character, lookup its code in O(1) time

Decrypt Message

Lookup encrypted string in preprocessed dictionary counts

Key Takeaway

🎯 Key Insight: By preprocessing the dictionary (encrypting all words during initialization), we transform the decrypt operation from exponential backtracking to a simple O(1) hash table lookup, making the system blazingly fast for real-time encryption and decryption operations.

Asked in

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

The optimal solution uses hash maps for O(1) character lookups and preprocessing to encrypt all dictionary words during initialization. This eliminates the need for backtracking during decrypt operations, achieving O(1) time complexity for both encrypt and decrypt after preprocessing.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Search)	O(nk + md)	O(1)	Linear search through arrays for each character/substring
Hash Table Approach (Optimal)	O(1) encrypt, O(1) decrypt after O(D*L) preprocessing	O(K + D*L)	Use hash maps for O(1) character/substring lookups and preprocess dictionary

Brute Force (Linear Search) — Algorithm Steps

For encryption: iterate through each character and linearly search keys array
Replace each found character with corresponding value
For decryption: iterate through encrypted string in steps of 2
Linearly search values array for each substring
Generate all possible decryptions and check against dictionary

Visualization

Tap to expand

Step-by-Step Walkthrough

Character 'a'

Search keys array linearly until 'a' is found at index 0

Get Value

Use index 0 to get values[0] = '01'

Next Character

Repeat process for each remaining character

Code -

solution.c — C

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

typedef struct {
    char* keys;
    char** values;
    char** dictionary;
    int keysSize;
    int valuesSize;
    int dictionarySize;
} Encrypter;

Encrypter* encrypterCreate(char* keys, int keysSize, char** values, int valuesSize, char** dictionary, int dictionarySize) {
    Encrypter* obj = (Encrypter*)malloc(sizeof(Encrypter));
    obj->keys = (char*)malloc(keysSize * sizeof(char));
    memcpy(obj->keys, keys, keysSize);
    
    obj->values = (char**)malloc(valuesSize * sizeof(char*));
    for (int i = 0; i < valuesSize; i++) {
        obj->values[i] = (char*)malloc(3 * sizeof(char));
        strcpy(obj->values[i], values[i]);
    }
    
    obj->dictionary = (char**)malloc(dictionarySize * sizeof(char*));
    for (int i = 0; i < dictionarySize; i++) {
        obj->dictionary[i] = (char*)malloc((strlen(dictionary[i]) + 1) * sizeof(char));
        strcpy(obj->dictionary[i], dictionary[i]);
    }
    
    obj->keysSize = keysSize;
    obj->valuesSize = valuesSize;
    obj->dictionarySize = dictionarySize;
    return obj;
}

char* encrypterEncrypt(Encrypter* obj, char* word1) {
    int len = strlen(word1);
    char* result = (char*)malloc(len * 2 + 1);
    result[0] = '\0';
    
    for (int i = 0; i < len; i++) {
        bool found = false;
        for (int j = 0; j < obj->keysSize; j++) {
            if (obj->keys[j] == word1[i]) {
                strcat(result, obj->values[j]);
                found = true;
                break;
            }
        }
        if (!found) {
            strcpy(result, "");
            return result;
        }
    }
    return result;
}

int backtrackDecrypt(Encrypter* obj, char* word2, int pos, char* current) {
    if (pos >= strlen(word2)) {
        for (int i = 0; i < obj->dictionarySize; i++) {
            if (strcmp(obj->dictionary[i], current) == 0) {
                return 1;
            }
        }
        return 0;
    }
    
    char substring[3];
    strncpy(substring, word2 + pos, 2);
    substring[2] = '\0';
    
    int count = 0;
    for (int i = 0; i < obj->valuesSize; i++) {
        if (strcmp(obj->values[i], substring) == 0) {
            char newCurrent[1000];
            sprintf(newCurrent, "%s%c", current, obj->keys[i]);
            count += backtrackDecrypt(obj, word2, pos + 2, newCurrent);
        }
    }
    return count;
}

int encrypterDecrypt(Encrypter* obj, char* word2) {
    if (strlen(word2) % 2 != 0) return 0;
    return backtrackDecrypt(obj, word2, 0, "");
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k + m*d)

n is string length, k is keys length, m is encrypted string length, d is dictionary size

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.9K Views

Medium Frequency

~25 min Avg. Time

847 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

🔐 Encrypt and Decrypt Strings

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Linear Search) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler