One In.
One Out.
Keep Going.

What it asks: Given an integer array and a window size k, find the contiguous subarray of length k with the maximum average. Return that average.

The window holds a running sum. Every slide is a two-number transaction: subtract the element that just left, add the element that just arrived. Everything else in the window is unaffected. At the end, divide by k exactly once.

def findMaxAverage(nums, k):
    total   = 0
    max_sum = float('-inf')
    left    = 0

    for right in range(len(nums)):
        total += nums[right]            # ADD: new element enters

        if right >= k - 1:               # window is full
            max_sum = max(max_sum, total) # USE: record best
            total  -= nums[left]          # REMOVE: old element leaves
            left   += 1

    return max_sum / k                 # divide ONCE at the end

Common Pitfalls

• ✗
  Dividing inside the loop on every step — unnecessary and slow. Divide once at the end.
• ✗
  Storing max_avg (a float) instead of max_sum (an integer). Float comparison accumulates rounding error.

What it asks: Count the number of subarrays of length k whose average is greater than or equal to a given threshold.

def numOfSubarrays(arr, k, threshold):
    target = k * threshold          # multiply once, avoid floats forever
    total  = 0
    count  = 0
    left   = 0

    for right in range(len(arr)):
        total += arr[right]

        if right >= k - 1:
            if total >= target:          # USE: does this window qualify?
                count += 1              # ← this is the only changed part
            total -= arr[left]
            left  += 1

    return count

Common Pitfalls

• ✗
  > vs >= — the problem says "greater than or equal to". Re-read the condition before submitting.
• ✗
  Sliding before scoring the window — this counts the next window, not the current one. Always: add → check window size → use → remove → advance left.

What it asks: Given a string and window size k, find the maximum number of vowels in any substring of length k.

This is LC 643 in disguise. Replace "value of the element" with "is it a vowel (1) or not (0)". The running sum IS the vowel count. The add() and remove() steps just become conditional.

def maxVowels(s, k):
    vowels  = set('aeiou')
    cnt     = 0
    max_cnt = 0
    left    = 0

    for right in range(len(s)):
        if s[right] in vowels:          # ADD: only count vowels
            cnt += 1

        if right >= k - 1:
            max_cnt = max(max_cnt, cnt)
            if s[left] in vowels:         # REMOVE: only undo vowels
                cnt -= 1
            left += 1

    return max_cnt

Common Pitfalls

• ✗
  Unconditionally decrementing cnt for the leaving element — you only decrement if it was a vowel. The if guard is essential.
• ✗
  Using s[right] == 'a' or == 'e' ... — just use a set lookup. Cleaner and O(1).

What it asks: Given a string and window size k, count the number of substrings of length k where all characters are unique.

The key insight: if k characters fit into exactly k slots and distinct == k, there can be no repeats — each slot must hold a different character. You don't need to check every pair; just track how many distinct characters are in the window.

from collections import defaultdict

def countKLengthSubstrings(s, k):
    if k > 26:                         # only 26 lowercase letters — impossible
        return 0

    freq     = defaultdict(int)       # ← state upgraded to a frequency map
    distinct = 0                       # chars currently in window with freq > 0
    count    = 0
    left     = 0

    for right in range(len(s)):
        c = s[right]
        freq[c] += 1
        if freq[c] == 1:                 # first time c appears in window
            distinct += 1

        if right >= k - 1:
            if distinct == k:           # all characters are unique
                count += 1

            d = s[left]
            freq[d] -= 1
            if freq[d] == 0:            # c is fully gone from window
                distinct -= 1
            left += 1

    return count

Common Pitfalls

• ✗
  Forgetting to decrement distinct when freq[d] hits exactly 0. If you decrement unconditionally, distinct goes negative for duplicates.
• ✗
  Confusing this with the variable-window problem "longest substring with at most k distinct" — that shrinks the window. This one holds it fixed.

What it asks: Return True if any two equal values in the array exist at indices no more than k apart.

This problem doesn't say "substrings of size exactly k". It says "any two equal values within distance k". The window holds the last k values seen. If the current value is already in there, you found a pair. Check membership before inserting.

def containsNearbyDuplicate(nums, k):
    seen = set()                        # ← state is a set, not a map

    for right in range(len(nums)):

        if nums[right] in seen:          # USE first — before adding
            return True
        seen.add(nums[right])            # ADD

        if right >= k:                   # REMOVE when window exceeds k
            seen.remove(nums[right - k])

    return False

Why a set and not a map?

Common Pitfalls

• ✗
  Off-by-one on the removal trigger: the window holds at most k previous elements, so remove at right >= k (not k - 1).
• ✗
  Removing the wrong index — nums[right - k] is the element that entered exactly k steps ago. Off by one here causes a silent wrong answer.

What it asks: Given a circular code array, replace each element code[i] with the sum of the next k elements (if k > 0) or the previous |k| elements (if k < 0). If k = 0, all values are zero.

The "circular" part only lives in the indexing. Build the first window once — compute its sum directly. Then for each of the n positions: record the sum, subtract the element that just left, add the element that just arrived — both using % n to wrap around.

def decrypt(code, k):
    n      = len(code)
    result = [0] * n

    if k == 0:
        return result                    # all zeros

    # Set window direction based on sign of k
    if k > 0:
        start, size = 1, k               # next k elements
    else:
        start, size = n - abs(k), abs(k) # previous |k| elements

    # Build the first window once
    total = sum(code[(start + j) % n] for j in range(size))

    for i in range(n):
        result[i] = total               # USE: record answer for this position
        total -= code[(start + i) % n]         # REMOVE: left element exits
        total += code[(start + i + size) % n]   # ADD: right element enters

    return result

Common Pitfalls

• ✗
  Mixing up which index is subtracted vs added during the slide — draw it out once on paper before coding.
• ✗
  In languages other than Python, negative modulo can return a negative number. Use (idx % n + n) % n to be safe in C++/Java.
• ✗
  Recomputing the window from scratch for each position — that's O(n·|k|). Build once, slide in O(1).