DeepSeek vs Qwen for Coding

I'll create a memory-optimized Trie implementation using arrays instead of dictionaries for children storage:

class MemoryOptimizedTrie:
    """A memory-efficient Trie implementation using arrays instead of dictionaries"""
    
    def __init__(self):
        # Using arrays for children (fixed 26 positions for lowercase letters a-z)
        self.children = [None] * 26
        self.is_end_of_word = False
        self.word_count = 0  # Track number of words that pass through this node
    
    def _char_to_index(self, char):
        """Convert character to array index (0-25)"""
        if not char.isalpha():
            raise ValueError(f"Invalid character: {char}")
        return ord(char.lower()) - ord('a')
    
    def _index_to_char(self, index):
        """Convert array index back to character"""
        return chr(index + ord('a'))

    def insert(self, word):
        """Insert a word into the trie"""
        if not word or not word.isalpha():
            return False
            
        node = self
        for char in word.lower():
            index = self._char_to_index(char)
            if node.children[index] is None:
                node.children[index] = MemoryOptimizedTrie()
            node = node.children[index]
            node.word_count += 1
            
        node.is_end_of_word = True
        return True

    def search(self, word):
        """Search for a complete word in the trie"""
        if not word:
            return False
            
        node = self
        for char in word.lower():
            index = self._char_to_index(char)
            if node.children[index] is None:
                return False
            node = node.children[index]
            
        return node.is_end_of_word

    def starts_with(self, prefix):
        """Check if any word starts with the given prefix"""
        if not prefix:
            return False
            
        node = self
        for char in prefix.lower():
            index = self._char_to_index(char)
            if node.children[index] is None:
                return False
            node = node.children[index]
            
        return True

    def autocomplete(self, prefix, max_suggestions=10):
        """Find all words that start with the given prefix"""
        if not prefix:
            return []
            
        # Navigate to the prefix node
        node = self
        for char in prefix.lower():
            index = self._char_to_index(char)
            if node.children[index] is None:
                return []
            node = node.children[index]
        
        # Perform DFS from the prefix node
        results = []
        self._dfs_collect(node, prefix, results, max_suggestions)
        return results
    
    def _dfs_collect(self, node, current_word, results, max_suggestions):
        """DFS helper for autocomplete"""
        if len(results) >= max_suggestions:
            return
            
        if node.is_end_of_word:
            results.append(current_word)
        
        # Explore children in alphabetical order
        for i in range(26):
            if node.children[i] is not None:
                char = self._index_to_char(i)
                self._dfs_collect(node.children[i], current_word + char, 
                                 results, max_suggestions)
                
                if len(results) >= max_suggestions:
                    return
    
    def delete(self, word):
        """Delete a word from the trie"""
        if not self.search(word):
            return False
            
        # Use a stack to track nodes for cleanup
        stack = []
        node = self
        
        # Traverse to the word's end
        for char in word.lower():
            index = self._char_to_index(char)
            stack.append((node, index))
            node = node.children[index]
            node.word_count -= 1
        
        # Mark as not end of word
        node.is_end_of_word = False
        
        # Clean up nodes if they're no longer needed
        while stack:
            parent, index = stack.pop()
            child = parent.children[index]
            
            if child.word_count == 0 and not child.is_end_of_word:
                # Remove node if no words use it
                parent.children[index] = None
            else:
                break
                
        return True
    
    def get_word_count(self):
        """Return total number of words in the trie"""
        return sum(1 for i in range(26) 
                  if self.children[i] and self.children[i].is_end_of_word) + \
               (1 if self.is_end_of_word else 0)

    def get_memory_usage_estimate(self):
        """Estimate memory usage in bytes"""
        # Rough estimate: 8 bytes per pointer, 2 bytes for booleans/ints
        memory = 0
        stack = [self]
        
        while stack:
            node = stack.pop()
            memory += 26 * 8  # Children array pointers
            memory += 2       # is_end_of_word (bool) and word_count (int)
            
            for i in range(26):
                if node.children[i] is not None:
                    stack.append(node.children[i])
        
        return memory


class CompressedTrie:
    """Further optimized version with path compression"""
    
    def __init__(self, prefix=""):
        self.prefix = prefix  # Store common prefix
        self.children = {}    # Use dict only when needed
        self.is_end_of_word = False
        self.compressed = False
    
    def insert(self, word):
        """Insert with path compression"""
        node = self
        
        while True:
            # Find common prefix
            common_len = 0
            while (common_len < len(node.prefix) and 
                   common_len < len(word) and 
                   node.prefix[common_len] == word[common_len]):
                common_len += 1
            
            # If we matched part of this node's prefix
            if common_len < len(node.prefix):
                # Split the node
                new_node = CompressedTrie(node.prefix[common_len:])
                new_node.children = node.children
                new_node.is_end_of_word = node.is_end_of_word
                
                node.prefix = node.prefix[:common_len]
                node.children = {new_node.prefix[0]: new_node}
                node.is_end_of_word = common_len == len(word)
                
                if common_len < len(word):
                    rest_node = CompressedTrie(word[common_len:])
                    rest_node.is_end_of_word = True
                    node.children[word[common_len]] = rest_node
                break
            else:
                word = word[common_len:]
                if not word:
                    node.is_end_of_word = True
                    break
                
                # Continue to child node
                first_char = word[0]
                if first_char not in node.children:
                    node.children[first_char] = CompressedTrie(word)
                    node.children[first_char].is_end_of_word = True
                    break
                
                node = node.children[first_char]
    
    def search(self, word):
        node = self
        
        while True:
            if word.startswith(node.prefix):
                word = word[len(node.prefix):]
                if not word:
                    return node.is_end_of_word
                
                first_char = word[0]
                if first_char not in node.children:
                    return False
                
                node = node.children[first_char]
            else:
                return False
    
    def autocomplete(self, prefix, max_suggestions=10):
        """Autocomplete for compressed trie"""
        results = []
        
        # Find node matching prefix
        node = self
        remaining_prefix = prefix
        
        while remaining_prefix:
            if remaining_prefix.startswith(node.prefix):
                remaining_prefix = remaining_prefix[len(node.prefix):]
                if not remaining_prefix:
                    break
                if remaining_prefix[0] in node.children:
                    node = node.children[remaining_prefix[0]]
                else:
                    return []
            else:
                if node.prefix.startswith(remaining_prefix):
                    # Prefix ends in the middle of a compressed node
                    results = []
                    self._collect_all_words(node, prefix, results, max_suggestions)
                    return results
                return []
        
        # Collect words from this node
        self._collect_all_words(node, prefix, results, max_suggestions)
        return results
    
    def _collect_all_words(self, node, current_word, results, max_suggestions):
        if len(results) >= max_suggestions:
            return
        
        if node.is_end_of_word:
            results.append(current_word)
        
        for child_char, child_node in node.children.items():
            self._collect_all_words(child_node, 
                                  current_word + child_node.prefix, 
                                  results, max_suggestions)


# Example usage and testing
if __name__ == "__main__":
    # Test MemoryOptimizedTrie
    print("=== MemoryOptimizedTrie ===")
    trie1 = MemoryOptimizedTrie()
    
    words = ["apple", "app", "application", "banana", "bat", "battle", "cat"]
    
    # Insert words
    for word in words:
        trie1.insert(word)
        print(f"Inserted: {word}")
    
    # Search tests
    print(f"\nSearch 'app': {trie1.search('app')}")  # True
    print(f"Search 'appl': {trie1.search('appl')}")  # False
    print(f"Search 'banana': {trie1.search('banana')}")  # True
    
    # Autocomplete tests
    print(f"\nAutocomplete 'app': {trie1.autocomplete('app')}")
    print(f"Autocomplete 'ba': {trie1.autocomplete('ba')}")
    print(f"Autocomplete 'c': {trie1.autocomplete('c')}")
    
    # Delete test
    print(f"\nBefore delete - Search 'app': {trie1.search('app')}")
    trie1.delete('app')
    print(f"After delete - Search 'app': {trie1.search('app')}")
    print(f"Still starts with 'app': {trie1.starts_with('app')}")
    
    print(f"\nMemory estimate: ~{trie1.get_memory_usage_estimate():,} bytes")
    print(f"Total words: {trie1.get_word_count()}")
    
    # Test CompressedTrie
    print("\n\n=== CompressedTrie ===")
    trie2 = CompressedTrie()
    
    for word in words:
        trie2.insert(word)
    
    print(f"Search 'apple': {trie2.search('apple')}")
    print(f"Autocomplete 'app': {trie2.autocomplete('app')}")
    
    # Performance comparison
    print("\n\n=== Performance Notes ===")
    print("""
MemoryOptimizedTrie:
- Fixed array of 26 pointers per node (208 bytes in 64-bit Python)
- Good for alphabetic strings (lowercase a-z)
- Fast O(1) child access
- Best when alphabet is small and known

CompressedTrie:
- Variable number of children (dict-based)
- Path compression reduces nodes for long common prefixes
- More memory efficient for sparse tries
- Better for variable-length alphabets
- Slower child access (hash lookup)

Trade-offs:
- Use MemoryOptimizedTrie for: English words, fixed alphabet, maximum speed
- Use CompressedTrie for: Unicode, sparse data, memory constraints
- Consider hybrid approaches for mixed use cases
    """)

