Sliding Window: Practice Problems with Solutions

Coding Patterns - Guide to 30 Core Algorithm Patterns

Sliding Window: Complete Guide with Examples

Welcome to the practice problems for the sliding window pattern. If you need a refresher on the code, the code templates page has the fixed-size and variable-size patterns in 6 languages. Each problem below includes the reason the pattern applies, a hint that stops short of the answer, and the full solution.

Recommended Study Order

The problems are ordered by difficulty and by the size of the conceptual jump between them.

Maximum Average Subarray I teaches the fixed-size window with a plain running sum. No other mechanics to juggle.
Max Consecutive Ones III introduces the left pointer and the shrink loop with a simple validity rule. At most k zeros are allowed inside the window.
Minimum Size Subarray Sum is the variable-size core: record the window, then shrink it. This is the most common interview variation.
Permutation in String replaces the sum with a frequency comparison, which turns the window state into character counts.
Longest Substring Without Repeating Characters adds the at-most-one constraint on character counts, the most common way to keep a window valid.
Minimum Window Substring is the Hard capstone. It combines two frequency maps and a formed counter, and if you can write it from memory you know the pattern deeply.

The order above builds intuition progressively. The app schedules your reviews so you do not forget the Easy pattern while grinding the Hard one. Set up your review schedule .

Easy Problems

1. Maximum Average Subarray I

LeetCode 643 | Difficulty: Easy

Brief: Find the contiguous subarray of size k with the maximum average value.

Why this pattern: The window has a fixed size of exactly k elements. Once the first window is built, each slide adds one element on the right and removes one on the left, and the running sum updates in

O(1)

time.

Key Insight: The divisor never changes, so track the maximum sum and divide once at the end.

Visual:

    graph TD
    I["nums = 1 12 -5 -6 50 3, k = 4"] --> W1["window 1: 1+12-5-6 = 2"]
    W1 --> W2["slide: 2 - 1 + 50 = 51"]
    W2 --> W3["slide: 51 - 12 + 3 = 42"]
    W3 --> M["max sum 51, average = 51 / 4 = 12.75"]
    style M fill:#d8f5d8,stroke:#333

Code:

var findMaxAverage = function(nums, k) {
    let sum = 0;
    for (let i = 0; i < k; i++) {
        sum += nums[i];
    }

    let maxSum = sum;
    for (let i = k; i < nums.length; i++) {
        // Remove the element leaving the window, add the new one
        sum = sum - nums[i - k] + nums[i];
        maxSum = Math.max(maxSum, sum);
    }

    return maxSum / k;
};

class Solution:
    def findMaxAverage(self, nums: List[int], k: int) -> float:
        curr_sum = sum(nums[:k])
        max_sum = curr_sum

        for i in range(k, len(nums)):
            curr_sum = curr_sum - nums[i - k] + nums[i]
            max_sum = max(max_sum, curr_sum)

        return max_sum / k

The fixed window never needs a while loop because the window size is a constant of the problem. The only bookkeeping is subtracting the element that just left and adding the element that just entered.

Medium Problems

2. Max Consecutive Ones III

LeetCode 1004 | Difficulty: Medium

Brief: Find the longest subarray that contains at most k zeros, so that flipping those zeros produces all ones.

Why this pattern: The window is variable and the validity rule is a count. The number of zeros inside the window must stay at or below k, which gives the shrink condition its simple shape.

Key Insight: Only the zeros matter. When the window holds k+1 zeros, shrink from the left until a zero leaves the window, restoring validity.

Visual:

    graph LR
    A["nums = 1 0 1 0 1, k = 1"] --> B["right = 3: zeros = 2 > 1"]
    B --> C["shrink: drop one zero, zeros = 1"]
    C --> D["window 1 0 1, length 3"]
    D --> E["answer 3"]
    style E fill:#d8f5d8,stroke:#333

Code:

function longestOnes(nums, k) {
    let left = 0;
    let zeros = 0;
    let maxLen = 0;

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

        // A window with k+1 zeros is invalid. Shrink from the
        // left until a zero has left the window
        while (zeros > k) {
            if (nums[left] === 0) zeros--;
            left++;
        }

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

    return maxLen;
}

class Solution:
    def longestOnes(self, nums: List[int], k: int) -> int:
        left = 0
        zeros = 0
        max_len = 0

        for right in range(len(nums)):
            if nums[right] == 0:
                zeros += 1

            while zeros > k:
                if nums[left] == 0:
                    zeros -= 1
                left += 1

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

        return max_len

class Solution {
    public int longestOnes(int[] nums, int k) {
        int left = 0, zeros = 0, maxLen = 0;

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

            while (zeros > k) {
                if (nums[left] == 0) zeros--;
                left++;
            }

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

        return maxLen;
    }
}

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int left = 0, zeros = 0, maxLen = 0;

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

            while (zeros > k) {
                if (nums[left] == 0) zeros--;
                left++;
            }

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

        return maxLen;
    }
};

func longestOnes(nums []int, k int) int {
    left, zeros, maxLen := 0, 0, 0

    for right := 0; right < len(nums); right++ {
        if nums[right] == 0 {
            zeros++
        }

        for zeros > k {
            if nums[left] == 0 {
                zeros--
            }
            left++
        }

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

    return maxLen
}

The total work stays linear because left passes each position at most once. When the window is invalid, no re-scanning happens, the left edge just walks forward until a zero leaves, and those positions can never be part of a valid window again.

3. Minimum Size Subarray Sum

LeetCode 209 | Difficulty: Medium

Brief: Find the minimal length of a contiguous subarray whose sum is at least the target.

Why this pattern: Adding elements to the window can only raise the sum, and removing them can only lower it. That monotonic property is exactly what a shrink loop needs, so this problem is the canonical one for the pattern.

Key Insight: Record the window length before every shrink. Once the sum meets the target, every smaller window you reach by dropping elements is also a candidate.

Visual:

    graph TD
    A["right=3: 2 3 1 2, sum 8, len 4"] --> B["shrink: 3 1 2, sum 6"]
    B --> C["right=4: 3 1 2 4, sum 10, len 4"]
    C --> D["shrink: 1 2 4, sum 7, len 3"]
    D --> E["right=5: 2 4 3, sum 9"]
    E --> F["shrink: 4 3, sum 7, len 2"]
    F --> G["answer 2"]
    style G fill:#d8f5d8,stroke:#333

Code:

var minSubArrayLen = function(target, nums) {
    let left = 0;
    let sum = 0;
    let minLen = Infinity;

    for (let right = 0; right < nums.length; right++) {
        sum += nums[right];
        while (sum >= target) {
            // Record before shrinking: the next window may be
            // shorter, but this one is still valid right now
            minLen = Math.min(minLen, right - left + 1);
            sum -= nums[left];
            left++;
        }
    }

    return minLen === Infinity ? 0 : minLen;
};

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        left = 0
        curr_sum = 0
        min_len = float("inf")

        for right in range(len(nums)):
            curr_sum += nums[right]
            while curr_sum >= target:
                min_len = min(min_len, right - left + 1)
                curr_sum -= nums[left]
                left += 1

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

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;
        int sum = 0;
        int minLen = Integer.MAX_VALUE;

        for (int right = 0; right < nums.length; right++) {
            sum += nums[right];
            while (sum >= target) {
                minLen = Math.min(minLen, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }

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

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int left = 0;
        int sum = 0;
        int min_len = INT_MAX;

        for (int right = 0; right < nums.size(); right++) {
            sum += nums[right];
            while (sum >= target) {
                min_len = min(min_len, right - left + 1);
                sum -= nums[left];
                left++;
            }
        }

        return min_len == INT_MAX ? 0 : min_len;
    }
};

func minSubarrayLength(target int, nums []int) int {
    left := 0
    sum := 0
    minLen := math.MaxInt32

    for right := 0; right < len(nums); right++ {
        sum += nums[right]
        for sum >= target {
            length := right - left + 1
            if length < minLen {
                minLen = length
            }
            sum -= nums[left]
            left++
        }
    }

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

def min_subarray_length(target, nums)
  left = 0
  sum = 0
  min_len = Float::INFINITY

  nums.each_with_index do |num, right|
    sum += num
    while sum >= target
      min_len = [min_len, right - left + 1].min
      sum -= nums[left]
      left += 1
    end
  end

  min_len == Float::INFINITY ? 0 : min_len
end

The one detail to keep straight is that the answer is recorded before the shrink, never after. This is the number one place learners drop the smallest window. The solution assumes the array has no negatives, because the sum must be monotonic for the shrink to be safe. With negatives in the input, switch to a prefix-sum or Kadane-style approach instead.

4. Permutation in String

LeetCode 567 | Difficulty: Medium

Brief: Return true if s2 contains a substring that is a permutation of s1.

Why this pattern: A permutation of s1 is exactly any window of length len(s1) with the same character counts. Fixed window size plus a frequency state is all the problem turns into.

Key Insight: Keep two 26-element tables, one for s1 and one for the window. Slide the window and compare tables. A match at any position means the permutation exists.

Visual:

    graph LR
    A["s1 = ab, s2 = eidbaooo"] --> B["window: ei"]
    B --> C["id"]
    C --> D["db"]
    D --> E["ba: counts match"]
    style E fill:#d8f5d8,stroke:#333

Code:

function checkInclusion(s1, s2) {
    if (s1.length > s2.length) return false;

    const target = new Array(26).fill(0);
    const window = new Array(26).fill(0);

    for (let i = 0; i < s1.length; i++) {
        target[s1.charCodeAt(i) - 97]++;
        window[s2.charCodeAt(i) - 97]++;
    }

    for (let i = s1.length; i < s2.length; i++) {
        if (window.every((count, j) => count === target[j])) return true;
        // Slide: add the entering character, remove the leaving one
        window[s2.charCodeAt(i) - 97]++;
        window[s2.charCodeAt(i - s1.length) - 97]--;
    }

    return window.every((count, j) => count === target[j]);
}

class Solution:
    def checkInclusion(self, s1: str, s2: str) -> bool:
        if len(s1) > len(s2):
            return False

        target = [0] * 26
        window = [0] * 26

        for i in range(len(s1)):
            target[ord(s1[i]) - ord("a")] += 1
            window[ord(s2[i]) - ord("a")] += 1

        for i in range(len(s1), len(s2)):
            if window == target:
                return True
            window[ord(s2[i]) - ord("a")] += 1
            window[ord(s2[i - len(s1)]) - ord("a")] -= 1

        return window == target

class Solution {
    public boolean checkInclusion(String s1, String s2) {
        if (s1.length() > s2.length()) return false;

        int[] target = new int[26];
        int[] window = new int[26];

        for (int i = 0; i < s1.length(); i++) {
            target[s1.charAt(i) - 'a']++;
            window[s2.charAt(i) - 'a']++;
        }

        for (int i = s1.length(); i < s2.length(); i++) {
            if (Arrays.equals(target, window)) return true;
            window[s2.charAt(i) - 'a']++;
            window[s2.charAt(i - s1.length()) - 'a']--;
        }

        return Arrays.equals(target, window);
    }
}

class Solution {
public:
    bool checkInclusion(string s1, string s2) {
        if (s1.size() > s2.size()) return false;

        vector<int> target(26, 0), window(26, 0);

        for (int i = 0; i < s1.size(); i++) {
            target[s1[i] - 'a']++;
            window[s2[i] - 'a']++;
        }

        for (int i = s1.size(); i < s2.size(); i++) {
            if (target == window) return true;
            window[s2[i] - 'a']++;
            window[s2[i - s1.size()] - 'a']--;
        }

        return target == window;
    }
};

func checkInclusion(s1 string, s2 string) bool {
    if len(s1) > len(s2) {
        return false
    }

    var target, window [26]int
    for i := 0; i < len(s1); i++ {
        target[s1[i]-'a']++
        window[s2[i]-'a']++
    }

    for i := len(s1); i < len(s2); i++ {
        if target == window {
            return true
        }
        window[s2[i]-'a']++
        window[s2[i-len(s1)]-'a']--
    }

    return target == window
}

Because the alphabet is small and fixed, an integer array of size 26 beats a hash map in both time and space. This is the same idea as the frequency map template, with the window size pinned so no shrink is ever needed.

5. Longest Substring Without Repeating Characters

LeetCode 3 | Difficulty: Medium

Brief: Find the length of the longest substring without repeating characters.

Why this pattern: The window is variable and the validity rule targets character counts. When a character repeats, the window is invalid and the left edge must move past the earlier copy.

Key Insight: Instead of shrinking one character at a time, the map stores the last index of each character, so the left edge jumps straight past the repeated character.

Visual:

    graph LR
    A["abcabcbb"] --> B["right=3: 'a' seen at 0, left -> 1"]
    B --> C["window bca, length 3"]
    C --> D["later: 'b' seen, left -> 5"]
    D --> E["answer 3"]
    style E fill:#d8f5d8,stroke:#333

Code:

var lengthOfLongestSubstring = function(s) {
    let left = 0;
    let maxLen = 0;
    const lastSeen = new Map();

    for (let right = 0; right < s.length; right++) {
        // A repeated character moves the left edge past its
        // previous occurrence, without rescanning the window
        if (lastSeen.has(s[right])) {
            left = Math.max(left, lastSeen.get(s[right]) + 1);
        }
        lastSeen.set(s[right], right);
        maxLen = Math.max(maxLen, right - left + 1);
    }

    return maxLen;
};

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        last_seen = {}
        left = 0
        max_len = 0

        for right, char in enumerate(s):
            if char in last_seen:
                left = max(left, last_seen[char] + 1)
            last_seen[char] = right
            max_len = max(max_len, right - left + 1)

        return max_len

class Solution {
    public int lengthOfLongestSubstring(String s) {
        Map<Character, Integer> lastSeen = new HashMap<>();
        int left = 0, maxLen = 0;

        for (int right = 0; right < s.length(); right++) {
            char c = s.charAt(right);
            if (lastSeen.containsKey(c)) {
                left = Math.max(left, lastSeen.get(c) + 1);
            }
            lastSeen.put(c, right);
            maxLen = Math.max(maxLen, right - left + 1);
        }

        return maxLen;
    }
}

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        unordered_map<char, int> last_seen;
        int left = 0, max_len = 0;

        for (int right = 0; right < s.length(); right++) {
            if (last_seen.count(s[right])) {
                left = max(left, last_seen[s[right]] + 1);
            }
            last_seen[s[right]] = right;
            max_len = max(max_len, right - left + 1);
        }

        return max_len;
    }
};

