A dynamic window expands and contracts over an array/string to maintain a running state in O(N) time.

Data Flow

array = [2, 1, 3, 4, 5, 2, 1, 7]

        start             end
          |                |
        +---+---+---+---+---+---+---+---+
        | 2 | 1 | 3 | 4 | 5 | 2 | 1 | 7 |
        +---+---+---+---+---+---+---+---+
        | <----------- window ----------->|
              expand end one step at a time
              shrink start when constraint violated

When to use

• Longest/shortest subarray/substring that satisfies a constraint.
• The constraint is monotone (once violated inside the window, removing from the left restores it).

How it works

1. Initialise start = 0, answer = ....
2. For end in range(N): add arr[end]. While constraint violated, subtract arr[start] and start += 1. Record answer.
3. Return answer.

Code (max sum of any size-K subarray)

def max_sum_subarray_k(arr, k):
    cur = sum(arr[:k])
    best = cur
    for end in range(k, len(arr)):
        cur += arr[end] - arr[end - k]
        best = max(best, cur)
    return best

Pitfalls

• Updating end but forgetting to shrink start -> O(N*K) by accident.
• Off-by-one when computing end - k + 1 for window length.

Analogy

A 60-second timeline in a video editor: scrub forward (end++) or trim from the start (start++).

Interview tip: State out loud: expand until invalid, shrink until valid, record answer. Repeat this catchphrase whenever the constraint changes.