Fix all ruff linting errors

- Fix advanced_trie.py:
  - Replace deprecated typing.List/Dict/Set with built-in list/dict/set
  - Replace Optional[T] with T | None syntax
  - Remove unused imports (Set, re)
  - Fix line length issues
  - Convert else-if chains to elif
  - Remove f-string prefixes where no placeholders
  - Fix unused variable by prefixing with underscore

- Fix bloom_filter.py:
  - Replace deprecated typing.List with built-in list
  - Replace Union[T, U] with T | U syntax
  - Remove unnecessary int() casting around math.ceil()
  - Remove f-string prefixes where no placeholders

- Fix fenwick_tree.py:
  - Replace deprecated typing.List with built-in list
  - Fix exception f-string issues by assigning to variables first
  - Remove f-string prefixes where no placeholders

- Fix segment_tree.py:
  - Replace deprecated typing.List with built-in list
  - Import Callable from collections.abc instead of typing
  - Fix Optional type annotations
  - Fix exception f-string issues by assigning to variables first
  - Remove f-string prefixes where no placeholders

- Fix fft_cooley_tukey.py:
  - Replace deprecated typing.List/Tuple with built-in list/tuple
  - Fix long line by breaking into multiple lines
  - Remove unused typing.Optional import

All files now pass ruff linting checks and follow modern Python type annotation standards.

Author: TechnoBlogger14o3

data_structures/advanced_trie.py

@@ -13,20 +13,19 @@
     - Search: O(m) where m is the length of the string
     - Delete: O(m) where m is the length of the string
     - Prefix search: O(m + k) where m is prefix length, k is number of results
-Space Complexity: O(ALPHABET_SIZE * N * M) where N is number of strings, M is average length
+Space Complexity: O(ALPHABET_SIZE * N * M) where N is number of strings, M is avg length
 
 Reference: https://en.wikipedia.org/wiki/Trie
 """
 
-from typing import List, Set, Optional, Dict, Any
-import re
+from typing import Optional, Any
 
 
 class TrieNode:
     """Node in the Trie data structure."""
 
     def __init__(self):
-        self.children: Dict[str, "TrieNode"] = {}
+        self.children: dict[str, TrieNode] = {}
         self.is_end_of_word: bool = False
         self.word_count: int = 0  # Number of words ending at this node
         self.prefix_count: int = 0  # Number of words with this prefix
@@ -171,7 +170,7 @@ def _delete_helper(self, node: TrieNode, word: str, index: int) -> bool:
         node.prefix_count -= 1
         return len(node.children) == 0 and not node.is_end_of_word
 
-    def _find_node(self, word: str) -> Optional[TrieNode]:
+    def _find_node(self, word: str) -> TrieNode | None:
         """
         Find the node corresponding to the given word.
 
@@ -199,7 +198,7 @@ def _find_node(self, word: str) -> Optional[TrieNode]:
             node = node.children[char]
         return node
 
-    def get_all_words_with_prefix(self, prefix: str) -> List[str]:
+    def get_all_words_with_prefix(self, prefix: str) -> list[str]:
         """
         Get all words that start with the given prefix.
 
@@ -226,7 +225,7 @@ def get_all_words_with_prefix(self, prefix: str) -> List[str]:
         return words
 
     def _collect_words(
-        self, node: TrieNode, current_word: str, words: List[str]
+        self, node: TrieNode, current_word: str, words: list[str]
     ) -> None:
         """
         Collect all words from a given node.
