Encrypt and Decrypt Strings - Practice Coding Problems

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.

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.

Time & Space Complexity

Time Complexity

⏱️

O(1) encrypt, O(1) decrypt after O(D*L) preprocessing

D is dictionary size, L is average word length. Each operation is O(1) after preprocessing

✓ Linear Growth

Space Complexity

O(K + D*L)

K for key-value mappings, D*L for storing encrypted dictionary words

✓ Linear Space

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

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
✓ 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)	O(nk + md)	O(1)	Linear search through arrays for each character/substring

Hash Table Approach (Optimal) — Algorithm Steps

Build hash map from characters to encrypted values for O(1) encryption
Build reverse hash map from encrypted values to possible characters
Preprocess dictionary by encrypting all words and counting occurrences
For decrypt: simply lookup the encrypted string in preprocessed counts

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Maps

Create encrypt_map and decrypt_map for O(1) lookups

Preprocess Dictionary

Encrypt all dictionary words and store counts

Fast Operations

Encrypt: O(1) lookup per char. Decrypt: O(1) lookup total

Code -

solution.c — C

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

#define MAX_ENCRYPTED_LEN 1000
#define HASH_SIZE 10007

typedef struct HashNode {
    char* key;
    int value;
    struct HashNode* next;
} HashNode;

typedef struct {
    char* keys;
    char** values;
    int keysSize;
    HashNode* encryptedDict[HASH_SIZE];
} Encrypter;

unsigned int hash(const char* str) {
    unsigned int hash = 5381;
    int c;
    while ((c = *str++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

void insertHash(HashNode* table[], const char* key, int value) {
    unsigned int index = hash(key);
    HashNode* node = (HashNode*)malloc(sizeof(HashNode));
    node->key = (char*)malloc((strlen(key) + 1) * sizeof(char));
    strcpy(node->key, key);
    node->value = value;
    node->next = table[index];
    table[index] = node;
}

int searchHash(HashNode* table[], const char* key) {
    unsigned int index = hash(key);
    HashNode* node = table[index];
    while (node) {
        if (strcmp(node->key, key) == 0) {
            return node->value;
        }
        node = node->next;
    }
    return 0;
}

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->keysSize = keysSize;
    
    for (int i = 0; i < HASH_SIZE; i++) {
        obj->encryptedDict[i] = NULL;
    }
    
    // Preprocess dictionary
    for (int i = 0; i < dictionarySize; i++) {
        char* encrypted = encrypterEncrypt(obj, dictionary[i]);
        if (strlen(encrypted) > 0) {
            int currentCount = searchHash(obj->encryptedDict, encrypted);
            insertHash(obj->encryptedDict, encrypted, currentCount + 1);
        }
        free(encrypted);
    }
    
    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 encrypterDecrypt(Encrypter* obj, char* word2) {
    return searchHash(obj->encryptedDict, word2);
}

Time & Space Complexity

Time Complexity

⏱️

O(1) encrypt, O(1) decrypt after O(D*L) preprocessing

D is dictionary size, L is average word length. Each operation is O(1) after preprocessing

✓ Linear Growth

Space Complexity

O(K + D*L)

K for key-value mappings, D*L for storing encrypted dictionary words

✓ Linear Space

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Hash Table Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler