Sliding Window Pattern: LeetCode Guide & Problems

Efficiently process subarrays or substrings of a fixed or variable size.

✓ Pattern Solutions & Guides Practice Mode Enabled

27 Problem 0 Easy 25 Medium 2 Hard

Overview

The sliding window technique maintains a window of elements that satisfies a condition, expanding or shrinking it as you traverse the data. It converts brute-force O(n²) solutions into O(n) by avoiding redundant re-computation.

When to Use

Finding max/min subarray of size k
Longest substring without repeating characters
Minimum window containing all characters
Fixed-size window statistics

Common Mistakes

Forgetting to shrink the window when the constraint is violated
Off-by-one errors on window boundaries
Not resetting window state when shrinking

Complexity

Time

O(n) — each element enters and exits the window at most once

Space

O(k) where k is the window size or alphabet size

public int slidingWindow(int[] arr, int k) {
    int left = 0, result = 0;
    Map<Integer, Integer> windowState = new HashMap<>();

    for (int right = 0; right < arr.length; right++) {
        // Expand window: add arr[right]

        // Shrink window when constraint violated
        while (false) { // replace with invalid condition
            // Remove arr[left] from state
            left++;
        }

        // Update result
        result = Math.max(result, right - left + 1);
    }
    return result;
}

Problems (27)

Hide completed

Problem	Difficulty	Companies	Freq	Solution
Longest Substring Without Repeating Characters #String #Hash Map #Sliding Window	Medium	AmazonGoogle +2	High	Solution
Minimum Window Substring #String #Hash Map #Sliding Window	Hard	FacebookAmazon +2	High	Solution
Sliding Window Maximum #Array #Deque #Sliding Window	Hard	AmazonGoogle +1	Medium	Solution
Longest Repeating Character Replacement #String #Sliding Window	Medium	GoogleAmazon	Medium	Solution
Permutation in String #String #Hash Map #Sliding Window	Medium	MicrosoftAmazon	Medium	Solution
Find All Anagrams in a String #String #Hash Map #Sliding Window	Medium	FacebookUber	Medium	Solution
Max Consecutive Ones III #Array #Sliding Window #Binary	Medium	GoogleAmazon	Medium	Solution
Subarray Product Less Than K #Array #Sliding Window	Medium	Amazon	Low	Solution
Minimum Size Subarray Sum #Array #Sliding Window #Binary Search	Medium	AmazonFacebook	Medium	Solution
Fruit Into Baskets #Array #Sliding Window #Hash Map	Medium	Google	Low	Solution
Minimum Operations to Reduce X to Zero #Array #Hash Table #Binary Search	Medium	AmazonGoogle	Medium	Solution
Longest Subarray of 1's After Deleting One Element #Array #Dynamic Programming #Sliding Window	Medium	AmazonGoogle +1	Medium	Solution
Count Number of Nice Subarrays #Array #Hash Table #Math	Medium	Amazon	Medium	Solution
Frequency of the Most Frequent Element #Array #Binary Search #Greedy	Medium	AmazonGoogle	Medium	Solution
Maximum Number of Vowels in a Substring of Given Length #String #Sliding Window	Medium	GoogleBloomberg +1	Medium	Solution
Consecutive 1's not allowed #String	Medium	AmazonGoogle +1	High	Solution
Minimum changes to make alternating binary string #String	Medium	AmazonGoogle +1	High	Solution
String to Integer #String	Medium	AmazonGoogle +1	High	Solution
Length of Last Word #String	Medium	AmazonGoogle +1	High	Solution
Run Length Encoding #String	Medium	AmazonGoogle +1	High	Solution
Longest Common Prefix #String	Medium	AmazonGoogle +1	High	Solution
Largest Alphabetic Character present in the String #String	Medium	AmazonGoogle +1	High	Solution
Roman to Integer #String	Medium	AmazonGoogle +1	High	Solution
Integer to Roman #String	Medium	AmazonGoogle +1	High	Solution
First Unique Character in a String #String	Medium	AmazonGoogle +1	High	Solution
Valid Tic Toe State #String	Medium	AmazonGoogle +1	High	Solution
Find the Index of the First Occurrence in a String #String	Medium	AmazonGoogle +1	High	Solution

🧠

Mastering the Sliding Window Pattern for Coding Interviews

1. Mental Model & Visual Intuition

The Sliding Window pattern is designed to eliminate redundant work and reduce search spaces. Rather than evaluating every possible state using a naive brute-force approach, this pattern relies on an invariant that allows you to safely discard subproblems that cannot lead to an optimal answer. When encountering an interview question, look for core triggers such as monotonicity, contiguous constraints, optimal substructure, or overlapping subproblems.

2. Algorithmic Invariants & Step-by-Step Execution

To implement this pattern flawlessly under interview conditions, structure your thought process into three discrete steps:

State Initialization: Define your boundaries, pointers, or memoization tables clearly before entering loops.
State Transition: Update tracking variables incrementally as new elements enter or leave your active evaluation window.
Feasibility Check: When constraints are violated, systematically shrink or adjust your state until the valid invariant is restored.

3. Time and Space Complexity Trade-Offs

In top-tier technical interviews at Google, Meta, and Amazon, arriving at a working solution is only half the battle. You must explicitly justify why your approach achieves optimal Big-O bounds. For Sliding Window, the target time complexity is typically O(n) — each element enters and exits the window at most once while maintaining an auxiliary space complexity of O(k) where k is the window size or alphabet size. Always discuss whether an in-place modification or two-pass traversal can save memory.

4. Common Interview Edge Cases to Test

Before informing your interviewer that you have completed coding, trace your logic against these standard high-failure test cases:

Empty inputs, single-element collections, or all-identical values.
Inputs with negative numbers, duplicates, or extreme values that could cause integer overflow.
Odd versus even length inputs when dealing with pointer convergence or tree midpoints.

The sliding window technique turns O(n²) brute-force substring problems into clean O(n) solutions. H…