Sliding Window | CodeSimulators

THE PROBLEM

A Window Over a Bigger List

You have a long list, and you keep asking a question about a small connected stretch of it — the biggest sum of any 3 numbers in a row, the longest run with no repeated letter. There are thousands of such stretches, and you want the best one.

The obvious way: take each stretch, walk it, and work out its answer from scratch. For "biggest sum of K in a row" over N numbers that is N stretches times K work each — O(N×K). And it is wasteful in a way you can feel: when you slide one step to the right, the new stretch shares almost every number with the old one. You just re-added K numbers when only two of them actually changed.

That repeated work is the whole opportunity. Remove it and O(N×K) collapses to O(N).

THE INSIGHT

Don't Rebuild — Slide

🪟

Keep a running summary, update only the edges

Hold a window over the list — a left edge and a right edge — and keep a small running summary of what is inside it: a sum, a count of letters, whatever the question needs.

When the window moves one step right, you do not recompute. You add the one element that just entered on the right and subtract the one that just left on the left. Two operations per step, no matter how wide the window is. The K numbers in the middle never get touched again.

The invariant — the one promise: everything between left and right is always a valid stretch for the question. You grow the right edge to explore; the moment the rule breaks, you shrink the left edge until the promise holds again. Keep it, and the answer is always sitting in front of you — everything else is just bookkeeping.

SEE IT

Watch the Waste Disappear

Step through both. The Naive run re-adds every number in the window at each stop; the Sliding Window run only touches the two that changed. Watch the operation counter.

INDEX 0

INDEX 1

INDEX 2

INDEX 3

INDEX 4

INDEX 5

Mode

DELTA UPDATING

Active Sum

6

Ops So Far

+3 / −0

Initial window [0,1,2]: add all 3 once: 1 + 2 + 3 = 6

1 / 4

SHAPE ONE

A Fixed-Width Window

Same window, first shape: it never changes size — always exactly K wide. Grow the right edge by one, then immediately shrink the left edge by one to hold the width. Reach for this when the question fixes the size: the max sum of K in a row, or an anagram of a fixed word.

Fixed Trace Demo: Max Sum Subarray of size K = 3

L,R

function maxSubarraySum(arr, k) {

    let left = 0, sum = 0, maxSum = 0;

    for (let right = 0; right < arr.length; right++) {

        sum += arr[right]; // 1️⃣ Expand

        if (right - left + 1 === k) {

            maxSum = Math.max(maxSum, sum); // 2️⃣ Record

            sum -= arr[left]; // 3️⃣ Shrink

            left++; // 4️⃣ Slide

}

}

    return maxSum;

}

Variables Monitor

left:0

right:0

sum:0

maxSum:0

Initialize left pointer to 0, running sum to 0, and maxSum result tracker to 0.

The Loop, Four Moves

1️⃣

ExpandAdd arr[right] to incorporate the entering element.

2️⃣

ConditionCheck if the active window width reaches size K.

3️⃣

Record / EvaluateCompare and update maxSum with the current window sum.

4️⃣

Slide windowSubtract arr[left] from sum, and increment left forward.

🎯 Target Scenario Signals:

Max/Min Subarray SumAnagram matchingFixed-length sequences

fixed_window.js

let left = 0;

let state = initializeState();

let result = initializeResult();

for (let right = 0; right < arr.length; right++) {

// 1️⃣ Expand

add(state, arr[right]);

// 2️⃣ Condition: When window reaches size K

if (right - left + 1 === k) {

// 3️⃣ Record / Evaluate

result = updateResult(result, state);

// 4️⃣ Slide window

remove(state, arr[left]);

left++;

}

SHAPE TWO

A Window That Breathes

Same window, now it changes size. The right edge keeps exploring forward. The moment the stretch breaks the rule — sum over the limit, or a repeated letter — the left edge steps in until the window is valid again. That is the invariant in action, and the answer is the best valid window you ever saw.

Variable Trace Demo: Longest Subarray with Sum ≤ 7

Array: [2, 5, 2, 1, 6]

Limit: 7

L,R

function longestSubarray(arr, limit) {

    let left = 0, sum = 0, maxLen = 0;

    for (let right = 0; right < arr.length; right++) {

        sum += arr[right]; // 1️⃣ Expand

        while (sum > limit) {

            sum -= arr[left]; // 2️⃣ Shrink

            left++; // 3️⃣ Contract

}

        maxLen = Math.max(maxLen, right - left + 1); // 4️⃣ Record

}

    return maxLen;

}

Variables Monitor

left:0

right:0

sum:0

maxLen:0

Initialize left pointer, running sum, and maxLen tracker to 0.

The Loop, Four Moves

1️⃣

ExpandAdd arr[right] to expand the active window.

2️⃣

ShrinkSubtract arr[left] from sum while sum > limit.

3️⃣

ContractIncrement left to shrink the active window frame.

4️⃣

Record / OptimizeRecord the maximum valid length (right - left + 1).

🎯 Target Scenario Signals:

Longest substringMin window containing subSubarray sums <= limit

variable_window.js

let left = 0;

let state = emptyState();

let result = 0;

for (let right = 0; right < arr.length; right++) {

// 1️⃣ Expand

addToState(state, arr[right]);

// 2️⃣ Condition: While invalid

while (!isValid(state)) {

// 3️⃣ Contract

removeFromState(state, arr[left]);

left++;

}

// 4️⃣ Record / Optimize

result = optimize(result, right - left + 1);

}

ANALYSIS

Performance Dashboard

TIME EFFICIENCY

O(N)

LINEAR SPEED

Each element is processed exactly twice (once entering on the right, once leaving on the left), making it radically faster than checking every combination.

THE INTUITION

Explorer

We move the right boundary forward to scan new values.

Monotonicity

For positive numbers, adding items strictly increases the total, establishing a predictable trend.

Repair

When constraints fail, advancing the left boundary is the only way to return to a valid state.

🚫

CRITICAL: When it Fails

Sliding Window fails with negative numbers. If subtracting an item makes the sum bigger, the window loses its clear "direction" and doesn't know how to repair itself.

CHEAT SHEET

Summary Comparison

Window Style	Constraint Condition	Pointers Setup	Time / Space Complexity
Fixed Size	Size is strictly K	right expands, left shifts when size matches K	O(N) / O(1)
Variable Size	Length adjusts dynamically	right expands, left contracts while invalid	O(N) / O(1)

🔎 When to reach for it

📏
A contiguous stretch: the question is about a subarray, substring, or sliding block — never a scattered, non-contiguous pick.
📊
Longest / shortest / best under a rule: longest substring with K distinct letters, shortest subarray reaching a target sum, best average of size K.
⚡
The naive answer re-scans overlapping stretches: O(N×K) or O(N²) work, most of it repeated — exactly the waste a sliding window removes.

PRACTICE

Ready to Practice with Visual Simulations?

Max Sum Subarray of Size KEasy

Longest Substring Without Repeating CharactersMedium

Minimum Size Subarray SumMedium

Minimum Window SubstringHard

"Add from the right, check the rule, and shrink from the left."