D. J.:

- Added the leetcode problem and solution for 79, 208, 211 and 212

Author: nobodyPerfecZ

README.md

@@ -61,6 +61,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [73 Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/description/)
 - [76 Minimum Window Substring](https://leetcode.com/problems/minimum-window-substring/description/)
+- [79 Word Search](https://leetcode.com/problems/word-search/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [82 Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
 - [86 Partition List](https://leetcode.com/problems/partition-list/description/)
@@ -110,8 +111,11 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [202 Happy Number](https://leetcode.com/problems/happy-number/description/)
 - [205 Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/description/)
 - [207 Course Schedule](https://leetcode.com/problems/course-schedule/description/)
+- [208 Implement Trie (Prefix Tree)](https://leetcode.com/problems/implement-trie-prefix-tree/description/)
 - [209 Minimum Size Subarray Sum](https://leetcode.com/problems/minimum-size-subarray-sum)
 - [210 Course Schedule](https://leetcode.com/problems/course-schedule-ii/description/)
+- [211 Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure/description/)
+- [212 Word Search II](https://leetcode.com/problems/word-search-ii/description/)
 - [219 Contains Duplicates II](https://leetcode.com/problems/contains-duplicate-ii/description/)
 - [222 Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/description/)
 - [224 Basic Calculator](https://leetcode.com/problems/basic-calculator/description/)

awesome_python_leetcode/_208_implement_trie_prefix_tree.py

@@ -0,0 +1,53 @@
+from typing import Dict
+
+
+class Trie:
+    """
+    A trie (pronounced as "try") or prefix tree is a tree data structure used to
+    efficiently store and retrieve keys in a dataset of strings. There are various
+    applications of this data structure, such as autocomplete and spellchecker.
+
+    Implement the Trie class:
+    - Trie() Initializes the trie object.
+    - void insert(String word) Inserts the string word into the trie.
+    - boolean search(String word) Returns true if the string word is in the trie
+    (i.e., was inserted before), and false otherwise.
+    - boolean startsWith(String prefix) Returns true if there is a previously inserted
+    string word that has the prefix prefix, and false otherwise.
+    """
+
+    def __init__(
+        self,
+        val: str = None,
+        end: bool = False,
+        letters: Dict[str, "Trie"] = None,
+    ):
+        self.val = val
+        self.end = end
+        self.letters = letters if letters is not None else {}
+
+    def insert(self, word: str) -> None:
+        parent = self
+        for i, c in enumerate(word, 1):
+            end = i == len(word)
+            if c not in parent.letters:
+                parent.letters[c] = Trie(val=c)
+            if end:
+                parent.letters[c].end = end
+            parent = parent.letters[c]
+
+    def search(self, word: str) -> bool:
+        parent = self
+        for c in word:
+            if c not in parent.letters:
+                return False
+            parent = parent.letters[c]
+        return parent.end
+
+    def startsWith(self, prefix: str) -> bool:
+        parent = self
+        for c in prefix:
+            if c not in parent.letters:
+                return False
+            parent = parent.letters[c]
+        return True

awesome_python_leetcode/_211_design_add_and_search_words_data_structure.py

@@ -0,0 +1,48 @@
+from typing import Dict
+
+
+class WordDictionary:
+    """
+    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.
+    """
+
+    def __init__(
+        self,
+        val: str = None,
+        end: bool = False,
+        letters: Dict[str, "WordDictionary"] = None,
+    ):
+        self.val = val
+        self.end = end
+        self.letters = letters if letters is not None else {}
+
+    def addWord(self, word: str) -> None:
+        parent = self
+        for i, c in enumerate(word, 1):
+            end = i == len(word)
+            if c not in parent.letters:
+                parent.letters[c] = WordDictionary(val=c)
+            if end:
+                parent.letters[c].end = end
+            parent = parent.letters[c]
+
+    def search(self, word: str) -> bool:
+        parent = self
+        for i, c in enumerate(word):
+            if c == ".":
+                found = False
+                for c_ in parent.letters:
+                    found = found | parent.letters[c_].search(word[i + 1 :])
+                return found
+            elif c not in parent.letters:
+                return False
+            parent = parent.letters[c]
+        return parent.end

awesome_python_leetcode/_212_word_search_II.py

@@ -0,0 +1,62 @@
+from typing import Dict, List
+
+
+class Trie:
+    def __init__(self, end: bool = False, letters: Dict[str, "Trie"] = None):
+        self.end = end
+        self.children = letters if letters is not None else {}
+
+    def insert(self, word: str) -> None:
+        parent = self
+        for c in word:
+            if c not in parent.children:
+                parent.children[c] = Trie()
+            parent = parent.children[c]
+        parent.end = True
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        """
+        Given an m x n board of characters and a list of strings words, return all words
+        on the board.
+
+        Each word must be constructed from letters of sequentially adjacent cells,
+        where adjacent cells are horizontally or vertically neighboring. The same
+        letter cell may not be used more than once in a word.
+        """
+
+        root = Trie()
+        for word in words:
+            root.insert(word)
+
+        res, path = set(), set()
+
+        def dfs(row: int, col: int, node: Trie, word: str):
+            if (
+                row < 0
+                or row >= len(board)
+                or col < 0
+                or col >= len(board[0])
+                or board[row][col] not in node.children
+                or (row, col) in path
+            ):
+                return False
+            path.add((row, col))
+            node = node.children[board[row][col]]
+            word += board[row][col]
+            if node.end:
+                res.add(word)
+            dfs(row + 1, col, node, word)
+            dfs(row - 1, col, node, word)
+            dfs(row, col + 1, node, word)
+            dfs(row, col - 1, node, word)
+            path.remove((row, col))
+            return res
+
+        for row in range(len(board)):
+            for col in range(len(board[0])):
+                dfs(row, col, root, "")
+        return list(res)

awesome_python_leetcode/_79_word_search.py

@@ -0,0 +1,44 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        """
+        Given an m x n grid of characters board and a string word, return true if word
+        exists in the grid.
+
+        The word can be constructed from letters of sequentially adjacent cells, where
+        adjacent cells are horizontally or vertically neighboring. The same letter cell
+        may not be used more than once.
+        """
+        path = set()
+
+        def dfs(row: int, col: int, i: int):
+            if i == len(word):
+                return True
+            if (
+                row < 0
+                or row >= len(board)
+                or col < 0
+                or col >= len(board[0])
+                or board[row][col] != word[i]
+                or (row, col) in path
+            ):
+                return False
+            path.add((row, col))
+            res = (
+                dfs(row + 1, col, i + 1)
+                or dfs(row - 1, col, i + 1)
+                or dfs(row, col + 1, i + 1)
+                or dfs(row, col - 1, i + 1)
+            )
+            path.remove((row, col))
+            return res
+
+        for row in range(len(board)):
+            for col in range(len(board[0])):
+                if dfs(row, col, 0):
+                    return True
+        return False

tests/test_208_implement_trie_prefix_tree.py

@@ -0,0 +1,12 @@
+from awesome_python_leetcode._208_implement_trie_prefix_tree import Trie
+
+
+def test_func():
+    """Tests the solution of a LeetCode problem."""
+    trie = Trie()
+    trie.insert("apple")
+    assert trie.search("apple") is True
+    assert trie.search("app") is False
+    assert trie.startsWith("app") is True
+    trie.insert("app")
+    assert trie.search("app") is True

tests/test_211_design_add_and_search_words_data_structure.py

@@ -0,0 +1,15 @@
+from awesome_python_leetcode._211_design_add_and_search_words_data_structure import (
+    WordDictionary,
+)
+
+
+def test_func():
+    """Tests the solution of a LeetCode problem."""
+    wordDict = WordDictionary()
+    wordDict.addWord("bad")
+    wordDict.addWord("dad")
+    wordDict.addWord("mad")
+    assert wordDict.search("pad") is False
+    assert wordDict.search("bad") is True
+    assert wordDict.search(".ad") is True
+    assert wordDict.search("b..") is True

tests/test_212_word_search_II.py

@@ -0,0 +1,25 @@
+from typing import List
+import pytest
+from awesome_python_leetcode._212_word_search_II import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["board", "words", "expected"],
+    argvalues=[
+        (
+            [
+                ["o", "a", "a", "n"],
+                ["e", "t", "a", "e"],
+                ["i", "h", "k", "r"],
+                ["i", "f", "l", "v"],
+            ],
+            ["oath", "pea", "eat", "rain"],
+            ["eat", "oath"],
+        ),
+        ([["a", "b"], ["c", "d"]], ["abcb"], []),
+    ],
+)
+def test_func(board: List[List[str]], words: List[str], expected: List[str]):
+    """Tests the solution of a LeetCode problem."""
+    words_founded = Solution().findWords(board, words)
+    assert set(words_founded) == set(expected)

tests/test_79_word_search.py

@@ -0,0 +1,31 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._79_word_search import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["board", "word", "expected"],
+    argvalues=[
+        (
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]],
+            "ABCCED",
+            True,
+        ),
+        (
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]],
+            "SEE",
+            True,
+        ),
+        (
+            [["A", "B", "C", "E"], ["S", "F", "C", "S"], ["A", "D", "E", "E"]],
+            "ABCB",
+            False,
+        ),
+    ],
+)
+def test_func(board: List[List[str]], word: str, expected: bool):
+    """Tests the solution of a LeetCode problem."""
+    exist = Solution().exist(board, word)
+    assert exist is expected