@@ -251,7 +250,7 @@ def _collect_words(
         for char, child_node in node.children.items():
             self._collect_words(child_node, current_word + char, words)
 
-    def autocomplete(self, prefix: str, max_results: int = 10) -> List[str]:
+    def autocomplete(self, prefix: str, max_results: int = 10) -> list[str]:
         """
         Get autocomplete suggestions for the given prefix.
 
@@ -341,7 +340,7 @@ def get_prefix_count(self, prefix: str) -> int:
         node = self._find_node(prefix)
         return node.prefix_count if node else 0
 
-    def pattern_search(self, pattern: str) -> List[str]:
+    def pattern_search(self, pattern: str) -> list[str]:
         """
         Search for words matching a pattern with wildcards.
         Supports '*' for any character and '?' for single character.
@@ -365,7 +364,7 @@ def pattern_search(self, pattern: str) -> List[str]:
         return words
 
     def _pattern_search_helper(
-        self, node: TrieNode, current_word: str, pattern: str, words: List[str]
+        self, node: TrieNode, current_word: str, pattern: str, words: list[str]
     ) -> None:
         """Helper method for pattern search."""
         if not pattern:
@@ -389,14 +388,13 @@ def _pattern_search_helper(
                 self._pattern_search_helper(
                     child_node, current_word + child_char, remaining_pattern, words
                 )
-        else:
+        elif char in node.children:
             # Match exact character
-            if char in node.children:
-                self._pattern_search_helper(
-                    node.children[char], current_word + char, remaining_pattern, words
-                )
+            self._pattern_search_helper(
+                node.children[char], current_word + char, remaining_pattern, words
+            )
 
-    def get_all_words(self) -> List[str]:
+    def get_all_words(self) -> list[str]:
         """
         Get all words in the trie.
 
@@ -448,7 +446,7 @@ def _compress(self) -> None:
     def _compress_helper(self, node: TrieNode) -> None:
         """Helper method for compression."""
         if len(node.children) == 1 and not node.is_end_of_word:
-            child_char, child_node = next(iter(node.children.items()))
+            _child_char, child_node = next(iter(node.children.items()))
             # Merge single child
             node.children = child_node.children
             node.is_end_of_word = child_node.is_end_of_word
@@ -477,22 +475,22 @@ def _compress_helper(self, node: TrieNode) -> None:
     print(f"\nTrie size: {len(trie)}")
 
     # Search operations
-    print(f"\nSearch operations:")
+    print("\nSearch operations:")
     search_words = ["hello", "help", "xyz", "world"]
     for word in search_words:
         result = trie.search(word)
         print(f"'{word}': {'Found' if result else 'Not found'}")
 
     # Prefix operations
-    print(f"\nPrefix operations:")
+    print("\nPrefix operations:")
     prefixes = ["hel", "wor", "xyz"]
     for prefix in prefixes:
         has_prefix = trie.starts_with(prefix)
         words_with_prefix = trie.get_all_words_with_prefix(prefix)
         print(f"Prefix '{prefix}': {has_prefix}, Words: {words_with_prefix}")
 
     # Autocomplete
-    print(f"\nAutocomplete:")
+    print("\nAutocomplete:")
     autocomplete_prefixes = ["hel", "wor"]
     for prefix in autocomplete_prefixes:
         suggestions = trie.autocomplete(prefix, 3)
@@ -502,20 +500,20 @@ def _compress_helper(self, node: TrieNode) -> None:
     print(f"\nLongest common prefix: '{trie.longest_common_prefix()}'")
 
     # Pattern search
-    print(f"\nPattern search:")
+    print("\nPattern search:")
     patterns = ["hel*", "wor?", "h*"]
     for pattern in patterns:
         matches = trie.pattern_search(pattern)
         print(f"Pattern '{pattern}': {matches}")
 
     # Word counts
-    print(f"\nWord counts:")
+    print("\nWord counts:")
     trie.insert("hello")  # Insert again
     print(f"'hello' count: {trie.get_word_count('hello')}")
     print(f"'hel' prefix count: {trie.get_prefix_count('hel')}")
 
     # Delete operation
-    print(f"\nDelete operation:")
+    print("\nDelete operation:")
     print(f"Before delete - 'help' exists: {trie.search('help')}")
     trie.delete("help")
     print(f"After delete - 'help' exists: {trie.search('help')}")
@@ -524,4 +522,4 @@ def _compress_helper(self, node: TrieNode) -> None:
     # All words
     print(f"\nAll words in trie: {trie.get_all_words()}")
 
-    print(f"\nTrie implementation completed successfully!")
+    print("\nTrie implementation completed successfully!")

data_structures/bloom_filter.py

@@ -15,7 +15,7 @@
 
 import hashlib
 import math
-from typing import List, Union
+from typing import Union
 
 
 class BloomFilter:
@@ -62,15 +62,15 @@ def _calculate_size(self, n: int, p: float) -> int:
 
         # m = -(n * ln(p)) / (ln(2)^2)
         size = -(n * math.log(p)) / (math.log(2) ** 2)
-        return int(math.ceil(size))
+        return math.ceil(size)
 
     def _calculate_hash_functions(self, m: int, n: int) -> int:
         """Calculate optimal number of hash functions."""
         # k = (m/n) * ln(2)
         k = (m / n) * math.log(2)
-        return int(math.ceil(k))
+        return math.ceil(k)
 
-    def _hash(self, item: Union[str, bytes], seed: int) -> int:
+    def _hash(self, item: str | bytes, seed: int) -> int:
         """
         Generate hash value for an item with given seed.
 
@@ -100,7 +100,7 @@ def _hash(self, item: Union[str, bytes], seed: int) -> int:
 
         return int(hash_obj.hexdigest(), 16) % self.size
 
-    def add(self, item: Union[str, bytes]) -> None:
+    def add(self, item: str | bytes) -> None:
         """
         Add an item to the Bloom Filter.
 
@@ -119,7 +119,7 @@ def add(self, item: Union[str, bytes]) -> None:
 
         self.count += 1
 
-    def contains(self, item: Union[str, bytes]) -> bool:
+    def contains(self, item: str | bytes) -> bool:
         """
         Check if an item might be in the Bloom Filter.
 
@@ -193,7 +193,7 @@ def __len__(self) -> int:
         """Return the number of items added to the filter."""
         return self.count
 
-    def __contains__(self, item: Union[str, bytes]) -> bool:
+    def __contains__(self, item: str | bytes) -> bool:
         """Support 'in' operator."""
         return self.contains(item)
 
@@ -237,14 +237,14 @@ def _calculate_size(self, n: int, p: float) -> int:
             raise ValueError("False positive rate must be between 0 and 1")
 
         size = -(n * math.log(p)) / (math.log(2) ** 2)
-        return int(math.ceil(size))
+        return math.ceil(size)
 
     def _calculate_hash_functions(self, m: int, n: int) -> int:
         """Calculate optimal number of hash functions."""
         k = (m / n) * math.log(2)
-        return int(math.ceil(k))
+        return math.ceil(k)
 
-    def _hash(self, item: Union[str, bytes], seed: int) -> int:
+    def _hash(self, item: str | bytes, seed: int) -> int:
         """Generate hash value for an item with given seed."""
         if isinstance(item, str):
             item = item.encode("utf-8")
@@ -264,7 +264,7 @@ def _hash(self, item: Union[str, bytes], seed: int) -> int:
 
         return int(hash_obj.hexdigest(), 16) % self.size
 
-    def add(self, item: Union[str, bytes]) -> None:
+    def add(self, item: str | bytes) -> None:
         """Add an item to the Counting Bloom Filter."""
         for i in range(self.hash_functions):
             index = self._hash(item, i)
@@ -292,7 +292,7 @@ def remove(self, item: Union[str, bytes]) -> bool:
         self.count -= 1
         return True
 
-    def contains(self, item: Union[str, bytes]) -> bool:
+    def contains(self, item: str | bytes) -> bool:
         """Check if an item might be in the Counting Bloom Filter."""
         for i in range(self.hash_functions):
             index = self._hash(item, i)
@@ -316,7 +316,7 @@ def contains(self, item: Union[str, bytes]) -> bool:
         bf.add(item)
         print(f"Added: {item}")
 
-    print(f"\nBloom Filter Info:")
+    print("\nBloom Filter Info:")
     print(f"Size: {bf.size}")
     print(f"Hash Functions: {bf.hash_functions}")
     print(f"Items Added: {len(bf)}")
@@ -325,13 +325,13 @@ def contains(self, item: Union[str, bytes]) -> bool:
 
     # Test contains
     test_items = ["apple", "banana", "grape", "kiwi", "mango"]
-    print(f"\nTesting items:")
+    print("\nTesting items:")
     for item in test_items:
         result = bf.contains(item)
         print(f"'{item}': {'Found' if result else 'Not found'}")
 
     # Counting Bloom Filter example
-    print(f"\nCounting Bloom Filter Example")
+    print("\nCounting Bloom Filter Example")
     print("=" * 50)
 
     cbf = CountingBloomFilter(expected_items=100, false_positive_rate=0.05)
@@ -346,6 +346,6 @@ def contains(self, item: Union[str, bytes]) -> bool:
     print(f"Contains 'test2': {cbf.contains('test2')}")
     print(f"Contains 'test1': {cbf.contains('test1')}")
 
-    print(f"\nCounting Bloom Filter Info:")
+    print("\nCounting Bloom Filter Info:")
     print(f"Items: {len(cbf)}")
     print(f"Load Factor: {cbf.get_load_factor():.3f}")