Fixed & Variable Windows
What is this?
Picture a frame that slides across a row of numbers, lighting up a stretch of them like a moving spotlight. A window comes in two shapes: a fixed one that stays the same width and just rolls forward, and a variable one that stretches wider or pulls in tighter as the data demands. Either way, you only update what changed at the edges instead of re-scanning everything.
π‘ Fun fact: Fixed-size sliding windows are exactly how moving-average filters work in audio and signal processing β smoothing out a noisy sound or stock chart by averaging the last few samples as the window glides along.
π The 4 problems in this chapter are free. Sign in with Google or Microsoft to start solving.
Core idea: A sliding window turns an O(nΒ²) "check every subarray" into one O(n) pass by reusing the previous window's work. Two shapes cover most problems: a fixed-width window that rolls one step at a time (update +entering / βleaving), and a variable window that expands to grow a quantity, then shrinks to restore a constraint.
The two shapes
Fixed windows answer "best/quantity over every length-k span." Variable windows answer "longest/shortest span satisfying a constraint" β the right edge always advances; the left edge only moves to keep (or restore) validity, so each index enters and leaves at most once β O(n).
The problems
- Maximum Average Subarray I β the fixed-window intro: roll the sum in O(1) per step.
- Fruits into Baskets β longest window with at most 2 distinct (the "at most k distinct" template).
- Minimum Size Subarray Sum β shortest window reaching a target; shrink while still valid.
- Longest Subarray of 1's After Deleting One β a window carrying a violation budget (at most one zero).
Key takeaways
- Reuse, don't recompute β the window's answer is one cheap edit from the next.
- Fixed = roll (+in/βout); variable = expand then shrink to stay valid.
- Each index enters/leaves once β O(n) even with the inner shrink loop.
- "Longest" shrinks on invalidity; "shortest" shrinks on validity β mirror images.
- Why interviewers love it: it's the cleanest "turn O(nΒ²) into O(n)" move on sequences.
Start here: Maximum Average Subarray I (fixed), then Fruits into Baskets (variable).
Maximum Average Subarray I
Core idea: A fixed-size window of width
kslides across the array one step at a time. Don't recompute its sum from scratch at every position β update it incrementally: add the element that just entered on the right, subtract the one that just left on the left. One window's answer is one cheap edit away from the next.
Problem, rephrased
You're watching a stock ticker that reports one price per minute. Your boss wants the best k-minute stretch the stock had today β specifically, the highest average price over any window of exactly k consecutive minutes. Not the best single minute, not the best of the whole day: the best contiguous k-minute slice.
You don't need to know which minutes, and you don't need a list of candidates. You need one number: the maximum average value over all contiguous subarrays of length exactly k.
Formally (LeetCode 643): given an integer array nums and an integer k, find the contiguous subarray of length exactly k whose average value is the largest, and return that average as a float.
nums |
k |
Output | Why |
|---|---|---|---|
[1,12,-5,-6,50,3] |
4 | 12.75 | (12-5-6+50)/4 = 51/4 |
[5] |
1 | 5.0 | only one window, the whole array |
[0,4,0,3,2] |
1 | 4.0 | best single element is 4 |
[-1,-2,-3,-4] |
2 | -1.5 | (-1-2)/2, the "least negative" pair |
[1,2,3,4,5] |
5 | 3.0 | only one window: the whole array |
Sign in to continue reading
The rest of this lesson is available with a free account. Signing in with Google or Microsoft is free.
Sign in to read the full lesson