Design add and search words data structure

Author: volodimyr

211.design_add_search_words_data_strucutre/search.py

@@ -0,0 +1,71 @@
+# 211. Design add and search words data structure
+# Topics: 'String', 'Depth-First Search', 'Design', 'Trie'
+
+# Design a data structure that supports adding new words and finding if a string matches any previously added string.
+
+# Implement the WordDictionary class:
+
+#     WordDictionary() Initializes the object.
+#     void addWord(word) Adds word to the data structure, it can be matched later.
+#     bool search(word) Returns true if there is any string in the data structure that matches word or false otherwise. word may contain dots '.' where dots can be matched with any letter.
+
+
+# Example:
+
+# Input
+# ["WordDictionary","addWord","addWord","addWord","search","search","search","search"]
+# [[],["bad"],["dad"],["mad"],["pad"],["bad"],[".ad"],["b.."]]
+# Output
+# [null,null,null,null,false,true,true,true]
+
+# Explanation
+# WordDictionary wordDictionary = new WordDictionary();
+# wordDictionary.addWord("bad");
+# wordDictionary.addWord("dad");
+# wordDictionary.addWord("mad");
+# wordDictionary.search("pad"); // return False
+# wordDictionary.search("bad"); // return True
+# wordDictionary.search(".ad"); // return True
+# wordDictionary.search("b.."); // return True
+
+ 
+
+# 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 dots in word for search queries.
+#     At most 104 calls will be made to addWord and search.
+
+class Node:
+    def __init__(self):
+        self.children = {}
+        self.word = False
+
+class WordDictionary:
+    def __init__(self):
+        self.root = Node()
+
+    def addWord(self, word: str) -> None:
+        cur = self.root
+        for c in word:
+            if c not in cur.children:
+                cur.children[c] = Node()
+            cur = cur.children[c]
+        cur.word = True
+
+    def search(self, word: str) -> bool:
+        return self.pattern_search(self.root, 0, word)
+
+    def pattern_search(self, next: Node, i: int, word: str) -> bool:
+        if i == len(word):
+            return next.word
+        if word[i] == '.':
+            for val in next.children.values():
+                if self.pattern_search(val, i+1, word):
+                    return True
+            return False
+        if word[i] not in next.children:
+            return False
+        return self.pattern_search(next.children[word[i]], i+1, word)

211.design_add_search_words_data_strucutre/test_search.py

@@ -0,0 +1,274 @@
+from search import WordDictionary
+
+def test_example_from_problem():
+    """Test the exact example from the problem statement"""
+    wd = WordDictionary()
+    
+    wd.addWord("bad")
+    wd.addWord("dad")
+    wd.addWord("mad")
+    
+    assert wd.search("pad") == False, "Should not find 'pad'"
+    assert wd.search("bad") == True, "Should find 'bad'"
+    assert wd.search(".ad") == True, "Should match '.ad' with 'bad', 'dad', 'mad'"
+    assert wd.search("b..") == True, "Should match 'b..' with 'bad'"
+    
+    print("✓ Problem example test passed")
+
+
+def test_empty_dictionary():
+    """Test operations on empty dictionary"""
+    wd = WordDictionary()
+    
+    assert wd.search("test") == False, "Empty dictionary should not find any word"
+    assert wd.search(".") == False, "Empty dictionary should not match single dot"
+    assert wd.search("...") == False, "Empty dictionary should not match dots"
+    
+    print("✓ Empty dictionary test passed")
+
+
+def test_exact_match():
+    """Test exact word matching without wildcards"""
+    wd = WordDictionary()
+    
+    wd.addWord("hello")
+    wd.addWord("world")
+    
+    assert wd.search("hello") == True, "Should find 'hello'"
+    assert wd.search("world") == True, "Should find 'world'"
+    assert wd.search("hell") == False, "Should not find 'hell'"
+    assert wd.search("worlds") == False, "Should not find 'worlds'"
+    
+    print("✓ Exact match test passed")
+
+
+def test_single_wildcard():
+    """Test patterns with single wildcard"""
+    wd = WordDictionary()
+    
+    wd.addWord("cat")
+    wd.addWord("bat")
+    wd.addWord("rat")
+    
+    assert wd.search(".at") == True, "Should match '.at'"
+    assert wd.search("c.t") == True, "Should match 'c.t'"
+    assert wd.search("ca.") == True, "Should match 'ca.'"
+    assert wd.search(".a.") == True, "Should match '.a.'"
+    
+    print("✓ Single wildcard test passed")
+
+
+def test_multiple_wildcards():
+    """Test patterns with multiple wildcards"""
+    wd = WordDictionary()
+    
+    wd.addWord("abc")
+    wd.addWord("xyz")
+    
+    assert wd.search("...") == True, "Should match '...' with 'abc' or 'xyz'"
+    assert wd.search("a..") == True, "Should match 'a..' with 'abc'"
+    assert wd.search(".b.") == True, "Should match '.b.' with 'abc'"
+    assert wd.search("..c") == True, "Should match '..c' with 'abc'"
+    assert wd.search("..d") == False, "Should not match '..d'"
+    
+    print("✓ Multiple wildcards test passed")
+
+
+def test_all_wildcards():
+    """Test pattern with all wildcards"""
+    wd = WordDictionary()
+    
+    wd.addWord("test")
+    
+    assert wd.search("....") == True, "Should match '....' with 'test'"
+    assert wd.search(".....") == False, "Should not match '.....' (length mismatch)"
+    assert wd.search("...") == False, "Should not match '...' (length mismatch)"
+    
+    print("✓ All wildcards test passed")
+
+
+def test_single_character():
+    """Test single character words"""
+    wd = WordDictionary()
+    
+    wd.addWord("a")
+    wd.addWord("b")
+    
+    assert wd.search("a") == True, "Should find 'a'"
+    assert wd.search("b") == True, "Should find 'b'"
+    assert wd.search(".") == True, "Should match '.' with 'a' or 'b'"
+    assert wd.search("c") == False, "Should not find 'c'"
+    
+    print("✓ Single character test passed")
+
+
+def test_overlapping_words():
+    """Test words with common prefixes"""
+    wd = WordDictionary()
+    
+    wd.addWord("car")
+    wd.addWord("card")
+    wd.addWord("care")
+    wd.addWord("careful")
+    
+    assert wd.search("car") == True, "Should find 'car'"
+    assert wd.search("card") == True, "Should find 'card'"
+    assert wd.search("car.") == True, "Should match 'car.' with 'card' or 'care'"
+    assert wd.search("car..") == False, "Should not match 'car..' (length mismatch with card/care)"
+    assert wd.search("car....") == True, "Should match 'car....' with 'careful'"
+    
+    print("✓ Overlapping words test passed")
+
+
+def test_wildcard_beginning():
+    """Test wildcard at the beginning"""
+    wd = WordDictionary()
+    
+    wd.addWord("apple")
+    wd.addWord("apply")
+    
+    assert wd.search(".pple") == True, "Should match '.pple' with 'apple'"
+    assert wd.search(".pply") == True, "Should match '.pply' with 'apply'"
+    assert wd.search(".pp..") == True, "Should match '.pp..' with both words"
+    
+    print("✓ Wildcard beginning test passed")
+
+
+def test_wildcard_end():
+    """Test wildcard at the end"""
+    wd = WordDictionary()
+    
+    wd.addWord("test")
+    wd.addWord("text")
+    
+    assert wd.search("tes.") == True, "Should match 'tes.' with 'test'"
+    assert wd.search("tex.") == True, "Should match 'tex.' with 'text'"
+    assert wd.search("te..") == True, "Should match 'te..' with both words"
+    
+    print("✓ Wildcard end test passed")
+
+
+def test_no_match():
+    """Test patterns that should not match"""
+    wd = WordDictionary()
+    
+    wd.addWord("hello")
+    
+    assert wd.search("world") == False, "Should not find 'world'"
+    assert wd.search("h.....") == False, "Should not match 'h....' (length mismatch)"
+    assert wd.search("x....") == False, "Should not match 'x....' (wrong prefix)"
+    assert wd.search(".ello") == True, "Should match '.ello' with 'hello'"
+    assert wd.search(".ellx") == False, "Should not match '.ellx'"
+    
+    print("✓ No match test passed")
+
+
+def test_duplicate_words():
+    """Test adding duplicate words"""
+    wd = WordDictionary()
+    
+    wd.addWord("test")
+    wd.addWord("test")
+    wd.addWord("test")
+    
+    assert wd.search("test") == True, "Should find 'test' after multiple additions"
+    assert wd.search("....") == True, "Should match '....' with 'test'"
+    
+    print("✓ Duplicate words test passed")
+
+
+def test_long_words():
+    """Test with longer words"""
+    wd = WordDictionary()
+    
+    long_word = "abcdefghij"
+    wd.addWord(long_word)
+    
+    assert wd.search(long_word) == True, "Should find long word"
+    assert wd.search("abcdefghi.") == True, "Should match with wildcard at end"
+    assert wd.search(".bcdefghij") == True, "Should match with wildcard at beginning"
+    assert wd.search("abcd.fghij") == True, "Should match with wildcard in middle"
+    
+    print("✓ Long words test passed")
+
+
+def test_wildcard_no_alternatives():
+    """Test wildcard when there are no alternatives"""
+    wd = WordDictionary()
+    
+    wd.addWord("aaa")
+    
+    assert wd.search(".aa") == True, "Should match '.aa' with 'aaa'"
+    assert wd.search("a.a") == True, "Should match 'a.a' with 'aaa'"
+    assert wd.search("aa.") == True, "Should match 'aa.' with 'aaa'"
+    assert wd.search("...") == True, "Should match '...' with 'aaa'"
+    
+    print("✓ Wildcard no alternatives test passed")
+
+
+def test_different_lengths():
+    """Test words of different lengths"""
+    wd = WordDictionary()
+    
+    wd.addWord("a")
+    wd.addWord("ab")
+    wd.addWord("abc")
+    wd.addWord("abcd")
+    
+    assert wd.search(".") == True, "Should match '.' with 'a'"
+    assert wd.search("..") == True, "Should match '..' with 'ab'"
+    assert wd.search("...") == True, "Should match '...' with 'abc'"
+    assert wd.search("....") == True, "Should match '....' with 'abcd'"
+    assert wd.search(".....") == False, "Should not match '.....' (no word that long)"
+    
+    print("✓ Different lengths test passed")
+
+
+def test_complex_patterns():
+    """Test complex wildcard patterns"""
+    wd = WordDictionary()
+    
+    wd.addWord("at")
+    wd.addWord("and")
+    wd.addWord("an")
+    wd.addWord("add")
+    
+    assert wd.search("a") == False, "Should not match 'a'"
+    assert wd.search(".at") == False, "Should not match '.at' (length mismatch)"
+    assert wd.search("an.") == True, "Should match 'an.' with 'and'"
+    assert wd.search(".nd") == True, "Should match '.nd' with 'and'"
+    assert wd.search("a.d") == True, "Should match 'a.d' with 'and' or 'add'"
+    assert wd.search("a.") == True, "Should match 'a.' with 'at' or 'an'"
+    assert wd.search(".") == False, "Should not match '.' (no single char words except none exist)"
+    
+    print("✓ Complex patterns test passed")
+
+
+def run_all_tests():
+    """Run all test cases"""
+    print("Running WordDictionary tests...\n")
+    
+    test_example_from_problem()
+    test_empty_dictionary()
+    test_exact_match()
+    test_single_wildcard()
+    test_multiple_wildcards()
+    test_all_wildcards()
+    test_single_character()
+    test_overlapping_words()
+    test_wildcard_beginning()
+    test_wildcard_end()
+    test_no_match()
+    test_duplicate_words()
+    test_long_words()
+    test_wildcard_no_alternatives()
+    test_different_lengths()
+    test_complex_patterns()
+    
+    print("\n" + "="*50)
+    print("All tests passed! ✓")
+    print("="*50)
+
+
+if __name__ == "__main__":
+    run_all_tests()