def fixedWindow(arr: List[int], k: int) -> int:
    """
    Fixed size window of size k.
    Time: O(n), Space: O(1)
    """
    if len(arr) < k:
        return 0
    
    # Initialize first window
    window_sum = sum(arr[:k])
    max_sum = window_sum
    
    # Slide window
    for i in range(k, len(arr)):
        # Add new element, remove leftmost
        window_sum += arr[i] - arr[i - k]
        max_sum = max(max_sum, window_sum)
    
    return max_sum

def variableWindow(s: str, constraint: int) -> int:
    """
    Variable size window with constraint.
    Time: O(n), Space: O(k) for counter
    """
    left = 0
    max_length = 0
    window_state = {}  # Track window contents
    
    for right in range(len(s)):
        # Expand window - add right element
        char = s[right]
        window_state[char] = window_state.get(char, 0) + 1
        
        # Contract window - move left if constraint violated
        while CONSTRAINT_VIOLATED(window_state, constraint):
            left_char = s[left]
            window_state[left_char] -= 1
            if window_state[left_char] == 0:
                del window_state[left_char]
            left += 1
        
        # Update result
        max_length = max(max_length, right - left + 1)
    
    return max_length

def lengthOfLongestSubstring(s: str) -> int:
    """
    Find longest substring with all unique characters.
    Time: O(n), Space: O(min(n, charset_size))
    """
    char_index = {}  # char -> last seen index
    left = 0
    max_length = 0
    
    for right, char in enumerate(s):
        # If char seen in current window, move left past it
        if char in char_index and char_index[char] >= left:
            left = char_index[char] + 1
        
        char_index[char] = right
        max_length = max(max_length, right - left + 1)
    
    return max_length

def minWindow(s: str, t: str) -> str:
    """
    Find minimum window in s containing all chars from t.
    Time: O(m + n), Space: O(k)
    """
    if not s or not t:
        return ""
    
    # Count chars in t
    target = Counter(t)
    required = len(target)
    formed = 0
    
    window_counts = {}
    left = 0
    min_len = float('inf')
    min_left = 0
    
    for right, char in enumerate(s):
        # Expand window
        window_counts[char] = window_counts.get(char, 0) + 1
        
        if char in target and window_counts[char] == target[char]:
            formed += 1
        
        # Contract window
        while left <= right and formed == required:
            # Update result
            if right - left + 1 < min_len:
                min_len = right - left + 1
                min_left = left
            
            # Remove from left
            left_char = s[left]
            window_counts[left_char] -= 1
            if left_char in target and window_counts[left_char] < target[left_char]:
                formed -= 1
            left += 1
    
    return "" if min_len == float('inf') else s[min_left:min_left + min_len]

def longestOnes(nums: List[int], k: int) -> int:
    """
    Longest subarray with at most k zeros flipped.
    Time: O(n), Space: O(1)
    """
    left = 0
    zeros_count = 0
    max_length = 0
    
    for right in range(len(nums)):
        # Expand window
        if nums[right] == 0:
            zeros_count += 1
        
        # Contract if too many zeros
        while zeros_count > k:
            if nums[left] == 0:
                zeros_count -= 1
            left += 1
        
        max_length = max(max_length, right - left + 1)
    
    return max_length

Is window size fixed or variable?
├─ Fixed size k
│  ├─ Track sum/count? → Initialize first k, slide by 1
│  └─ Track frequencies? → Hash map, update on slide
└─ Variable size
   ├─ Find maximum length? → Expand right, shrink left when invalid
   ├─ Find minimum length? → Expand until valid, shrink for minimum
   └─ Count subarrays? → For each right, count valid lefts

def exactlyK(s: str, k: int) -> int:
    """
    Subarrays with exactly k distinct = atMostK(k) - atMostK(k-1)
    """
    def atMostK(k: int) -> int:
        left = count = 0
        freq = {}
        
        for right, char in enumerate(s):
            freq[char] = freq.get(char, 0) + 1
            
            while len(freq) > k:
                freq[s[left]] -= 1
                if freq[s[left]] == 0:
                    del freq[s[left]]
                left += 1
            
            count += right - left + 1
        
        return count
    
    return atMostK(k) - atMostK(k - 1)

from collections import deque

def maxSlidingWindow(nums: List[int], k: int) -> List[int]:
    """
    Maximum in each window of size k.
    Time: O(n), Space: O(k)
    """
    deq = deque()  # Store indices, maintain decreasing order
    result = []
    
    for right, num in enumerate(nums):
        # Remove elements outside window
        if deq and deq[0] < right - k + 1:
            deq.popleft()
        
        # Remove smaller elements (they'll never be max)
        while deq and nums[deq[-1]] < num:
            deq.pop()
        
        deq.append(right)
        
        # Add to result once window is size k
        if right >= k - 1:
            result.append(nums[deq[0]])
    
    return result

def findAnagrams(s: str, p: str) -> List[int]:
    """
    Find all anagram starting positions.
    Fixed window with frequency matching.
    """
    if len(p) > len(s):
        return []
    
    p_count = Counter(p)
    s_count = Counter(s[:len(p)])
    result = [0] if s_count == p_count else []
    
    for right in range(len(p), len(s)):
        # Add new char
        s_count[s[right]] += 1
        
        # Remove old char
        left_char = s[right - len(p)]
        s_count[left_char] -= 1
        if s_count[left_char] == 0:
            del s_count[left_char]
        
        # Check if anagram
        if s_count == p_count:
            result.append(right - len(p) + 1)
    
    return result