Fixed-size windows keep a constant width of exactly k elements. The right pointer enters and the left pointer exits in lockstep — each slide subtracts the leftmost element and adds the new right one. Variable-size windows expand freely and only contract when a constraint breaks. The right pointer always moves forward, but the left pointer advances only as needed to restore validity. Contraction in variable windows lives inside a while loop; fixed windows use a straightforward for-loop step.

Check upfront: if k > n, no valid subarray of size k exists, so return a sentinel value (-1, empty, or raise an exception depending on the problem). Variable windows handle this automatically — the window simply cannot reach size k, so the algorithm correctly returns 0 or handles the empty state.

Standard sliding window assumes monotonicity when searching for maximums or minimums, which breaks with negative numbers. For maximum subarray sum, you cannot discard the current sum just because it's negative — you keep it because the next negative element might make it even more negative. The fix: in problems like "Maximum Average Subarray," negative values still work with the prefix-sum approach. But for longest subarray satisfying a constraint, contraction must be based purely on the constraint itself (e.g., character frequency) not on the running sum sign.

Yes — the Minimum Size Subarray Sum problem is a classic case. After expanding right and satisfying the constraint, you enter an inner contraction loop that greedily shrinks the window from the left as long as it stays valid. Each contraction potentially yields a new minimum. This flips the tracking metric compared to Maximum Window problems where you record the largest valid window. The direction of expansion and contraction stays the same; only what you're tracking changes.

The trick is to compute countSubarraysWithAtMostKDistinct(k) - countSubarraysWithAtMostKDistinct(k-1). Write a helper that returns the count of subarrays with at most K distinct integers using a variable-size window. Slide the window: add the right element, update frequency counts. When the distinct count exceeds K, contract from the left until it's valid again. The total count at each step equals the window length (number of valid subarrays ending at right). This subtraction trick works for any "exactly K" variant of sliding window problems.

You can only sell after a cooldown of one day. This isn't a classic two-pointer problem but a DP problem where the "window" is actually a state machine with three states: holding a stock, not holding, or in cooldown. However, if you reframe finding maximum profit with a constraint on consecutive transactions, a deque-based sliding window can track the best recent buy opportunity. The more common solution uses O(1) space DP with the states: sell[i] = max(sell[i-1], hold[i-1] + price[i]) and hold[i] = max(hold[i-1], cooldown[i-1] - price[i]).

This is a direct application of the "longest subarray with at most K distinct elements" pattern where K=2. Use a hash map to track the count of each fruit type in the current window. Expand right by adding fruits; when a third type would enter, contract from the left by removing fruits until only two types remain. Track the maximum window size. The time complexity is O(n) because each fruit is added and removed at most once.

Off-by-one errors are the most common sliding window bug. With [left, right] inclusive on both ends, the window length is right - left + 1. With [left, right) exclusive on right, length is right - left. Mixing these conventions within the same function — for example, using inclusive when checking validity but exclusive when calculating length — produces wrong answers. Pick one convention and apply it consistently across all boundary comparisons, initial window setup, and contraction loop conditions.

When a duplicate character enters the window, you must contract from the left until that character is no longer present. The standard approach stores the most recent index of each character. When character c at index right is seen again, if char_index[c] >= left, you update left = char_index[c] + 1. This jump is safe because all elements before the previous occurrence are now irrelevant — the window must start after the last seen index of c to remain valid.

Yes. A monotonic deque keeps elements in sorted order within the window, enabling O(1) retrieval of min or max. In the Sliding Window Maximum problem, the deque stores indices in decreasing order of their values — the front is always the maximum. As the window slides, you remove indices outside the window from the front and remove indices of values smaller than the incoming element from the back. Each element is processed at most twice (once entering, once leaving), giving O(n) total time.

This is really about the "Maximum Average Subarray" pattern. If K is fixed per test case, the sliding window code works as-is. If K must be found (e.g., find the subarray length that gives maximum average with sum >= threshold), you combine sliding window with binary search on K, or you use a variable-size window that tracks the sum-to-length ratio. Sliding window itself does not require K to be known at compile time — you pass it as a parameter at runtime.

Two-pointer uses two pointers moving independently toward each other (common in sorted array pair problems). Sliding window is a specialized two-pointer variant where both pointers move in the same direction with an overlapping active region — the window. Use sliding window when you need to track a property of the current contiguous segment (max sum, longest substring, valid anagram). Use two-pointer when the pointers define a search range that shrinks from both ends (binary-search-like, pair finding, partition). Sliding window always gives O(n) total pointer movement; general two-pointer can be O(n) or O(n²) depending on implementation.