Implement Magic Dictionary - Practice Coding Problems

Implement Magic Dictionary - Problem

Implement Magic Dictionary - Create a Smart Word Matching System

Design a data structure that acts like a "magic dictionary" - it can find words that are almost matches! Given a list of dictionary words, your magic dictionary should be able to determine if you can change exactly one character in a search word to match any word in the dictionary.

Key Requirements:
• MagicDictionary() - Initialize the object
• buildDict(dictionary) - Build the dictionary from an array of distinct strings
• search(searchWord) - Return true if changing exactly one character in searchWord matches any dictionary word

Example: If dictionary contains ["hello", "leetcode"], then searching for "hhllo" returns true (change 'h' to 'e'), but "hello" returns false (no changes needed).

Input & Output

example_1.py — Basic Magic Dictionary

$ Input: magicDictionary = MagicDictionary() magicDictionary.buildDict(["hello", "leetcode"]) magicDictionary.search("hello") magicDictionary.search("hhllo") magicDictionary.search("hell") magicDictionary.search("leetcoded")

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

💡 Note: buildDict builds the dictionary. search('hello') returns false (no changes needed, must change exactly one). search('hhllo') returns true (change first 'h' to 'e' to get 'hello'). search('hell') and search('leetcoded') return false due to different lengths.

example_2.py — Single Character Words

$ Input: magicDictionary = MagicDictionary() magicDictionary.buildDict(["a", "b"]) magicDictionary.search("a") magicDictionary.search("b") magicDictionary.search("c") magicDictionary.search("ab")

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

💡 Note: Dictionary has ['a', 'b']. search('a') and search('b') return false (exact matches, no change). search('c') returns true (can change 'c' to 'a' or 'b'). search('ab') returns false (different length).

example_3.py — Multiple Word Matches

$ Input: magicDictionary = MagicDictionary() magicDictionary.buildDict(["hello", "hallo", "hullo"]) magicDictionary.search("hxllo")

› Output: [null, null, true]

💡 Note: Dictionary has words that differ only in the second character. search('hxllo') returns true because changing 'x' to 'e', 'a', or 'u' matches dictionary words.

Visualization

Tap to expand

Understanding the Visualization

Build Dictionary

Construct Trie from dictionary words ['hello', 'leetcode']

Start Search

Begin DFS search for 'hhllo' with 1 mismatch allowed

Handle Mismatch

At position 1: 'h' doesn't match 'e', use our one allowed mismatch

Continue Match

Remaining characters 'llo' match exactly in Trie path

Found Result

Reached end of word with exactly 0 mismatches remaining → return true

Key Takeaway

🎯 Key Insight: The Trie approach efficiently explores exactly one character modification by using DFS with a mismatch counter, achieving optimal time complexity while handling the constraint elegantly.

Time & Space Complexity

Time Complexity

⏱️

O(n*m) build, O(m*26) search

Build: insert n words of length m. Search: DFS with at most 26 branches per level

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE * N * M)

Trie nodes for storing dictionary words with shared prefixes

✓ Linear Space

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
buildDict will be called only once before search
At most 100 calls will be made to search

Asked in

G Google 42 a Amazon 28 ⊞ Microsoft 18 f Meta 15

The optimal solution uses a Trie with DFS wildcard search to achieve O(m×26) search time. Build a Trie from dictionary words, then use DFS traversal allowing exactly one character mismatch. The pattern-based hash table approach is also efficient, pre-generating all one-character-different patterns for O(m) search time. Both significantly outperform the brute force O(n×m) character comparison approach.

Common Approaches

Approach	Time	Space	Notes
✓ Generalized Neighbors (Hash Table)	O(n*m) build, O(m) search	O(n*m²)	Pre-generate all possible one-character modifications for efficient lookup
Trie with Wildcard Search (Optimal)	O(nm) build, O(m26) search	O(ALPHABET_SIZE * N * M)	Use Trie data structure for efficient wildcard matching with exactly one character difference
Brute Force Character Comparison	O(nmk)	O(n*m)	Compare search word with each dictionary word character by character

Generalized Neighbors (Hash Table) — Algorithm Steps

For each dictionary word, generate patterns by replacing each character with '*'
Store these patterns in a hash table mapping to original words
For search word, generate same patterns and look up in hash table
Ensure the matched word is different from search word (exactly one change)

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Patterns

Generate patterns: 'hello' → ['*ello', 'h*llo', 'he*lo', 'hel*o', 'hell*']

Search Patterns

For 'hhllo' → generate ['*hllo', 'h*llo', 'hh*lo', 'hhl*o', 'hhll*']

Find Match

Pattern 'h*llo' matches both 'hello' and 'hhllo', and they're different words!

Code -

solution.c — C

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

#define MAX_PATTERNS 1000
#define MAX_WORDS_PER_PATTERN 100

typedef struct {
    char pattern[51];
    char words[MAX_WORDS_PER_PATTERN][51];
    int wordCount;
} PatternEntry;

typedef struct {
    PatternEntry patterns[MAX_PATTERNS];
    int patternCount;
} MagicDictionary;

MagicDictionary* magicDictionaryCreate() {
    MagicDictionary* md = malloc(sizeof(MagicDictionary));
    md->patternCount = 0;
    return md;
}

int findPattern(MagicDictionary* md, char* pattern) {
    for (int i = 0; i < md->patternCount; i++) {
        if (strcmp(md->patterns[i].pattern, pattern) == 0) {
            return i;
        }
    }
    return -1;
}

void magicDictionaryBuildDict(MagicDictionary* md, char** dictionary, int dictSize) {
    md->patternCount = 0;
    for (int i = 0; i < dictSize; i++) {
        char* word = dictionary[i];
        int len = strlen(word);
        for (int j = 0; j < len; j++) {
            char pattern[51];
            strcpy(pattern, word);
            pattern[j] = '*';
            
            int idx = findPattern(md, pattern);
            if (idx == -1) {
                strcpy(md->patterns[md->patternCount].pattern, pattern);
                strcpy(md->patterns[md->patternCount].words[0], word);
                md->patterns[md->patternCount].wordCount = 1;
                md->patternCount++;
            } else {
                strcpy(md->patterns[idx].words[md->patterns[idx].wordCount], word);
                md->patterns[idx].wordCount++;
            }
        }
    }
}

bool magicDictionarySearch(MagicDictionary* md, char* searchWord) {
    int len = strlen(searchWord);
    for (int i = 0; i < len; i++) {
        char pattern[51];
        strcpy(pattern, searchWord);
        pattern[i] = '*';
        
        int idx = findPattern(md, pattern);
        if (idx != -1) {
            for (int j = 0; j < md->patterns[idx].wordCount; j++) {
                if (strcmp(md->patterns[idx].words[j], searchWord) != 0) {
                    return true;
                }
            }
        }
    }
    return false;
}

int main() {
    MagicDictionary* md = magicDictionaryCreate();
    char* dict[] = {"hello", "leetcode"};
    magicDictionaryBuildDict(md, dict, 2);
    printf("%d\n", magicDictionarySearch(md, "hhllo"));  // 1
    printf("%d\n", magicDictionarySearch(md, "hello"));  // 0
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m) build, O(m) search

Build: n words × m length for pattern generation. Search: m patterns to check

✓ Linear Growth

Space Complexity

O(n*m²)

Each word generates m patterns, stored with word references

⚡ Linearithmic Space

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
buildDict will be called only once before search
At most 100 calls will be made to search

89.2K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Generalized Neighbors (Hash Table) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler