Sliding Window Pattern: Template + 116 LeetCode Problems

What the sliding window pattern is

A sliding window holds one contiguous stretch of the input between two indices, along with a running summary of what is inside it — a sum, a character count, a distinct-element count. Because the summary is updated incrementally as an index moves, advancing the window costs O(1) instead of re-reading it, which is what turns an O(n²) scan of every subarray into one linear pass. The right index always moves forward; the left index moves only while the window violates the constraint, so each element is added once and removed at most once. Two forms cover almost everything: a fixed window slides both ends in lockstep and answers questions about every subarray of length k, while a variable window grows greedily and shrinks from the left until it is legal again, answering questions about the longest or shortest subarray satisfying a condition.

When to use it

• —The answer is a contiguous subarray or substring — not a subsequence, which cannot be described by two indices.
• —You can update the window's summary in O(1) when an element enters or leaves it.
• —The constraint is monotone: if a window is too long or too costly, extending it further cannot fix it.
• —The brute force is two nested loops where the inner one recomputes work the outer one already did.

The sliding window template in Python

The shape, not a solution to any one problem. Adapt the condition and the summary being maintained; the skeleton stays the same across the 116 problems listed below.

def longest_valid_window(nums):
    left = 0
    window = 0          # running summary of nums[left : right + 1]
    best = 0

    for right, value in enumerate(nums):
        window += value                 # extend on the right

        while window_is_illegal(window):
            window -= nums[left]        # shrink on the left until legal again
            left += 1

        best = max(best, right - left + 1)

    return best

Complexity characteristics

Time

O(n)

Auxiliary space

O(1) to O(k)

Each index enters the window once and leaves it at most once, so the two pointers together travel at most 2n steps no matter how long any individual window gets — that is what makes a single pass equivalent to the O(n²) scan over every subarray. The space is whatever the running summary costs: O(1) for a sum or a counter, O(k) for a map of the elements currently inside the window, bounded by the alphabet rather than by the input length.

All 116 sliding window LeetCode problems

Every problem in the library the sliding window pattern applies to, grouped by LeetCode's own difficulty rating. 102 of the 116 carry a complete Python solution with a worked example and complexity analysis; the rest are listed for completeness, with the LeetCode Premium ones marked.

Related patterns

Problems sit in more than one pattern more often than not, and the overlap is where the interesting follow-up questions live.

Sliding Window pattern FAQ

More ways in: all 22 patterns, the curated study lists, or the full problem list.