Codestin Search App

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.

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

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.

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
✓ 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)	O(n*m)	O(n*m)	Store all words in a list and check each word during search

Trie Data Structure (Optimal) — Algorithm Steps

Create a Trie node structure with children array and end-of-word marker
For addWord: traverse/create path in trie for each character
For search: use recursive DFS to handle both exact matches and wildcards
When encountering '.', explore all possible children paths recursively

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Trie

Words create paths in the tree structure

Wildcard Encounter

When seeing '.', explore all child branches

Recursive Search

Continue search on all possible paths until match found

Code -

solution.c — C

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

#define ALPHABET_SIZE 26

typedef struct TrieNode {
    struct TrieNode* children[ALPHABET_SIZE];
    bool isWord;
} TrieNode;

typedef struct {
    TrieNode* root;
} WordDictionary;

TrieNode* createNode() {
    TrieNode* node = (TrieNode*)malloc(sizeof(TrieNode));
    node->isWord = false;
    for (int i = 0; i < ALPHABET_SIZE; i++) {
        node->children[i] = NULL;
    }
    return node;
}

WordDictionary* wordDictionaryCreate() {
    WordDictionary* obj = (WordDictionary*)malloc(sizeof(WordDictionary));
    obj->root = createNode();
    return obj;
}

void wordDictionaryAddWord(WordDictionary* obj, char* word) {
    TrieNode* node = obj->root;
    int len = strlen(word);
    for (int i = 0; i < len; i++) {
        int index = word[i] - 'a';
        if (!node->children[index]) {
            node->children[index] = createNode();
        }
        node = node->children[index];
    }
    node->isWord = true;
}

bool dfs(TrieNode* node, char* word, int i, int len) {
    if (i == len) {
        return node->isWord;
    }
    
    if (word[i] == '.') {
        for (int j = 0; j < ALPHABET_SIZE; j++) {
            if (node->children[j] && dfs(node->children[j], word, i + 1, len)) {
                return true;
            }
        }
        return false;
    } else {
        int index = word[i] - 'a';
        return node->children[index] && dfs(node->children[index], word, i + 1, len);
    }
}

bool wordDictionarySearch(WordDictionary* obj, char* word) {
    return dfs(obj->root, word, 0, strlen(word));
}

Time & Space Complexity

Time Complexity

⏱️

O(m) add, O(26^k × m) search worst case

Add: m = word length. Search: k wildcards, each explores up to 26 children

✓ Linear Growth

Space Complexity

O(ALPHABET_SIZE × N × M)

Trie nodes for unique prefixes, N words of average length M

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Trie Data Structure (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler