HashMap Pattern

def two_sum(nums, target):
    """Find indices of two numbers that sum to target"""
    seen = {}  # value -> index
    
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    
    return []

from collections import Counter

def top_k_frequent(nums, k):
    """Return k most frequent elements"""
    count = Counter(nums)
    return [num for num, _ in count.most_common(k)]

def is_anagram(s, t):
    """Check if t is anagram of s"""
    return Counter(s) == Counter(t)

from collections import defaultdict

def group_anagrams(strs):
    """Group strings that are anagrams of each other"""
    groups = defaultdict(list)
    
    for s in strs:
        key = tuple(sorted(s))  # or count-based key
        groups[key].append(s)
    
    return list(groups.values())

def subarray_sum_equals_k(nums, k):
    """Count subarrays with sum exactly k"""
    count = 0
    prefix_sum = 0
    sum_count = {0: 1}  # prefix_sum -> frequency
    
    for num in nums:
        prefix_sum += num
        
        # If (prefix_sum - k) exists, those many subarrays sum to k
        if prefix_sum - k in sum_count:
            count += sum_count[prefix_sum - k]
        
        sum_count[prefix_sum] = sum_count.get(prefix_sum, 0) + 1
    
    return count

def longest_consecutive(nums):
    """Find length of longest consecutive sequence"""
    num_set = set(nums)
    max_length = 0
    
    for num in num_set:
        # Only start counting from sequence start
        if num - 1 not in num_set:
            current = num
            length = 1
            
            while current + 1 in num_set:
                current += 1
                length += 1
            
            max_length = max(max_length, length)
    
    return max_length

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity):
        self.cache = OrderedDict()
        self.capacity = capacity
    
    def get(self, key):
        if key not in self.cache:
            return -1
        self.cache.move_to_end(key)
        return self.cache[key]
    
    def put(self, key, value):
        if key in self.cache:
            self.cache.move_to_end(key)
        self.cache[key] = value
        if len(self.cache) > self.capacity:
            self.cache.popitem(last=False)