Interactive Lab · DSA & Algorithms
Here's a question you will see: given an array, find the largest sum of any k consecutive elements. The obvious answer re-adds all k numbers for every position, that's O(n·k), and it gets slow fast. The sliding-window trick does it in one pass: keep a running sum, and each time the window moves right, just add the element entering and subtract the element leaving. One add, one subtract, O(1) per step, O(n) total, no matter how wide the window. Drag k and scrub the window across to watch the sum update without ever recomputing.
🎬 Watch the 90-second explainer, then slide the window yourself below ↓
▶ The playground, pick a window size, then slide it across the array
Bars are the array values. The shaded box is the current window of k elements; its running sum is on top. The green underline marks the best window found so far. As the window slides, watch the +entering and −leaving caps.
The sliding window is the streaming pattern of production systems: rate limiters (requests in the last minute), moving averages in monitoring dashboards, TCP flow control, and log-anomaly detection all maintain running aggregates in O(1) per event, exactly the enter-once-leave-once trick you just verified.
The code that's actually running, a running sum, updated in O(1)
Slide k all the way to its largest and watch the two counters. Predict: which one climbs? The brute-force touches are (n−k+1)·kre-summing k elements at every position, so widening the window makes it do more work. The sliding-window touches stay flat at about 2n: every element enters the sum exactly once and leaves exactly once, whatever k is. That flat line is the whole point, when k grows with the array (say k = n/2), brute force becomes O(n²) while sliding stays O(n). Now: can you find a k where the best window sits at the far right edge?
The takeaway
i and i+1 share k−1 elements. Throwing that overlap away and re-summing is the mistake; the trick is to update the sum by the one element that changed on each side.sum always equals the total of the current window. To keep it true after a slide, add the newcomer and subtract the leaver, sum += a[i] − a[i−k]. That's constant work per step, independent of k.k elements per position; when the window is large that's quadratic. Same answer, dramatically less work.