Design Add and Search Words Data Structure

Design Add and Search Words Data Structure - Problem

Design a smart word dictionary that can store words and search for them with a twist - it supports wildcard matching!

Your task is to implement a WordDictionary class with these capabilities:

Add words: Store new words in your data structure
Search with wildcards: Find words where dots (.) can match any single letter

For example, if you add the word "bad", then searching for "b.d" should return true because the dot can match the 'a'.

Class Interface:

WordDictionary() - Initialize the data structure
void addWord(word) - Add a word to the dictionary
bool search(word) - Search for a word (with wildcard support)

The challenge is to efficiently handle both exact matches and wildcard patterns while maintaining good performance for both operations.

Input & Output

example_1.py — Basic Operations

$ Input: WordDictionary wd = new WordDictionary(); wd.addWord("bad"); wd.addWord("dad"); wd.addWord("mad"); wd.search("pad"); // false wd.search("bad"); // true wd.search(".ad"); // true wd.search("b.."); // true

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

💡 Note: We add three words and test various search patterns. 'pad' doesn't exist, 'bad' exists exactly, '.ad' matches 'bad', 'dad', 'mad', and 'b..' matches 'bad'.

example_2.py — Edge Cases

$ Input: WordDictionary wd = new WordDictionary(); wd.addWord("a"); wd.addWord("a"); wd.search("."); // true wd.search("a"); // true wd.search("aa"); // false wd.search(".a"); // false wd.search("a."); // false

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

💡 Note: Adding duplicate words is allowed. Single character 'a' matches '.', length mismatches return false.

example_3.py — Complex Wildcards

$ Input: WordDictionary wd = new WordDictionary(); wd.addWord("word"); wd.addWord("work"); wd.addWord("world"); wd.search("wor."); // true (matches 'word', 'work') wd.search("wor.d"); // true (matches 'world') wd.search("w..ld"); // true (matches 'world') wd.search(".o.ld"); // true (matches 'world')

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

💡 Note: Multiple wildcards in different positions all work correctly, matching various stored words based on the pattern.

Visualization

Tap to expand

Understanding the Visualization

Build the Trie

Each word creates a path from root, sharing common prefixes

Handle Exact Matches

For regular characters, follow the single path in the trie

Handle Wildcards

For '.' characters, recursively explore all possible child paths

Check End State

Verify we've consumed entire pattern and reached a valid word ending

Key Takeaway

🎯 Key Insight: Trie structure enables efficient prefix sharing and the recursive DFS approach elegantly handles wildcard expansion by exploring all possible character matches at each '.' position.

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For search: n words × m characters per comparison. Add is O(1)

✓ Linear Growth

Space Complexity

O(n*m)

Store n words, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ word.length ≤ 25
word in addWord consists of lowercase English letters
word in search consist of '.' or lowercase English letters
There will be at most 2 × 10⁴ calls to addWord and search
Wildcards '.' can match any single lowercase letter

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal solution uses a Trie (prefix tree) data structure combined with recursive depth-first search for wildcard handling. This approach provides O(m) time complexity for adding words and efficient search even with wildcards by exploring all possible paths when encountering '.' characters.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Simple List Storage)	O(n*m)	O(n*m)	Store all words in a list and check each word during search
Trie Data Structure (Optimal)	O(m) add, O(26^k × m) search worst case	O(ALPHABET_SIZE × N × M)	Use a prefix tree with recursive wildcard matching for efficient storage and search

Brute Force (Simple List Storage) — Algorithm Steps

Store all added words in a simple list/array
For search: iterate through all stored words
For each word, check character by character if it matches the pattern
Handle wildcards by accepting any character when encountering '.'

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Words

Words are simply appended to a list

Linear Search

Search checks every word one by one

Pattern Match

Each character is compared, wildcards match anything

Code -

solution.c — C

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

#define MAX_WORDS 1000
#define MAX_WORD_LEN 25

typedef struct {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int count;
} WordDictionary;

WordDictionary* wordDictionaryCreate() {
    WordDictionary* obj = (WordDictionary*)malloc(sizeof(WordDictionary));
    obj->count = 0;
    return obj;
}

void wordDictionaryAddWord(WordDictionary* obj, char* word) {
    strcpy(obj->words[obj->count], word);
    obj->count++;
}

bool matches(char* storedWord, char* pattern) {
    if (strlen(storedWord) != strlen(pattern)) return false;
    for (int i = 0; i < strlen(pattern); i++) {
        if (pattern[i] != '.' && pattern[i] != storedWord[i]) {
            return false;
        }
    }
    return true;
}

bool wordDictionarySearch(WordDictionary* obj, char* word) {
    for (int i = 0; i < obj->count; i++) {
        if (matches(obj->words[i], word)) {
            return true;
        }
    }
    return false;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For search: n words × m characters per comparison. Add is O(1)

✓ Linear Growth

Space Complexity

O(n*m)

Store n words, each of average length m

⚡ Linearithmic Space

Constraints

1 ≤ word.length ≤ 25
word in addWord consists of lowercase English letters
word in search consist of '.' or lowercase English letters
There will be at most 2 × 10⁴ calls to addWord and search
Wildcards '.' can match any single lowercase letter

42.6K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Simple List Storage) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler