feat(algorithms, trie): replace words algorithm

Replace words using different approaches to solving the problem

Author: BrianLusina

algorithms/trie/replace_words/README.md

@@ -0,0 +1,162 @@
+# Replace Words
+
+In this problem, we are considering the words that are composed of a prefix and a postfix. For example, if we append a
+postfix “happy” to a prefix “un”, it forms the word “unhappy”. Similarly, “disagree” is formed from a prefix, “dis”
+followed by a postfix, “agree”.
+
+You’re given a dictionary, dictionary, consisting of prefixes, and a sentence, sentence, which has words separated by
+spaces only. Your task is to replace the postfix in sentence with their prefixes given in dictionary (if found) and
+return the modified sentence.
+
+A couple of points to keep in mind:
+
+- If a postfix in the sentence matches more than one prefix in the dictionary, replace it with the prefix that has the
+  shortest length. For example, if we have the sentence “iphone is amazing”, and the dictionary {“i”, “ip”, “hone”},
+  then the word “iphone” has two prefixes in the dictionary “i” and “ip”, but we will replace it with the one that is
+  shorter among the two, that is, “i”.
+- If there is no root word against any word in the sentence, leave it unchanged.
+
+## Constraints
+
+- 1 <= dictionary.length <= 1000
+- 1 <= `dictionary[i].length` <= 100
+- `dictionary[i]` consists of only lower-case letters.
+- 1 <= `sentence.length` <= 10^6
+- `sentence` consists of only lower-case letters and spaces.
+- The number of words in `sentence` is in the range `[1, 1000]`
+- The length of each word in `sentence` is in the range `[1, 1000]`
+- Every two consecutive words in `sentence` will be separated by exactly one space.
+- `sentence` does not have leading or trailing spaces.
+
+## Examples
+
+Example 1:
+
+```text
+Input: dictionary = ["cat","bat","rat"], sentence = "the cattle was rattled by the battery"
+Output: "the cat was rat by the bat"
+```
+
+Example 2:
+
+```text
+Input: dictionary = ["a","b","c"], sentence = "aadsfasf absbs bbab cadsfafs"
+Output: "a a b c"
+```
+
+Example 3:
+
+```text
+Input: dictionary = ["a", "aa", "aaa", "aaaa"], sentence = "a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa"
+Output: "a a a a a a a a bbb baba a"
+```
+
+Example 4:
+
+```text
+Input: dictionary = ["catt","cat","bat","rat"], sentence = "the cattle was rattled by the battery"
+Output: "the cat was rat by the bat"
+```
+
+Example 5:
+
+```text
+Input: dictionary = ["ac","ab"], sentence = "it is abnormal that this solution is accepted"
+Output: "it is ab that this solution is ac"
+```
+
+## Topics
+
+- Array
+- Hash Table
+- String
+- Trie
+
+## Solution(s)
+
+1. [Naive Approach](#naive-approach)
+2. [Optimized approach using trie](#optimized-approach-using-trie)
+
+### Naive approach
+
+This problem requires us to observe the leading characters (prefixes) of words in a sentence that can be replaced with
+the shortest matching prefix from a dictionary.
+
+In the naive approach, we traverse the given sentence, and for each word, we compare it with each prefix in the given
+dictionary to find the shortest matching prefix against it, if any. To make sure that we get to the right prefix, we
+store the respective lengths of prefixes with them. Additionally, we keep track of the shortest prefix as well. If, at
+any point, a match is found, we compare its length with the length of the shortest match found up to that point. If it
+is shorter than the current shortest prefix, we update the value of the shortest prefix.
+
+In this approach, we iterate through each word in the sentence, which takes O(n) time, where n is the number of words in
+a sentence. For each word, we iterate over the prefixes in the dictionary, which takes O(d) time, where d is the number
+of prefixes in the dictionary. Therefore, the overall time complexity for this approach is O(n×d).
+
+### Optimized approach using trie
+
+Searching for the shortest prefixes for all the words in the given sentence requires repeated searches in the dictionary.
+While this would be an expensive proposition if we keep our dictionary words in data structures like arrays and linked
+lists, some more advanced data structures, such as tries, help reduce our search time complexity. In this approach, we
+first store all the dictionary prefixes in a trie and then find the shortest prefix against each word of the sentence so
+that we can perform the required replacement.
+
+> A trie is visualized as a tree of characters that allows storing strings as graphs. A trie stores a word in a top-down
+> manner where all words having common leading characters (prefixes) have a common parent.
+
+To store the dictionary prefixes in the trie, we start from its root node and perform the following steps repeatedly
+until we’ve stored all the words:
+
+- We check if the current character of the dictionary prefix is listed among the immediate children of the current node.
+  - If it doesn’t exist, we create a new trie node for this character as a child of the current node and move to this new
+    trie node.
+  - If it exists among the children, we simply move to that node.
+- If the current character is the last character of a given dictionary prefix, we use a flag to mark the trie node holding
+  this last character. This flag represents the completion of a dictionary prefix on the trie. For example, if we have
+  the prefix “dis” in the dictionary, then when we reach “s” and store it in the trie. We mark this node with the flag
+  to represent that the word, “dis”, has been completed.
+
+After we are done creating the trie from the dictionary prefixes, we start to locate the matching prefix for each word
+of the sentence. Once found, we replace the word in the sentence with it. For example, if the input sentence is
+“fantastic” and the given dictionary is [“fanta”, “tic”, “fan”], then both “fanta” and “fan” are matching prefixes for
+“fantastic”, but we replace it with “fan” since it is the shortest of all the found matches. Since we are using a trie,
+our search automatically picks up the shortest matching prefix, and we don’t need to do it later.
+
+To traverse all the words in the sentence, we store them in a list. Then, for each word, wi, perform the following:
+
+- Start with the first character, `wi[0]`, and look at whether the same character exists in any of the children of the
+  root node of the trie.
+  - If it exists, it implies that the prefix for `wi` exists, and we can continue as follows:
+    - For remaining characters, keep looking for the matching character in the trie one by one.
+    - If at any point while searching and matching, we reach a node that is flagged for being the last character, we
+      stop and return this prefix as the shortest matching prefix for `wi`
+  - Otherwise, the prefix against `wi` doesn’t exist, so just move to the next word of the sentence.
+
+
+Once found, replace the original word `wi` in the list with its matched prefix. Keep doing this until we process the
+last word in the sentence. In the end, change the list of words back to the string representing the modified sentence
+and return it as the output.
+
+#### Summary
+
+Let’s review the optimized approach we have discussed above.
+
+- Create a trie and store all the dictionary prefixes in it.
+- Traverse the sentence and use the trie to find the shortest matching prefix for each word of the sentence.
+- Once found, replace the original word of the sentence with the matched prefix. We do this for all the words in the
+  sentence.
+- If no matching prefix is found, leave the word as it is and move to the next word in the sentence.
+- Return the modified sentence as the output.
+
+#### Time Complexity
+
+It takes O(m) time to create a trie from the given dictionary prefixes, where m is the sum of the number of characters
+of all the prefixes in the dictionary.
+
+Then, it takes O(n) time to iterate over each word in the sentence and find its matching prefix in the trie, where n is
+the number of words in the sentence.
+
+Therefore, the overall time complexity for this approach is O(n+m).
+
+#### Space Complexity
+
+The space complexity is O(m), where m is the sum of the number of characters of all the prefixes in the dictionary.

puzzles/replace_words/__init__.py algorithms/trie/replace_words/__init__.pypuzzles/replace_words/__init__.py renamed to algorithms/trie/replace_words/__init__.py

@@ -1,6 +1,7 @@
 import collections
 from functools import reduce
 from typing import List
+from datastructures import Trie, TrieNode
 
 
 def replace_words_with_prefix_hash(dictionary: List[str], sentence: str) -> str:
@@ -74,3 +75,44 @@ def replace(word: str) -> str:
         return cur.get(end, word)
 
     return " ".join(map(replace, sentence.split()))
+
+
+def replace_words_with_trie_2(sentence: str, dictionary: List[str]) -> str:
+    trie = Trie()
+
+    # iterate over the prefixes in the dictionary and insert them into the trie
+    for prefix in dictionary:
+        trie.insert(prefix)
+
+    # Store each of the word in the sentence in a new list
+    word_list = sentence.split()
+
+    # iterate over all the words in the list
+    for idx in range(len(word_list)):
+
+        def replace(root: TrieNode, word: str) -> str:
+            """
+            This replaces each word in the sentence with the smallest word from the dictionary
+            """
+            curr = root
+            # iterate over each dictionary word along with the index of that character
+            for i, char in enumerate(word):
+                # If the character does not belong to the current node's children, then return the word
+                if char not in curr.children:
+                    return word
+
+                # Move to the child of the current node corresponding to the current character
+                curr = curr.children[char]
+
+                # When the flag is_end becomes true, this means we have reached the end of the word in the trie. If this is
+                # the case, then return this word
+                if curr.is_end:
+                    return word[: i + 1]
+
+            return word
+
+        # replace each word in the word_list with the shortest prefix from the trie
+        word_list[idx] = replace(trie.root, word_list[idx])
+
+    # After replacing each word with the shortest matching prefix, convert the list of words back to a single sentence.
+    return " ".join(word_list)

algorithms/trie/replace_words/test_replace_words.py

@@ -0,0 +1,60 @@
+import unittest
+from typing import List
+from parameterized import parameterized
+from utils.test_utils import custom_test_name_func
+from algorithms.trie.replace_words import (
+    replace_words_with_prefix_hash,
+    replace_words_with_trie,
+    replace_words_with_trie_2,
+)
+
+REPLACE_WORDS_TEST_CASES = [
+    (
+        ["cat", "bat", "rat"],
+        "the cattle was rattled by the battery",
+        "the cat was rat by the bat",
+    ),
+    (
+        ["a", "aa", "aaa", "aaaa"],
+        "a aa a aaaa aaa aaa aaa aaaaaa bbb baba ababa",
+        "a a a a a a a a bbb baba a",
+    ),
+    (["a", "b", "c"], "aadsfasf absbs bbab cadsfafs", "a a b c"),
+    (
+        ["catt", "cat", "bat", "rat"],
+        "the cattle was rattled by the battery",
+        "the cat was rat by the bat",
+    ),
+    (
+        ["ac", "ab"],
+        "it is abnormal that this solution is accepted",
+        "it is ab that this solution is ac",
+    ),
+]
+
+
+class ReplaceWordsHashTestCases(unittest.TestCase):
+    @parameterized.expand(REPLACE_WORDS_TEST_CASES, name_func=custom_test_name_func)
+    def test_replace_words_with_prefix_hash(
+        self, dictionary: List[str], sentence: str, expected: str
+    ):
+        actual = replace_words_with_prefix_hash(dictionary, sentence)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(REPLACE_WORDS_TEST_CASES, name_func=custom_test_name_func)
+    def test_replace_words_with_trie(
+        self, dictionary: List[str], sentence: str, expected: str
+    ):
+        actual = replace_words_with_trie(dictionary, sentence)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(REPLACE_WORDS_TEST_CASES, name_func=custom_test_name_func)
+    def test_replace_words_with_trie_2(
+        self, dictionary: List[str], sentence: str, expected: str
+    ):
+        actual = replace_words_with_trie_2(dictionary=dictionary, sentence=sentence)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()

datastructures/__init__.py

@@ -1,3 +1,20 @@
 from datastructures.sets import DisjointSetUnion, UnionFind
+from datastructures.trees.trie import (
+    Trie,
+    TrieNode,
+    AlphabetTrieNode,
+    AlphabetTrie,
+    SuffixTreeNode,
+    SuffixTree,
+)
 
-__all__ = ["DisjointSetUnion", "UnionFind"]
+__all__ = [
+    "DisjointSetUnion",
+    "UnionFind",
+    "Trie",
+    "TrieNode",
+    "AlphabetTrieNode",
+    "AlphabetTrie",
+    "SuffixTreeNode",
+    "SuffixTree",
+]

datastructures/trees/trie/trie.py

@@ -43,15 +43,22 @@ def insert(self, word: str, index: Optional[int] = None) -> None:
             None
         """
         curr = self.root
+        # Strip the word of any leading or trailing white spaces
         stripped_word = word.strip()
 
+        # Iterate through each character in the word
         for char in stripped_word:
+            # If the character does not belong to any child of the current trie node, then create a new trie node for
+            # this character as a child of the current node
             if char not in curr.children:
                 curr.children[char] = TrieNode()
+
+            # move to the child of the current node (either already present or just added)
             curr = curr.children[char]
             if index is not None:
                 if curr.index is None or index < curr.index:
                     curr.index = index
+        # Set a flag as the end of the inserted word
         curr.is_end = True
 
     def search_exact(self, word: str) -> bool: