Implement Magic Dictionary

Implement Magic Dictionary - Problem

Design a data structure that is initialized with a list of different words. Given a string, determine if you can change exactly one character in this string to match any word in the data structure.

Implement the MagicDictionary class:

MagicDictionary() - Initializes the object
buildDict(String[] dictionary) - Sets the data structure with an array of distinct strings dictionary
search(String searchWord) - Returns true if you can change exactly one character in searchWord to match any string in the data structure, otherwise returns false

Input & Output

Example 1 — Basic Operations

$ Input: operations = ["MagicDictionary", "buildDict", "search", "search"], inputs = [[], ["hello", "leetcode"], "hello", "hhllo"]

› Output: [null, null, false, true]

💡 Note: Initialize dictionary with ["hello", "leetcode"]. Search "hello" returns false (can't change to itself). Search "hhllo" returns true (change 'h' to 'e' makes "hello")

Example 2 — Multiple Words

$ Input: operations = ["MagicDictionary", "buildDict", "search", "search"], inputs = [[], ["hello", "hallo"], "hello", "hillo"]

› Output: [null, null, true, true]

💡 Note: Dictionary has ["hello", "hallo"]. Search "hello" returns true (change 'e' to 'a' makes "hallo"). Search "hillo" returns true (change 'i' to 'e' makes "hello")

Example 3 — No Match

$ Input: operations = ["MagicDictionary", "buildDict", "search"], inputs = [[], ["hello"], "hellllo"]

› Output: [null, null, false]

💡 Note: Dictionary has ["hello"]. Search "hellllo" returns false (different lengths, cannot match with exactly one change)

Constraints

1 ≤ dictionary.length ≤ 100
1 ≤ dictionary[i].length ≤ 100
dictionary[i] consists of only lower-case English letters
All the strings in dictionary are distinct
1 ≤ searchWord.length ≤ 100
searchWord consists of only lower-case English letters

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15

The key insight is to either compare each search word with all dictionary words character by character, or pre-process dictionary words into patterns for faster lookup. The hash map approach is optimal for multiple searches: Time O(n×m² + k×m), Space O(n×m²).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Comparison	O(n × m × k)	O(n × m)	For each search, compare with every dictionary word character by character
Hash Map with Patterns	O(n × m² + k × m)	O(n × m²)	Pre-process dictionary words into patterns for faster lookup

Brute Force Comparison — Algorithm Steps

Store dictionary words in array
For each search, compare with all dictionary words
Count character differences for each comparison
Return true if any word has exactly 1 difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Dictionary

Store words: ["hello", "hallo", "leetcode"]

Compare "hello" with each word, count differences

Result

"hallo" has exactly 1 difference → return true

Code -

solution.c — C

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

typedef struct {
    char dictionary[100][101];
    int size;
} MagicDictionary;

MagicDictionary* magicDictionaryCreate() {
    MagicDictionary* obj = (MagicDictionary*)malloc(sizeof(MagicDictionary));
    obj->size = 0;
    return obj;
}

void magicDictionaryBuildDict(MagicDictionary* obj, char** dictionary, int dictionarySize) {
    obj->size = dictionarySize;
    for (int i = 0; i < dictionarySize; i++) {
        strcpy(obj->dictionary[i], dictionary[i]);
    }
}

bool magicDictionarySearch(MagicDictionary* obj, char* searchWord) {
    int searchLen = strlen(searchWord);
    for (int i = 0; i < obj->size; i++) {
        if (strlen(obj->dictionary[i]) == searchLen) {
            int diffCount = 0;
            for (int j = 0; j < searchLen; j++) {
                if (obj->dictionary[i][j] != searchWord[j]) {
                    diffCount++;
                    if (diffCount > 1) break;
                }
            }
            if (diffCount == 1) return true;
        }
    }
    return false;
}

int main() {
    printf("[null,null,false,true]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × k)

n dictionary words × m average word length × k search operations

✓ Linear Growth

Space Complexity

O(n × m)

Store n dictionary words of average length m

⚡ Linearithmic Space

67.0K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler