Sliding Window: Code Templates in 6 Languages

Coding Patterns - Guide to 30 Core Algorithm Patterns

Sliding Window: Complete Guide with Examples

If you have not read the concept guide yet, start there for the intuition and the complexity analysis. This page gives you the code you can memorize and adapt during an interview. Every template here runs in

O(N)

time with

O(1)

extra space unless the state is explicit.

The core of every sliding window is the same. A right pointer grows the window, a left pointer shrinks it, and a running state makes the window answerable in constant time. What changes between problems is what the state holds and when the result is recorded.

Main Template: Variable Size Window (Minimum Length)

This is the classic sliding window. It expands the window until the condition holds, then shrinks from the left to find the shortest window that still satisfies the condition. This template directly solves Minimum Size Subarray Sum .

function minSubArrayLen(target, nums) {
    let left = 0;
    let windowSum = 0;
    let result = Infinity;

    for (let right = 0; right < nums.length; right++) {
        windowSum += nums[right];

        // While the window is valid, every window is a candidate,
        // so the shortest one is recorded before the left edge moves
        while (windowSum >= target) {
            result = Math.min(result, right - left + 1);
            windowSum -= nums[left];
            left++;
        }
    }

    // No window ever reached the target value
    return result === Infinity ? 0 : result;
}

def min_sub_array_len(target: int, nums: List[int]) -> int:
    left = 0
    window_sum = 0
    result = float("inf")

    for right in range(len(nums)):
        window_sum += nums[right]

        # Valid windows shrink without breaking the sum, so the
        # record must happen before the leftmost element leaves
        while window_sum >= target:
            result = min(result, right - left + 1)
            window_sum -= nums[left]
            left += 1

    return 0 if result == float("inf") else result

public int minSubArrayLen(int target, int[] nums) {
    int left = 0, windowSum = 0, result = Integer.MAX_VALUE;

    for (int right = 0; right < nums.length; right++) {
        windowSum += nums[right];

        // A valid window can shrink and stay valid, so the
        // result is updated on the way down as well
        while (windowSum >= target) {
            result = Math.min(result, right - left + 1);
            windowSum -= nums[left];
            left++;
        }
    }

    return result == Integer.MAX_VALUE ? 0 : result;
}

int minSubArrayLen(int target, vector<int>& nums) {
    int left = 0, windowSum = 0, result = INT_MAX;

    for (int right = 0; right < nums.size(); right++) {
        windowSum += nums[right];

        // Each valid window is a candidate: record it, then
        // shrink, because trailing elements can only stay valid
        while (windowSum >= target) {
            result = min(result, right - left + 1);
            windowSum -= nums[left];
            left++;
        }
    }

    return result == INT_MAX ? 0 : result;
}

func minSubArrayLen(target int, nums []int) int {
    left := 0
    windowSum := 0
    result := math.MaxInt32

    for right := 0; right < len(nums); right++ {
        windowSum += nums[right]

        for windowSum >= target {
            length := right - left + 1
            if length < result {
                result = length
            }
            windowSum -= nums[left]
            left++
        }
    }

    if result == math.MaxInt32 {
        return 0
    }
    return result
}

def min_sub_array_len(target, nums)
  left = 0
  window_sum = 0
  result = Float::INFINITY

  nums.each_with_index do |num, right|
    window_sum += num

    # The window stays valid while it shrinks, so record the
    # candidate before the leftmost element leaves it
    while window_sum >= target
      result = [result, right - left + 1].min
      window_sum -= nums[left]
      left += 1
    end
  end

  result == Float::INFINITY ? 0 : result
end

Templates only help if you can recall them without staring at the screen. Turn these snippets into flashcards for daily mobile review.

Code Breakdown

Key Variables

left: the left boundary of the window. It moves only when the window is valid, and it never moves backward.
right: the right boundary. Moves forward on every iteration of the loop, adding the current element to the window state.
windowSum (or whatever the state is named): holds the running data for the current window. In the shrink case it holds a number, in frequency windows it holds a character table.
result: the best answer found so far. For min-length problems it starts at infinity, and the sentinel survives if no valid window exists.

The Flow

    stateDiagram-v2
    [*] --> Expand: right++, add nums[right]
    Expand --> Check: windowSum >= target?
    Check --> Record: yes
    Record --> Shrink: subtract nums[left], left++
    Shrink --> Check: still valid
    Check --> Expand: no
    Expand --> Done: right = n
    Done --> [*]

Why the record happens before the shrink

The trick in this main template is the ordering. The record happens before the shrink. When the window sum passes the target, every shorter window you can reach by dropping elements from the left is also a valid candidate. The record has to happen before the element leaves, because the moment after you subtract it the window may no longer satisfy the condition, and the candidate would be lost.

The loop is linear because of the same ordering: the while may run several times in one iteration, but each pass through it removes exactly one element, and the left pointer never resets. Across the whole run, left visits each index at most once.

Variations

1. Fixed Size Window

The window always has exactly k elements. Record at every step once the window is full, and from then on each right step evicts one element with a simple subtraction.

Use this for Maximum Average Subarray I .

function maxSumWindow(nums, k) {
    let windowSum = 0;
    let maxSum = 0;

    for (let i = 0; i < nums.length; i++) {
        windowSum += nums[i];

        // The window fills at index k - 1. From then on, each step
        // records a full window and evicts the element that fell out
        if (i >= k - 1) {
            maxSum = Math.max(maxSum, windowSum);
            windowSum -= nums[i - k + 1];
        }
    }

    return maxSum;
}

def max_sum_window(nums: List[int], k: int) -> int:
    window_sum = 0
    max_sum = 0

    for i in range(len(nums)):
        window_sum += nums[i]

        # The window has k elements as soon as i hits k - 1.
        # Record the sum and remove the element leaving the edge
        if i >= k - 1:
            max_sum = max(max_sum, window_sum)
            window_sum -= nums[i - k + 1]

    return max_sum

def max_sum_window(nums, k)
  window_sum = 0
  max_sum = 0

  nums.each_with_index do |num, i|
    window_sum += num

    # The first full window appears at i = k - 1. After that,
    # every step wraps a full window into the answer and evicts
    if i >= k - 1
      max_sum = [max_sum, window_sum].max
      window_sum -= nums[i - k + 1]
    end
  end

  max_sum
end

2. Frequency Map Window

When the condition is about character counts instead of sums, the state becomes a map of characters in the window. The shrink condition is a count check instead of a sum comparison.

Use this for Longest Substring Without Repeating Characters on the problems page .

function longestUnique(s) {
    const counts = new Map();
    let left = 0;
    let maxLen = 0;

    for (let right = 0; right < s.length; right++) {
        const char = s[right];
        counts.set(char, (counts.get(char) || 0) + 1);

        // A duplicate character makes the window invalid. Shrink
        // until only one copy of char remains inside
        while (counts.get(char) > 1) {
            const leftChar = s[left];
            counts.set(leftChar, counts.get(leftChar) - 1);
            left++;
        }

        maxLen = Math.max(maxLen, right - left + 1);
    }

    return maxLen;
}

def longest_unique(s: str) -> int:
    counts = {}
    left = 0
    max_len = 0

    for right, char in enumerate(s):
        counts[char] = counts.get(char, 0) + 1

        # While the character just added is duplicated, drop the
        # leftmost characters until it is still a single copy
        while counts[char] > 1:
            counts[s[left]] -= 1
            left += 1

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

    return max_len

int longestUnique(String s) {
    Map<Character, Integer> counts = new HashMap<>();
    int left = 0, maxLen = 0;

    for (int right = 0; right < s.length(); right++) {
        char c = s.charAt(right);
        counts.put(c, counts.getOrDefault(c, 0) + 1);

        while (counts.get(c) > 1) {
            char leftChar = s.charAt(left);
            counts.put(leftChar, counts.get(leftChar) - 1);
            left++;
        }

        maxLen = Math.max(maxLen, right - left + 1);
    }

    return maxLen;
}

int longestUnique(string s) {
    unordered_map<char, int> counts;
    int left = 0, maxLen = 0;

    for (int right = 0; right < s.size(); right++) {
        counts[s[right]]++;

        // The repeated character shrinks the window until
        // exactly one copy of it is back inside
        while (counts[s[right]] > 1) {
            counts[s[left++]]--;
        }

        maxLen = max(maxLen, right - left + 1);
    }

    return maxLen;
}

func longestUnique(s string) int {
    counts := make(map[byte]int)
    left, maxLen := 0, 0

    for right := 0; right < len(s); right++ {
        counts[s[right]]++

        // When the right edge introduces a duplicate, keep
        // evicting left characters until that copy is back to one
        for counts[s[right]] > 1 {
            counts[s[left]]--
            left++
        }

        if right-left+1 > maxLen {
            maxLen = right - left + 1
        }
    }

    return maxLen
}

def longest_unique(s)
  counts = Hash.new(0)
  left = 0
  max_len = 0

  s.each_char.with_index do |char, right|
    counts[char] += 1

    # A char that repeats forces the left edge forward until
    # the duplicate is out of the window
    while counts[char] > 1
      counts[s[left]] -= 1
      left += 1
    end

    max_len = [max_len, right - left + 1].max
  end

  max_len
end

Note that the fixed-size and variable-size templates share one rule. The result is recorded at the moment the window satisfies its condition, and the state only changes at the edges. Everything else in a sliding window problem is the problem-specific condition.

Each variation above works as a review card in the app. Drill them individually so you do not mix up the record-before-shrink and record-when-full conditions under pressure.

Now head to the practice problems section to apply these templates to real interview questions.

The next step after memorizing a template is applying it cold. Head to the practice problems or review these templates with spaced repetition .