feat(algorithms, hash table): word pattern

Author: BrianLusina

algorithms/hash_table/word_pattern/README.md

@@ -0,0 +1,151 @@
+# Word Pattern
+
+Given a `pattern` and a string `s`, find if s follows the same pattern.
+
+Here follow means a full match, such that there is a bijection between a letter in `pattern` and a non-empty word in `s`.
+Specifically:
+
+- Each letter in `pattern` maps to exactly one unique word in `s`.
+- Each unique word in `s` maps to exactly one letter in `pattern`.
+- No two letters map to the same word, and no two words map to the same letter.
+
+## Examples
+
+Example 1:
+
+```text
+Input: pattern = "abba", s = "dog cat cat dog"
+Output: true
+Explanation:
+The bijection can be established as:
+
+'a' maps to "dog".
+'b' maps to "cat".
+```
+
+Example 2:
+
+```text
+Input: pattern = "abba", s = "dog cat cat fish"
+
+Output: false
+```
+
+Example 3:
+
+```text
+Input: pattern = "aaaa", s = "dog cat cat dog"
+
+Output: false
+```
+
+## Constraints
+
+- 1 <= `pattern.lengt`h <= 300
+- `pattern` contains only lower-case English letters.
+- 1 <= `s.length` <= 3000
+- `s` contains only lowercase English letters and spaces ' '.
+- `s` does not contain any leading or trailing spaces.
+- All the words in `s` are separated by a single space.
+
+## Topics
+
+- Hash Table
+- String
+
+## Solution(s)
+
+1. [Using two hash maps](#using-two-hash-maps)
+2. [Using One hash map](#using-one-hash-map)
+
+### Using two hash maps
+
+The key insight is recognizing that we need to maintain a bidirectional mapping between pattern characters and words.
+Think of it like a translation dictionary that works both ways - if we know that 'a' translates to "dog", then "dog"
+must always translate back to 'a'.
+
+Why do we need two hash tables instead of just one? Consider this scenario:
+
+- If we only track that 'a' -> "dog" and 'b' -> "dog", we wouldn't catch the error that two different letters map to the
+  same word.
+- Similarly, if pattern is "aa" and string is "dog cat", using only one mapping wouldn't detect that the same letter 'a'
+  is trying to map to two different words.
+
+The bidirectional check ensures both conditions of the bijection are satisfied:
+
+- Forward mapping (d1): Ensures each pattern character consistently maps to the same word
+- Reverse mapping (d2): Ensures each word consistently maps to the same pattern character
+
+As we iterate through the pattern and words simultaneously using zip, we check:
+
+- If we've seen this pattern character before (a in d1), does it still map to the same word?
+- If we've seen this word before (b in d2), does it still map to the same pattern character?
+
+If either check fails, we know the bijection is broken. If we successfully process all pairs without conflicts, the
+pattern matches.
+
+The initial length check (len(pattern) != len(ws)) is a quick optimization - if the pattern has a different number of
+characters than we have words, there's no possible valid mapping.
+
+### Time and Space Complexity
+
+#### Time Complexity: O(m + n), where `m` is the length of the pattern string and `n` is the length of string `s`
+
+- Splitting string `s` by spaces takes `O(n)` time as it needs to traverse the entire string.
+- The zip operation combined with the loop iterates through `min(pattern length, words length)` elements, which is at
+  most `O(m)`iterations after the length check.
+- Inside each iteration, dictionary lookups and insertions (in operator and assignment) take `O(1)` average time.
+
+Therefore, the overall time complexity is `O(n)` for splitting + `O(m)` for the loop = `O(m + n)`.
+
+#### Space Complexity: O(m + n), where `m` is the length of the pattern string and `n` is the length of string `s`
+
+- The `words` list stores all words from string `s`, which takes `O(n)` space in the worst case (when `s` contains no
+  spaces, the entire string is one word).
+- Dictionary `pattern_to_word` stores at most `m` key-value pairs (pattern characters to words), requiring `O(m)` space
+  for keys plus the space for word values.
+- Dictionary `word_to_pattern` stores at most `m` key-value pairs (words to pattern characters), requiring space for word
+  keys plus `O(m)` space for character values.
+- The total space used by both dictionaries is proportional to the number of unique pattern characters and unique words,
+  bounded by `O(m + n)`. 
+
+Therefore, the overall space complexity is `O(m + n)`.
+
+### Using One Hash Map
+
+The algorithm checks whether a given string of words follows the same pattern as a sequence of characters, ensuring a
+one-to-one correspondence (bijection) between pattern characters and words. It begins by splitting the string s into
+individual words and verifying that the number of characters in the pattern matches the number of words; if not, it
+immediately returns False. Using a hash map, the algorithm records the first index at which each pattern character and
+word appear by creating unique keys. As it iterates through the words, it checks that the indices associated with a
+character and its corresponding word remain consistent, ensuring that each character maps to exactly one word and each
+word maps to exactly one character. If any mismatch occurs in this mapping, return False; otherwise, return True,
+confirming that the string follows the specified pattern.
+
+The steps of the algorithm are as follows:
+
+1. Create an empty dictionary map_index to store the mapping indices for pattern characters and words.
+2. Use s.split() to divide the string into a list of words.
+3. If the number of characters in the pattern does not equal the number of words, return False immediately.
+4. Iterate through each character–word pair simultaneously using their indices.
+   - For each character c and word w, form two distinct keys:
+     - `char_key = 'char_{}'.format(c)`
+     - `char_word = 'word_{}'.format(w)`
+     - Assign or compare mapping indices:
+       - If a key does not exist in map_index, assign its value as the current index i.
+       - After the assignment, compare the stored indices for both keys.
+       - If the indices do not match, return False (indicating inconsistent mapping).
+5. After processing all pairs without inconsistencies, return True, confirming that the pattern matches the word sequence
+   correctly.
+
+#### Time and Space Complexity
+
+##### Time Complexity
+
+The time complexity of the above solution is `O(n)` due to splitting the string and iterating through all characters and
+words once. Each lookup and insertion in the hash map takes `O(1)` on average, making the total linear in input size.
+
+##### Space Complexity
+
+The space complexity of the above solution is `O(n)` because it stores all unique pattern–word mappings and the list of
+words. The hash map and word list grow proportionally to the number of words in the input.

algorithms/hash_table/word_pattern/__init__.py

@@ -0,0 +1,92 @@
+from typing import Dict
+
+
+def word_pattern(pattern: str, s: str) -> bool:
+    """
+    Check if a pattern matches a string following a bijective mapping.
+    Each character in pattern should map to exactly one word in s, and vice versa.
+
+    Args:
+        pattern: A string containing the pattern (e.g., "abba")
+        s: A space-separated string of words (e.g., "dog cat cat dog")
+
+    Returns:
+        True if the pattern matches the string, False otherwise
+    """
+    # Split the string into individual words
+    words = s.split()
+
+    # If lengths don't match, pattern cannot be followed
+    if len(pattern) != len(words):
+        return False
+
+    # Dictionary to map pattern characters to words
+    pattern_to_word: Dict[str, str] = {}
+    # Dictionary to map words to pattern characters (ensures bijection)
+    word_to_pattern: Dict[str, str] = {}
+
+    # Iterate through pattern characters and corresponding words simultaneously
+    for pattern_char, word in zip(pattern, words):
+        # Check if pattern character already has a different word mappting
+        if pattern_char in pattern_to_word and pattern_to_word[pattern_char] != word:
+            return False
+
+        # Check if word already has a different pattern character mapping
+        if word in word_to_pattern and word_to_pattern[word] != pattern_char:
+            return False
+
+        # Establish the bidirectional mapping
+        pattern_to_word[pattern_char] = word
+        word_to_pattern[word] = pattern_char
+
+    return True
+
+
+def word_pattern_2(pattern: str, s: str) -> bool:
+    """
+    Check if a pattern matches a string following a bijective mapping.
+    Each character in pattern should map to exactly one word in s, and vice versa.
+
+    Args:
+        pattern: A string containing the pattern (e.g., "abba")
+        s: A space-separated string of words (e.g., "dog cat cat dog")
+
+    Returns:
+        True if the pattern matches the string, False otherwise
+    """
+    # Create a dictionary to store index mappings for both characters and words
+    map_index: Dict[str, int] = {}
+
+    # Split the input string into individual words
+    words = s.split()
+
+    # If the number of pattern characters and words don't match,
+    # there can't be a one-to-one correspondence
+    if len(pattern) != len(words):
+        return False
+
+    # Iterate through each character-word pair
+    for idx in range(len(words)):
+        pattern_char = pattern[idx]  # Current character in the pattern
+        word = words[idx]  # Corresponding word in the string
+
+        # Create separate keys for characters and words
+        # This helps differentiate between them in the same dictionary
+        char_key = f"char_{pattern_char}"
+        char_word = f"word_{word}"
+
+        # If this character hasn't been seen before, store its index
+        if char_key not in map_index:
+            map_index[char_key] = idx
+
+        # If this word hasn't been seen before, store its index
+        if char_word not in map_index:
+            map_index[char_word] = idx
+
+        # If the indices for the character and word don't match,
+        # it means they were mapped inconsistently — return False
+        if map_index[char_key] != map_index[char_word]:
+            return False
+
+    # If we finish the loop without mismatches, the pattern is valid
+    return True

algorithms/hash_table/word_pattern/test_word_pattern.py

@@ -0,0 +1,29 @@
+import unittest
+from parameterized import parameterized
+from utils.test_utils import custom_test_name_func
+from algorithms.hash_table.word_pattern import word_pattern, word_pattern_2
+
+WORD_PATTERN_TEST_CASES = [
+    ("abba", "dog cat cat dog", True),
+    ("abba", "dog dog dog dog", False),
+    ("abba", "dog cat cat fish", False),
+    ("aaaa", "dog cat cat dog", False),
+    ("abc", "red blue green", True),
+    ("abcba", "sun moon star moon sun", True),
+]
+
+
+class WordPatternTestCase(unittest.TestCase):
+    @parameterized.expand(WORD_PATTERN_TEST_CASES, name_func=custom_test_name_func)
+    def test_word_pattern(self, pattern: str, s: str, expected: bool):
+        actual = word_pattern(pattern, s)
+        self.assertEqual(expected, actual)
+
+    @parameterized.expand(WORD_PATTERN_TEST_CASES, name_func=custom_test_name_func)
+    def test_word_pattern_2(self, pattern: str, s: str, expected: bool):
+        actual = word_pattern_2(pattern, s)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()