def length_of_longest_substring(s)
  last_seen = {}
  left = 0
  max_len = 0

  s.each_char.with_index do |char, right|
    if last_seen.key?(char)
      left = [left, last_seen[char] + 1].max
    end
    last_seen[char] = right
    max_len = [max_len, right - left + 1].max
  end

  max_len
end

The map jumps the left edge straight past the previous occurrence of a character, which is faster than the shrink-one-by-one version from the template. The code stays linear, so this is the version you should aim to write from memory.

Hard Problems

6. Minimum Window Substring

LeetCode 76 | Difficulty: Hard

Brief: Find the minimum substring of s that contains every character of t, including duplicate counts.

Hint: Two maps, one for the target and one for the window, plus a formed counter that says how many target characters the window already satisfies in the right quantities. The window is valid the moment formed reaches the size of the target map.

Why this pattern: This is the hardest sliding window problem. The window must contain all characters of t with correct counts and stay minimal. It exercises the full variable-size window with an external frequency state.

Key Insight: Track a formed counter, the count of characters in t that the window currently satisfies. When formed equals the number of distinct characters in t, the window is valid and shrinking begins.

Visual:

    graph LR
    S["s = ADOBECODEBANC, t = ABC"] --> W1["first complete: ADOBEC, len 6"]
    W1 --> W2["shrink + expand: BECODEBA, len 8"]
    W2 --> W3["final: BANC, len 4"]
    style W3 fill:#d8f5d8,stroke:#333

Code:

var minWindow = function(s, t) {
    if (t.length > s.length) return "";

    const target = new Map();
    for (let char of t) {
        target.set(char, (target.get(char) || 0) + 1);
    }

    const window = new Map();
    let left = 0, formed = 0, required = target.size;
    let minLen = Infinity, start = 0;

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

        // Entering a character that reaches its required count
        // marks the window as more complete
        if (target.has(s[right]) && window.get(s[right]) === target.get(s[right])) {
            formed++;
        }

        while (left <= right && formed === required) {
            if (right - left + 1 < minLen) {
                minLen = right - left + 1;
                start = left;
            }

            // Removing a character that drops below its required
            // count makes the window incomplete again
            const leftChar = s[left];
            window.set(leftChar, window.get(leftChar) - 1);
            if (target.has(leftChar) && window.get(leftChar) < target.get(leftChar)) {
                formed--;
            }
            left++;
        }
    }

    return minLen === Infinity ? "" : s.substring(start, start + minLen);
};

class Solution:
    def minWindow(self, s: str, t: str) -> str:
        if not s or not t:
            return ""

        target = Counter(t)
        required = len(target)
        window = {}
        formed = 0
        left = 0
        min_len = float("inf")
        start = 0

        for right, char in enumerate(s):
            window[char] = window.get(char, 0) + 1
            if char in target and window[char] == target[char]:
                formed += 1

            while left <= right and formed == required:
                if right - left + 1 < min_len:
                    min_len = right - left + 1
                    start = left

                left_char = s[left]
                window[left_char] -= 1
                if left_char in target and window[left_char] < target[left_char]:
                    formed -= 1
                left += 1

        return "" if min_len == float("inf") else s[start : start + min_len]

class Solution {
    public String minWindow(String s, String t) {
        if (s.length() < t.length()) return "";

        Map<Character, Integer> target = new HashMap<>();
        for (char c : t.toCharArray()) target.put(c, target.getOrDefault(c, 0) + 1);

        Map<Character, Integer> window = new HashMap<>();
        int left = 0, formed = 0, required = target.size();
        int minLen = Integer.MAX_VALUE, start = 0;

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

            if (target.containsKey(c) && window.get(c).intValue() == target.get(c).intValue()) {
                formed++;
            }

            while (left <= right && formed == required) {
                if (right - left + 1 < minLen) {
                    minLen = right - left + 1;
                    start = left;
                }

                char leftChar = s.charAt(left);
                window.put(leftChar, window.get(leftChar) - 1);
                if (target.containsKey(leftChar) && window.get(leftChar) < target.get(leftChar)) {
                    formed--;
                }
                left++;
            }
        }

        return minLen == Integer.MAX_VALUE ? "" : s.substring(start, start + minLen);
    }
}

class Solution {
public:
    string minWindow(string s, string t) {
        if (s.length() < t.length()) return "";

        unordered_map<char, int> target;
        for (char c : t) target[c]++;

        unordered_map<char, int> window;
        int left = 0, formed = 0, required = target.size();
        int min_len = INT_MAX, start = 0;

        for (int right = 0; right < s.length(); right++) {
            char c = s[right];
            window[c]++;

            if (target.count(c) && window[c] == target[c]) {
                formed++;
            }

            while (left <= right && formed == required) {
                if (right - left + 1 < min_len) {
                    min_len = right - left + 1;
                    start = left;
                }

                char left_char = s[left];
                window[left_char]--;
                if (target.count(left_char) && window[left_char] < target[left_char]) {
                    formed--;
                }
                left++;
            }
        }

        return min_len == INT_MAX ? "" : s.substr(start, min_len);
    }
};

func minWindow(s string, t string) string {
    if len(s) < len(t) {
        return ""
    }

    target := make(map[byte]int)
    for i := 0; i < len(t); i++ {
        target[t[i]]++
    }

    window := make(map[byte]int)
    left, formed, required := 0, 0, len(target)
    minLen, start := math.MaxInt32, 0

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

        if count, ok := target[c]; ok && window[c] == count {
            formed++
        }

        for left <= right && formed == required {
            if right-left+1 < minLen {
                minLen = right - left + 1
                start = left
            }

            leftChar := s[left]
            window[leftChar]--
            if count, ok := target[leftChar]; ok && window[leftChar] < count {
                formed--
            }
            left++
        }
    }

    if minLen == math.MaxInt32 {
        return ""
    }
    return s[start : start+minLen]
}

def min_window(s, t)
  return "" if s.length < t.length

  target = Hash.new(0)
  t.each_char { |c| target[c] += 1 }
  required = target.size

  window = Hash.new(0)
  left = 0
  formed = 0
  min_len = Float::INFINITY
  start = 0

  s.each_char.with_index do |char, right|
    window[char] += 1
    if target.key?(char) && window[char] == target[char]
      formed += 1
    end

    while left <= right && formed == required
      if right - left + 1 < min_len
        min_len = right - left + 1
        start = left
      end

      left_char = s[left]
      window[left_char] -= 1
      if target.key?(left_char) && window[left_char] < target[left_char]
        formed -= 1
      end
      left += 1
    end
  end

  min_len == Float::INFINITY ? "" : s[start, min_len]
end

This problem is the whole pattern in one. It has a map for the target, a map for the window, a counter that says when the window is valid, and a shrink loop that runs only while the window stays valid. Compare the window map here with the frequency map template and you can see how the state grows into the counter logic.

Hard problems are where patterns separate candidates who pass from candidates who get offers. Track your misses and review them on a spaced schedule so you do not repeat them in the real interview.

Once Minimum Window Substring is memorized, the sliding window pattern is fully covered. From fixed-size running sums to two-map counters, the mechanics stay the same: expand right, shrink left, and record only valid windows. Nothing else changes regardless of the problem’s exact wording.

Done with these problems? The app has more, plus a review system that brings problems back right before you would forget them. Continue your prep .