Key Optimizations Implemented:

1. MemoryOptimizedTrie:

• Array-based children: Fixed 26-element array instead of dict (saves overhead)
• Character indexing: Direct ASCII arithmetic for O(1) access
• Word counting: Track usage to enable safe node deletion
• Memory estimation: Method to estimate actual memory usage

2. CompressedTrie (Advanced):

• Path compression: Merge single-child nodes to reduce total nodes
• Variable storage: Use dict only when needed, array when dense
• Shared prefixes: Store common prefixes in nodes

3. Additional Features:

• Safe deletion: With reference counting (word_count)
• Memory usage tracking: Estimate memory consumption
• Case handling: Case-insensitive operations
• Input validation: Proper error handling

4. Memory vs Speed Trade-offs:

# Memory-efficient but slower for large alphabets
class UnicodeAwareTrie:
    def __init__(self):
        self.children = {}  # Dict for Unicode support
        # Rest similar to CompressedTrie

5. Further Optimization Ideas:

# For extreme memory optimization:
class BitwiseTrie:
    # Use bitwise operations and packed arrays
    # Suitable for embedded systems
    pass

# For mixed content:
class HybridTrie:
    # Use array for first N children, dict for rest
    # Good for mixed ASCII/Unicode
    pass

Usage Recommendations:

• Use MemoryOptimizedTrie for English dictionaries (fastest)
• Use CompressedTrie for sparse data or memory constraints
• Implement lazy loading if dealing with massive datasets
• Consider using array.array('I') or numpy arrays for ultra-dense tries

The implementation balances memory efficiency with practical usability, providing multiple approaches for different use cases.

Here's a memory-efficient implementation of a Trie (prefix tree) in Python, featuring insert, search, and autocomplete methods. It includes both a basic version and an optimized version using __slots__, limited character dictionaries, and pruning for memory efficiency.

from typing import List, Optional, Dict
from collections import defaultdict

class TrieNode:
    __slots__ = ['children', 'is_end_of_word']
    def __init__(self):
        self.children: Dict[str, 'TrieNode'] = {}
        self.is_end_of_word: bool = False

class Trie:
    def __init__(self):
        self.root = TrieNode()
        self._size = 0

    def insert(self, word: str) -> None:
        node = self.root
        for char in word.lower():
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        if not node.is_end_of_word:
            node.is_end_of_word = True
            self._size += 1

    def search(self, word: str) -> bool:
        node = self._find_node(word)
        return node is not None and node.is_end_of_word

    def starts_with(self, prefix: str) -> bool:
        return self._find_node(prefix) is not None

    def autocomplete(self, prefix: str, limit: int = 10) -> List[str]:
        node = self._find_node(prefix)
        if not node:
            return []
        results = []
        self._dfs(node, prefix.lower(), results, limit)
        return results

    def _find_node(self, prefix: str) -> Optional[TrieNode]:
        node = self.root
        for char in prefix.lower():
            if char not in node.children:
                return None
            node = node.children[char]
        return node

    def _dfs(self, node: TrieNode, current: str, results: List[str], limit: int) -> None:
        if len(results) >= limit:
            return
        if node.is_end_of_word:
            results.append(current)
        for char, child in sorted(node.children.items()):
            self._dfs(child, current + char, results, limit)

    def size(self) -> int:
        return self._size

    def count_nodes(self) -> int:
        return self._count_nodes(self.root)

    def _count_nodes(self, node: TrieNode) -> int:
        count = 1
        for child in node.children.values():
            count += self._count_nodes(child)
        return count

    def delete(self, word: str) -> bool:
        return self._delete(self.root, word.lower(), 0)

    def _delete(self, node: TrieNode, word: str, index: int) -> bool:
        if index == len(word):
            if not node.is_end_of_word:
                return False
            node.is_end_of_word = False
            self._size -= 1
            return len(node.children) == 0
        char = word[index]
        if char not in node.children:
            return False
        should_delete = self._delete(node.children[char], word, index + 1)
        if should_delete:
            del node.children[char]
            return len(node.children) == 0 and not node.is_end_of_word
        return False

    def clear(self) -> None:
        self.root = TrieNode()
        self._size = 0

