Sliding window is a two-pointer pattern over contiguous subarrays/substrings that turns nested-loop O(n²) into single-pass O(n).

The pattern

Maintain a window [l, r] and a running state (sum, frequency map, char set). Expand by moving r forward; shrink from l when the window violates a constraint; record the best window as you go.

Two flavors

1. Fixed-size window — "max sum of subarray of size k"

function maxSum(arr, k) {
  let sum = 0;
  for (let i = 0; i < k; i++) sum += arr[i];
  let best = sum;
  for (let r = k; r < arr.length; r++) {
    sum += arr[r] - arr[r - k];   // slide
    best = Math.max(best, sum);
  }
  return best;
}

2. Variable-size window — "longest substring without repeating chars"

function lengthOfLongestSubstring(s) {
  const seen = new Map();
  let l = 0, best = 0;
  for (let r = 0; r < s.length; r++) {
    if (seen.has(s[r]) && seen.get(s[r]) >= l) {
      l = seen.get(s[r]) + 1;     // shrink
    }
    seen.set(s[r], r);
    best = Math.max(best, r - l + 1);
  }
  return best;
}

When to reach for it

• Asks about contiguous subarrays/substrings (not subsequences).
• Asks for a max/min length or sum/count under a constraint.
• Constraint changes monotonically as the window grows (so shrinking restores validity).

Classic problems

• Longest substring without repeating characters.
• Minimum window substring (smallest window containing all chars of t).
• Max sum subarray of size k.
• Longest substring with at most k distinct characters.
• Find all anagrams of p in s.

Interview framing

"For contiguous-range problems with a constraint, I think sliding window: a left and right pointer, expand right to grow, shrink left when constrained, track the best window as I go. It collapses the obvious O(n²) of nested loops into O(n) with a single pass and a running state — usually a frequency map or running sum."