You're in a coding interview.
The problem mentions a contiguous subarray or substring, some constraint, and "longest", "shortest", "maximum", or "minimum".
You suspect it's a sliding window pattern question… but you’re not 100% sure:
This guide is the pillar article for everything sliding window:
k, deques, 2D, and moreIf you internalize this, the sliding window pattern stops being a gimmick and becomes a reliable O(N) window technique you can deploy in almost any interview, especially on sliding window LeetCode problems.
At a high level, the sliding window pattern is a way to process all contiguous subarrays or substrings of a sequence in linear time by reusing work between neighboring windows.
Instead of recomputing from scratch for every candidate range, you:
[left, right] over the dataright (include new elements)left (remove old elements)Think of it as a moving interval:
Index: 0 1 2 3 4 5
Array: [7, 2, 5, 8, 1, 3]
Window 1: [0,2] → [7,2,5]
Window 2: [1,3] → [2,5,8]
Window 3: [2,4] → [5,8,1]Instead of recomputing the sum for each window, we:
Imagine scanning a log file with a moving magnifying glass:
Sliding window is the code version of that magnifying glass.
Sliding window works when:
expand)shrink)Under these conditions, both pointers together move at most N steps each.
That gives you an O(N) pass instead of an O(N²) brute-force search.
Sliding window LeetCode questions test:
It’s also a great discriminator: many candidates know “two pointers”, but far fewer can articulate why the window invariant is correct and debug it under pressure.
At an intuitive level, the sliding window algorithm does three things:
We always track an interval:
0 1 2 3 4 5
a b c a b b
↑ ↑
left right
window = s[left:right+1]The code invariant is simple:
left and right inclusiveright - left + 1 (this is where most off-by-one errors come from)Mentally, every variable-size sliding window follows this cycle:
right and update the window state (sum, counts, etc.)left and undo the stateleft = 0
for right in range(len(arr)):
add(arr[right]) # expand
while not is_valid(): # shrink until invariant restored
remove(arr[left])
left += 1
update_answer(left, right) # window [left, right] is valid hereThe window invariant is the condition you maintain after the shrink loop finishes.
Examples:
The invariant rule is:
After the shrink loop, the window must always be valid.
This is the heart of the sliding window algorithm:
[left, right] is the “best” window ending at right that satisfies your rulesSliding window is powerful because state changes are local:
rightleftTypical window state structures:
The art is choosing the simplest state that lets you test window validity in O(1).
You don’t want to recognize sliding window halfway through a brute-force attempt.
Here’s a checklist and language cues to spot them immediately.
Use sliding window if:
If any of these are false, step back and consider other patterns (two pointers, prefix sums, DP).
Strong sliding window signals:
Examples:
Ask:
Is window size fixed?
k).Is window size flexible?
When in doubt, start with variable-size; fixed-size is just a simpler special case.
If you’re unsure whether to use sliding window:
Consider prefix sum when:
Consider classic two pointers when:
Consider dynamic programming when:
For deeper pattern-recognition pitfalls, read
Common Sliding Window Mistakes.
There are several flavors of the sliding window algorithm. Being explicit about which one you’re using clarifies both code and correctness.
Definition: The window always contains exactly k elements.
Examples:
Key traits:
right reaches k - 1Sketch (sum over window of size k):
window_sum = 0
best = -float("inf")
for right in range(len(nums)):
window_sum += nums[right]
if right >= k - 1: # window reached size k
best = max(best, window_sum)
window_sum -= nums[right - k + 1] # shrink from leftDefinition: Window grows and shrinks based on a validity constraint.
Examples:
Key traits:
Sometimes both ends move in more complex ways:
This is still sliding window as long as:
left or right movesShrink-to-fit:
Grow-to-fit:
Recognizing which one you’re using prevents subtle bugs in the shrink loop.
For some problems, basic counters aren’t enough:
You want to maintain the window’s max/min in O(1) without scanning the entire window each time.
The trick is to use a monotonic deque:
This is a specialized but important variation of the sliding window algorithm.
You’ll see it in harder sliding window LeetCode interview questions.
For 2D problems (submatrices, grids), you often:
Details are in
How to Apply Sliding Window in 2D / Matrix Problems.
For interview performance, you want one mental sliding window template per language, not ad-hoc loops.
Below are canonical variable-size and fixed-size templates in Python, Java, and JavaScript. For more depth and annotations, see
Sliding Window Template Explained.
def sliding_window_var(arr, condition) -> int:
left = 0
result = 0 # or float("inf") for minimum problems
window = {} # dict / Counter / set / scalar depending on problem
for right, value in enumerate(arr):
# 1. Expand: include arr[right] in window state
# update_window_add(window, value)
# 2. Shrink: while window is invalid, move left
while not is_valid(window, condition):
# update_window_remove(window, arr[left])
left += 1
# 3. Update result using current valid window [left, right]
result = max(result, right - left + 1)
return resultThis maps directly to most “longest/shortest with condition” problems:
def sliding_window_fixed(arr, k: int) -> int:
window_sum = 0
best = float("-inf")
for right, value in enumerate(arr):
window_sum += value # element enters
if right >= k - 1: # window hit size k
best = max(best, window_sum) # process current window
window_sum -= arr[right - k + 1] # element leaves
return bestHere, there’s no explicit validity check; the constraint is purely the fixed window size.
int slidingWindowVar(int[] nums) {
int left = 0;
int result = 0;
Map<Integer, Integer> window = new HashMap<>();
for (int right = 0; right < nums.length; right++) {
int val = nums[right];
window.put(val, window.getOrDefault(val, 0) + 1); // expand
while (!isValid(window)) { // shrink until valid
int leftVal = nums[left];
window.put(leftVal, window.get(leftVal) - 1);
if (window.get(leftVal) == 0) {
window.remove(leftVal);
}
left++;
}
result = Math.max(result, right - left + 1); // update
}
return result;
}int slidingWindowFixed(int[] nums, int k) {
int windowSum = 0;
int best = Integer.MIN_VALUE;
for (int right = 0; right < nums.length; right++) {
windowSum += nums[right]; // expand
if (right >= k - 1) {
best = Math.max(best, windowSum); // process window
windowSum -= nums[right - k + 1]; // shrink
}
}
return best;
}function slidingWindowVar(arr) {
let left = 0;
let result = 0;
const window = new Map(); // or Set / object
for (let right = 0; right < arr.length; right++) {
const val = arr[right];
window.set(val, (window.get(val) || 0) + 1); // expand
while (!isValid(window)) { // shrink until valid
const leftVal = arr[left];
window.set(leftVal, window.get(leftVal) - 1);
if (window.get(leftVal) === 0) {
window.delete(leftVal);
}
left++;
}
result = Math.max(result, right - left + 1); // update
}
return result;
}function slidingWindowFixed(arr, k) {
let windowSum = 0;
let best = -Infinity;
for (let right = 0; right < arr.length; right++) {
windowSum += arr[right]; // expand
if (right >= k - 1) {
best = Math.max(best, windowSum); // process window
windowSum -= arr[right - k + 1]; // shrink
}
}
return best;
}Once you can write these templates from memory, solving most sliding window interview questions becomes a matter of:
Let’s walk through three canonical sliding window LeetCode problems, with diagrams and pitfalls.
Problem: Given a string s, return the length of the longest substring without repeating characters.
This is the poster child for variable-size sliding window:
For s = "abcabcbb":
Step left right window action
----- ---- ----- -------- ----------------------------
0 0 0 "a" add 'a', max_len = 1
1 0 1 "ab" add 'b', max_len = 2
2 0 2 "abc" add 'c', max_len = 3
3 0 3 "abca" 'a' repeats → shrink
4 1 3 "bca" after removing left 'a', valid
...def lengthOfLongestSubstring(s: str) -> int:
left = 0
seen = set()
best = 0
for right, ch in enumerate(s):
# shrink until window has no duplicate of ch
while ch in seen:
seen.remove(s[left])
left += 1
# now safe to expand
seen.add(ch)
best = max(best, right - left + 1)
return bestKey points:
if, because you may need to remove multiple characters.seen contains each char in s[left:right+1] at most once.”O(N) time, O(min(N, M)) space where M is alphabet size.Common pitfalls:
seen when shrinkingright - left instead of right - left + 1For more on string-specific nuances, see
Sliding Window: Substrings vs Subarrays — What’s the Difference?.
Problem: Given a binary array nums and an integer k, return the maximum number of consecutive 1s in the array if you can flip at most k zeros.
This is a classic “at most k” sliding window:
Instead of thinking “flip k zeros”, think:
Find the longest window that contains at most k zeros.
Inside that window, flip all zeros to 1 and you get the answer.
function longestOnes(nums, k) {
let left = 0;
let zeros = 0;
let best = 0;
for (let right = 0; right < nums.length; right++) {
if (nums[right] === 0) zeros++; // expand
while (zeros > k) { // shrink until valid
if (nums[left] === 0) zeros--;
left++;
}
best = Math.max(best, right - left + 1);
}
return best;
}Key debugging notes:
zeros ≤ k.Problem: Given strings s and t, return the minimum window substring of s that contains all the characters of t (with multiplicity). If no such substring exists, return empty string.
This is a shrink-to-fit sliding window:
need[c]: how many of character c we still requirehave: how many characters from t are currently satisfiedt”from collections import Counter
def minWindow(s: str, t: str) -> str:
if not s or not t:
return ""
need = Counter(t)
window = Counter()
required = len(need)
formed = 0
left = 0
best_len = float("inf")
best = (0, 0)
for right, ch in enumerate(s):
window[ch] += 1
if ch in need and window[ch] == need[ch]:
formed += 1
# shrink while window is valid
while formed == required:
if right - left + 1 < best_len:
best_len = right - left + 1
best = (left, right)
left_ch = s[left]
window[left_ch] -= 1
if left_ch in need and window[left_ch] < need[left_ch]:
formed -= 1
left += 1
if best_len == float("inf"):
return ""
start, end = best
return s[start : end + 1]Common pitfalls:
formed (incrementing or decrementing at the wrong time)This problem is a great capstone for the sliding window pattern and appears frequently in sliding window interview questions.
Once you’re comfortable with basic sliding window examples, you’ll see richer variations that combine counters, maps, and sometimes extra data structures.
The pattern for “at most k distinct characters” is:
distinct_count > kdef longest_substring_at_most_k_distinct(s: str, k: int) -> int:
left = 0
freq = {}
best = 0
for right, ch in enumerate(s):
freq[ch] = freq.get(ch, 0) + 1
while len(freq) > k:
left_ch = s[left]
freq[left_ch] -= 1
if freq[left_ch] == 0:
del freq[left_ch]
left += 1
best = max(best, right - left + 1)
return bestFor “exactly k distinct”, use:
exactlyK(k) = atMostK(k) - atMostK(k - 1)
This trick appears often in advanced sliding window LeetCode problems like “Subarrays with K Different Integers”.
When the array contains only non-negative numbers:
You can use sliding window because the sum is monotonic:
When the array has negative numbers, monotonicity breaks.
Use prefix sum instead; see
Sliding Window for Negative Numbers — Why It Breaks & What to Do Instead and
Sliding Window vs Prefix Sum.
Occasionally you’ll see problems where:
Example: “Longest subarray where difference between min and max ≤ limit” can be done with sorted structure + window, or with deques on the original array.
Rule of thumb:
For problems like Sliding Window Maximum (LeetCode 239):
Use a monotonic deque:
from collections import deque
def sliding_window_max(nums, k):
dq = deque() # stores indices, values decreasing
result = []
for right, val in enumerate(nums):
# drop smaller elements from back
while dq and nums[dq[-1]] <= val:
dq.pop()
dq.append(right)
# drop elements falling out of window
if dq[0] <= right - k:
dq.popleft()
if right >= k - 1:
result.append(nums[dq[0]]) # front is max
return resultThis pattern generalizes to:
Sometimes you shrink the window by more than one step at a time using extra information:
These show up in performance-optimized variants, but the conceptual pattern is the same:
left in fewer stepsNot all problems use a smooth expand/shrink.
Example: if the window becomes impossible to repair (e.g., encountering a hard barrier character), you may:
left directly to right + 1This is still sliding window, but the shrink step is a full reset.
You’ll see variants of this in some substring and product-based problems.
If you’ve ever had a window that “doesn’t shrink” or a result off by one, you’re not alone.
Use this sliding window debugging checklist when your solution misbehaves and to avoid common sliding window pitfalls.
For deep dives on specific pitfalls, see:
Symptom:
Checklist:
right - left + 1, not right - leftright >= k - 1Symptom:
Checklist:
right (expand)left (shrink)If you break this order, your window invariant becomes hard to reason about.
Symptom:
Checklist:
while (!invariant) or while (invalid).Symptom:
Checklist:
Symptom:
Checklist:
violations or formed integerSymptom:
best before or after the wrong operation, missing optimal windowsChecklist:
If this feels confusing, walk through a simple example by hand with a table of left, right, and window content.
Sliding window is often confused with two pointers and prefix sum. Let’s clarify.
Sliding Window:
[left, right]Two Pointers (classic):
Prefix Sum:
| Pattern | Best When | Typical Keywords | Example Problem |
|---|---|---|---|
| Sliding Window | Contiguous subarray/substring, optimize window size/value, expand/shrink | longest, shortest, at most k, consecutive | Longest substring w/o repeats, max consecutive ones |
| Two Pointers | Sorted input, pair/triplet endpoints, no need for all in-between | pair sum, triplet, container, partition | Two Sum II, 3Sum, Container With Most Water |
| Prefix Sum | Sum equals k, negative numbers allowed, count subarrays | subarray sum, equal to k, range sum queries | Subarray Sum Equals K, longest subarray sum = k |
When in doubt:
For more side-by-side examples, read:
You don’t need to solve every sliding window LeetCode problem. You need the right ones.
Here’s a condensed roadmap; a full list with explanations and variations lives in
Top Sliding Window Problems on LeetCode (Ranked).
Skills:
Skills:
As you solve these, keep your sliding window template side-by-side and consciously map each problem onto it.
Interviewers love to probe not just that you can code the pattern, but why it works. Here are common sliding window interview questions and concise answers.
Define a validity condition and shrink while it’s violated.
Examples:
zeros > klen(freq) > kThe core rule:
Shrink as long as the window is invalid (or can still stay valid while getting smaller, for minimum problems).
Tie validity to a simple state and invariant:
distinct countformed counter for “all requirements met”Your job is to design state so that:
Because each pointer only moves forward:
right increments from 0 to N - 1 onceleft also increments from 0 to N - 1 onceEven though you see a for + while, across the entire algorithm each element is added and removed at most once. That’s why it’s linear.
It depends:
For these, prefer prefix sums; see
Sliding Window for Negative Numbers.
Avoid sliding window when:
For a dedicated breakdown of failure modes and alternatives, see
When NOT to Use Sliding Window and
Sliding Window for Negative Numbers.
Sliding window is one of the highest-leverage patterns in algorithm interviews:
The fastest way to internalize the sliding window pattern is deliberate practice:
LeetCopilot can:
Finally, remember: sliding window is just one cluster in your patterns toolbox.
Use the main LeetCode Patterns hub and the Sliding Window cluster to explore related techniques and keep building your mental library.
Apply this pattern with LeetCopilot's AI-powered hints, notes, and mock interviews. Transform your coding interview preparation today.