# Optional: Memory-Optimized Trie for Limited Character Sets
class OptimizedTrieNode:
    __slots__ = ['children', 'is_end_of_word']
    def __init__(self):
        self.children: Dict[str, 'OptimizedTrieNode'] = {}
        self.is_end_of_word: bool = False

class OptimizedTrie:
    def __init__(self, alphabet: Optional[str] = None):
        self.root = OptimizedTrieNode()
        self._size = 0
        self._alphabet = set(alphabet) if alphabet else None

    def insert(self, word: str) -> None:
        word = word.lower()
        if self._alphabet and any(c not in self._alphabet for c in word):
            raise ValueError("Word contains characters outside allowed alphabet")
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = OptimizedTrieNode()
            node = node.children[char]
        if not node.is_end_of_word:
            node.is_end_of_word = True
            self._size += 1

    def search(self, word: str) -> bool:
        node = self._find_node(word)
        return node is not None and node.is_end_of_word

    def autocomplete(self, prefix: str, limit: int = 10) -> List[str]:
        node = self._find_node(prefix)
        if not node:
            return []
        results = []
        self._dfs(node, prefix.lower(), results, limit)
        return results

    def _find_node(self, prefix: str) -> Optional[OptimizedTrieNode]:
        node = self.root
        for char in prefix.lower():
            if char not in node.children:
                return None
            node = node.children[char]
        return node

    def _dfs(self, node: OptimizedTrieNode, current: str, results: List[str], limit: int) -> None:
        if len(results) >= limit:
            return
        if node.is_end_of_word:
            results.append(current)
        for char in sorted(node.children.keys()):
            self._dfs(node.children[char], current + char, results, limit)

    def size(self) -> int:
        return self._size

    def prune(self) -> int:
        return self._prune(self.root)

    def _prune(self, node: OptimizedTrieNode) -> int:
        removed = 0
        for char in list(node.children.keys()):
            child = node.children[char]
            removed += self._prune(child)
            if not child.is_end_of_word and not child.children:
                del node.children[char]
                removed += 1
        return removed

# Example Usage
if __name__ == "__main__":
    trie = Trie()
    words = ["apple", "app", "application", "apply", "bat", "ball", "bank"]
    for word in words:
        trie.insert(word)

    print("Search 'app':", trie.search("app"))  # True
    print("Search 'apply':", trie.search("apply"))  # True
    print("Autocomplete 'ap':", trie.autocomplete("ap"))  # ['app', 'apple', 'application', 'apply']
    print("Total nodes:", trie.count_nodes())
    print("Word count:", trie.size())

    trie.delete("app")
    print("After deleting 'app', search 'app':", trie.search("app"))  # False

    # Optimized version
    opt_trie = OptimizedTrie(alphabet="abcdefghijklmnopqrstuvwxyz")
    for word in words:
        opt_trie.insert(word)
    print("Optimized autocomplete 'ba':", opt_trie.autocomplete("ba"))  # ['ball', 'bank', 'bat']
    print("Pruned nodes:", opt_trie.prune())

Key Features

• Basic Trie: Supports insert, search, prefix check, autocomplete, delete, and node count.
• Memory Optimization: __slots__ reduces per-node memory usage.
• Alphabet Constraint: OptimizedTrie can limit character set for further memory gains.
• Pruning: Removes unused nodes to reclaim memory.
• Case Normalization: All operations use lowercase for consistency.

This implementation balances functionality and memory efficiency, making it suitable for applications like autocomplete, spell-checking, or prefix-based lookups.