What is the pricing and subscription model for Hi👋SpeedAlgo?

The entire core curriculum of 13 patterns and 225 practice problems is 100% free to access with no credit card required. New accounts get 40 free coins once, the daily claim adds +20 coins once a day, and inviting a friend earns you +25 coins when they complete their first practice step. These are the only ways to earn coins. Each AI coach question costs 1-5 coins, priced by the server according to its size. AI coaching is free with your own Google Gemini, OpenAI or OpenRouter API key (BYOK). Coins also unlock extras for 24 hours: a Recall hint level (1 coin), a Solve solution reveal (2), a LeetCode problem card's solutions (1) and a pattern's extra canonical problems (1). Nothing on the site is sold for money: coins can only be earned, never bought.

What is the refund and cancellation policy?

Hi👋SpeedAlgo sells nothing for money: there are no subscriptions, renewals or charges, so there is nothing to cancel or refund. Nothing on the site is sold for money: coins can only be earned, never bought.

Who creates and maintains the curriculum?

Hi👋SpeedAlgo is developed and maintained by Hi👋WebEnterprise (https://hiwebenterprise.com), an engineering organization focused on developer education, deliberate practice methodologies, and cognitive ergonomics for technical interviews.

How does Hi👋SpeedAlgo prepare candidates for senior and staff SWE interviews?

Rather than rote LeetCode grinding, Hi👋SpeedAlgo uses deliberate practice for each pattern: learn the loop invariant, Big-O proof and edge cases from a side-by-side template and a step-by-step debugger, rebuild the template from memory, then solve a new problem on your own against a graded test suite.

Theory Context•Two Pointers & Sliding Window

Builds on Longest Window, which you haven’t finished yet.

P1MediumBuilt on Longest Window~4 min speedrun

Variable-Size Sliding Window (Minimum Window)

Built on

Longest WindowShrink the window while it is still valid and record its length each time, instead of shrinking only when it becomes invalid.

The problem

Minimum Size Subarray Sum (LC 209)(opens leetcode.com)

nums is an array of positive integers, and target is a positive integer. Among all contiguous subarrays whose sum reaches at least target, find the shortest one and return its length — or 0 if no subarray sums that high.

Example 1

Input:target = 7, nums = [2,3,1,2,4,3]

Output:2

The subarray [4,3] sums to 7, meeting the target with the fewest elements possible.

Shortest Window

left -> right -> (Expand to Validate, Shrink to Minimize)

Spot it when: You want the shortest contiguous subarray or substring that meets a condition, where adding elements only makes the condition easier to meet.

Shortest Window

Python

1	from typing import Callable, List, Tuple
2
3
4	def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
5	"""Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
6	Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
7	Precondition: every longer window that holds a valid window is valid too.
8	add(i) and remove(i) update the window's state for index i.
9	Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
10	T = the cost of one add, remove or is_valid call.
11	Time: O(N * T) \| Space: O(1) besides the window's state
12	"""
13	if is_valid():
14	return (0, 0) # Nothing needs to change: the empty window is already valid
15
16	left = 0
17	min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
18
19	for right in range(n):
20	# 1. Expand Right Frontier:
21	# Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
22	add(right)
23
24	# 2. While Valid, Record And Shrink:
25	# A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
26	while is_valid():
27	if right - left + 1 < min_len:
28	min_len, best_left = right - left + 1, left
29	remove(left)
30	left += 1
31
32	return (min_len, best_left)

Invariant: curr_sum is the sum of nums[left..right], and every window that starts before left has already had its shortest valid length recorded.

Grow the window by moving right. As soon as it is valid (curr_sum >= target), shrink it from left while it stays valid, recording its length each time.

Once a window starting at left is valid, any longer window from the same start is worse, so left can move on for good: neither pointer ever moves back, and no shorter window is skipped.

The trap is negative numbers: dropping nums[left] can then raise curr_sum, so shrinking can turn an invalid window valid again and the scan misses answers; Shortest Subarray with Sum at Least K (LC 862) allows negatives and needs prefix sums with a monotonic deque instead.

See it run

Shortest Window, step by step

left 0right -curr_sum 0min_len -

Each box is one entry of nums, with its index above it. The window runs from left to right.

left the first index of the window
right the last index of the window
left, right a window of one entry
window an entry between left and right
removed the entry that left the window

Start: left = 0 and curr_sum = 0. Move right to grow the window until curr_sum reaches 7.

1 / 13

Gotchas1 of 4

The trap
Gotcha 1: Using the shrinking window when nums has negative numbers
Mistake
```
minSubArrayLen(k, nums)
```
Fix
```
shortest_subarray(nums, k)
```
What happens: The loop shrinks by dropping nums[left], and it expects curr_sum to go down. A negative nums[left] makes curr_sum go up instead. So the sum can fall below target and then rise again as more values leave. The loop stops at the first fall and misses the shorter windows. Shortest Subarray with Sum at Least K (LC 862) allows negatives. It needs prefix sums with a monotonic deque, as in shortest_subarray.
Example: Shortest Subarray with Sum at Least K (LC 862): nums = [1, -1, 5], k = 5
Mistake: returns 3Fix: returns 1
Gotcha 2: Recording the length after the shrinking loop
Mistake
```
while curr_sum >= target:
    curr_sum -= nums[left]
    left += 1
min_len = min(min_len, right - left + 1)
```
Fix
```
while curr_sum >= target:
    min_len = min(min_len, right - left + 1)
    curr_sum -= nums[left]
    left += 1
```
What happens: The shrinking loop stops when curr_sum is below target. So after the loop, the window is not valid. The mistake records the length of that invalid window. It even records a length on steps where no window was ever valid. The answer comes out too small.
Example: nums = [2, 3, 1, 2, 4, 3], target = 7
Mistake: returns 1Fix: returns 2
Gotcha 3: Returning the inf placeholder when no window is valid
Mistake
```
return min_len
```
Fix
```
return 0 if min_len == float('inf') else min_len
```
What happens: min_len starts at float('inf'), so any real length is smaller. When no window reaches target, min_len never changes. Minimum Size Subarray Sum (LC 209) asks for 0 in that case, not infinity.
Example: nums = [1, 1], target = 5
Mistake: returns infFix: returns 0
Gotcha 4: Comparing whole count maps in Minimum Window Substring (LC 76)
What happens: In Minimum Window Substring (LC 76), the window is valid when it holds every required character often enough. Comparing two whole count maps reads every character at every step. Keep one number, formed, instead. Add 1 to formed only when a required character's running count in the window equals its required count, checked with ==, never >=: >= would add 1 again on every extra duplicate past the quota (a 5th 'A' when only 2 are required), making formed climb on a character that is already satisfied while a character still short, like 'B' or 'C', never gets counted for it. Subtract 1 from formed when a required character's running count drops below its required count. The window is valid when formed == required. The answer is the same, and each step costs O(1).

Not this one if…

The question asks for the longest window that stays within a limit, as in Longest Substring Without Repeating Characters (LC 3): adding elements makes the window worse, not better. See Longest Window
The sum must be exactly k and values can be negative, as in Subarray Sum Equals K (LC 560): adding an element does not always move the window closer to valid. See Prefix Sum Map

Theory

The question we build

What we know

nums holds non-negative integers. Adding an element to a window never lowers its sum, so a window that is valid stays valid as it grows.

What the problem gives us

The input is nums and target. Return the length of the shortest contiguous subarray whose sum is at least target, or 0 if none exists.

The question we build

For each right, we ask: "is the sum of nums[left..right] at least target?" Once that window is valid, is any longer window starting at the same left worth recording? A longer window from the same left has a larger sum and a larger length, so it can never beat the one just found.

Narrowing down to the template

Which windows that end at right can still be the answer? Once a window starting at left is valid, every longer window from the same left is worse (same or larger sum, more length), so left can move on for good. So shrinking from left while the window stays valid never skips a shorter answer, and left never needs to move backward. That is exactly Shortest Window: grow with right, and while the window is valid, record its length and shrink from left.

Step 1: Every window

Check every window (left, right), summing it from scratch. Correct: the sum is recomputed for each window. States the contract in one listing: the shortest window whose sum is at least target.

Step 1: Every windowPython

1		def min_sub_array_len_brute(target, nums):
2		n = len(nums)
3		best = float('inf')
4		for left in range(n):
5		total = 0
6		for right in range(left, n):
7		total += nums[right]
8		if total >= target:
9		best = min(best, right - left + 1)
10		break # Longer windows from this left are worse
11		return 0 if best == float('inf') else best

Cost: O(N^2) time, O(1) extra space.

Step 2: Grow and shrink

Once a window starting at left is valid, every longer window from the same left is worse. So grow with right, and while the window stays valid, record its length and shrink from left. On input with negative numbers, dropping nums[left] can raise curr_sum instead of lowering it, so a shrink can turn an invalid window valid again and the scan misses the true shortest window.

Step 2: Grow and shrinkPython

1		def minSubArrayLen(target: int, nums: List[int]) -> int:
2		left = 0
3		curr_sum = 0 # sum of nums[left..right], the current window
4		min_len = float('inf')
5
6		for right in range(len(nums)):
7		# 1. Expand Right Frontier:
8		# Growing the window with nums[right] can only help reach curr_sum >= target, since every value added only raises the sum.
9		curr_sum += nums[right]
10
11		# 2. While Valid, Record And Shrink:
12		# A window starting at left that already reaches target stays at least as large as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
13		while curr_sum >= target:
14		min_len = min(min_len, right - left + 1)
15		curr_sum -= nums[left]
16		left += 1
17
18		return 0 if min_len == float('inf') else min_len

Cost: O(N) time, O(1) extra space.

Step 3: The named template

The loop does not change between problems. Only add, remove and is_valid change.

Step 3: The named templatePython

1	+	New line: from typing import Callable, Tuple
2
3	+	New line: def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
4	+	New line: """Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
5	+	New line: Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
6	+	New line: Precondition: every longer window that holds a valid window is valid too.
7	+	New line: add(i) and remove(i) update the window's state for index i.
8	+	New line: Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
9	+	New line: T = the cost of one add, remove or is_valid call.
10	+	New line: Time: O(N * T) \| Space: O(1) besides the window's state
11	+	New line: """
12	+	New line: if is_valid():
13	+	New line: return (0, 0) # Nothing needs to change: the empty window is already valid
14
15		left = 0
16	+	New line: min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
17
18	+	New line: for right in range(n):
19		# 1. Expand Right Frontier:
20	+	New line: # Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
21	+	New line: add(right)
22
23		# 2. While Valid, Record And Shrink:
24	+	New line: # A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
25	+	New line: while is_valid():
26	+	New line: if right - left + 1 < min_len:
27	+	New line: min_len, best_left = right - left + 1, left
28	+	New line: remove(left)
29		left += 1
30
31	+	New line: return (min_len, best_left)

Cost: O(N * T), where T is the cost of one add, remove or is_valid call.

Before	After	What changed
`curr_sum += nums[right]`	`add(right)`	Expanding the window becomes `add`.
`while curr_sum >= target:`	`while is_valid():`	The sum check becomes `is_valid`.
`curr_sum -= nums[left]`	`remove(left)`	Contracting the window becomes `remove`.
`min_len = min(min_len, right - left + 1)`	`min_len, best_left = right - left + 1, left` (when smaller)	The template also remembers where the shortest window started.

Practice

Canonical LeetCode:Minimum Size Subarray Sum (LC 209)Minimum Window Substring (LC 76)Replace the Substring for Balanced String (LC 1234)Minimum Consecutive Cards to Pick Up (LC 2260)

Theory Context•Two Pointers & Sliding Window

Builds on Longest Window, which you haven’t finished yet.

P1MediumBuilt on Longest Window~4 min speedrun

Variable-Size Sliding Window (Minimum Window)

Built on

Longest WindowShrink the window while it is still valid and record its length each time, instead of shrinking only when it becomes invalid.

The problem

Minimum Size Subarray Sum (LC 209)(opens leetcode.com)

Example 1

Input:target = 7, nums = [2,3,1,2,4,3]

Output:2

The subarray [4,3] sums to 7, meeting the target with the fewest elements possible.

Shortest Window

left -> right -> (Expand to Validate, Shrink to Minimize)

Spot it when: You want the shortest contiguous subarray or substring that meets a condition, where adding elements only makes the condition easier to meet.

Shortest Window

Python

1	from typing import Callable, List, Tuple
2
3
4	def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
5	"""Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
6	Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
7	Precondition: every longer window that holds a valid window is valid too.
8	add(i) and remove(i) update the window's state for index i.
9	Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
10	T = the cost of one add, remove or is_valid call.
11	Time: O(N * T) \| Space: O(1) besides the window's state
12	"""
13	if is_valid():
14	return (0, 0) # Nothing needs to change: the empty window is already valid
15
16	left = 0
17	min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
18
19	for right in range(n):
20	# 1. Expand Right Frontier:
21	# Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
22	add(right)
23
24	# 2. While Valid, Record And Shrink:
25	# A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
26	while is_valid():
27	if right - left + 1 < min_len:
28	min_len, best_left = right - left + 1, left
29	remove(left)
30	left += 1
31
32	return (min_len, best_left)

Invariant: curr_sum is the sum of nums[left..right], and every window that starts before left has already had its shortest valid length recorded.

Grow the window by moving right. As soon as it is valid (curr_sum >= target), shrink it from left while it stays valid, recording its length each time.

Once a window starting at left is valid, any longer window from the same start is worse, so left can move on for good: neither pointer ever moves back, and no shorter window is skipped.

See it run

Shortest Window, step by step

left 0right -curr_sum 0min_len -

Each box is one entry of nums, with its index above it. The window runs from left to right.

left the first index of the window
right the last index of the window
left, right a window of one entry
window an entry between left and right
removed the entry that left the window

Start: left = 0 and curr_sum = 0. Move right to grow the window until curr_sum reaches 7.

1 / 13

Gotchas1 of 4

The trap
Gotcha 1: Using the shrinking window when nums has negative numbers
Mistake
```
minSubArrayLen(k, nums)
```
Fix
```
shortest_subarray(nums, k)
```
What happens: The loop shrinks by dropping nums[left], and it expects curr_sum to go down. A negative nums[left] makes curr_sum go up instead. So the sum can fall below target and then rise again as more values leave. The loop stops at the first fall and misses the shorter windows. Shortest Subarray with Sum at Least K (LC 862) allows negatives. It needs prefix sums with a monotonic deque, as in shortest_subarray.
Example: Shortest Subarray with Sum at Least K (LC 862): nums = [1, -1, 5], k = 5
Mistake: returns 3Fix: returns 1
Gotcha 2: Recording the length after the shrinking loop
Mistake
```
while curr_sum >= target:
    curr_sum -= nums[left]
    left += 1
min_len = min(min_len, right - left + 1)
```
Fix
```
while curr_sum >= target:
    min_len = min(min_len, right - left + 1)
    curr_sum -= nums[left]
    left += 1
```
What happens: The shrinking loop stops when curr_sum is below target. So after the loop, the window is not valid. The mistake records the length of that invalid window. It even records a length on steps where no window was ever valid. The answer comes out too small.
Example: nums = [2, 3, 1, 2, 4, 3], target = 7
Mistake: returns 1Fix: returns 2
Gotcha 3: Returning the inf placeholder when no window is valid
Mistake
```
return min_len
```
Fix
```
return 0 if min_len == float('inf') else min_len
```
What happens: min_len starts at float('inf'), so any real length is smaller. When no window reaches target, min_len never changes. Minimum Size Subarray Sum (LC 209) asks for 0 in that case, not infinity.
Example: nums = [1, 1], target = 5
Mistake: returns infFix: returns 0
Gotcha 4: Comparing whole count maps in Minimum Window Substring (LC 76)
What happens: In Minimum Window Substring (LC 76), the window is valid when it holds every required character often enough. Comparing two whole count maps reads every character at every step. Keep one number, formed, instead. Add 1 to formed only when a required character's running count in the window equals its required count, checked with ==, never >=: >= would add 1 again on every extra duplicate past the quota (a 5th 'A' when only 2 are required), making formed climb on a character that is already satisfied while a character still short, like 'B' or 'C', never gets counted for it. Subtract 1 from formed when a required character's running count drops below its required count. The window is valid when formed == required. The answer is the same, and each step costs O(1).

Not this one if…

The question asks for the longest window that stays within a limit, as in Longest Substring Without Repeating Characters (LC 3): adding elements makes the window worse, not better. See Longest Window
The sum must be exactly k and values can be negative, as in Subarray Sum Equals K (LC 560): adding an element does not always move the window closer to valid. See Prefix Sum Map

Theory

The question we build

What we know

nums holds non-negative integers. Adding an element to a window never lowers its sum, so a window that is valid stays valid as it grows.

What the problem gives us

The input is nums and target. Return the length of the shortest contiguous subarray whose sum is at least target, or 0 if none exists.

The question we build

Narrowing down to the template

Step 1: Every window

Check every window (left, right), summing it from scratch. Correct: the sum is recomputed for each window. States the contract in one listing: the shortest window whose sum is at least target.

Step 1: Every windowPython

1		def min_sub_array_len_brute(target, nums):
2		n = len(nums)
3		best = float('inf')
4		for left in range(n):
5		total = 0
6		for right in range(left, n):
7		total += nums[right]
8		if total >= target:
9		best = min(best, right - left + 1)
10		break # Longer windows from this left are worse
11		return 0 if best == float('inf') else best

Cost: O(N^2) time, O(1) extra space.

Step 2: Grow and shrink

Step 2: Grow and shrinkPython

1		def minSubArrayLen(target: int, nums: List[int]) -> int:
2		left = 0
3		curr_sum = 0 # sum of nums[left..right], the current window
4		min_len = float('inf')
5
6		for right in range(len(nums)):
7		# 1. Expand Right Frontier:
8		# Growing the window with nums[right] can only help reach curr_sum >= target, since every value added only raises the sum.
9		curr_sum += nums[right]
10
11		# 2. While Valid, Record And Shrink:
12		# A window starting at left that already reaches target stays at least as large as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
13		while curr_sum >= target:
14		min_len = min(min_len, right - left + 1)
15		curr_sum -= nums[left]
16		left += 1
17
18		return 0 if min_len == float('inf') else min_len

Cost: O(N) time, O(1) extra space.

Step 3: The named template

The loop does not change between problems. Only add, remove and is_valid change.

Step 3: The named templatePython

1	+	New line: from typing import Callable, Tuple
2
3	+	New line: def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
4	+	New line: """Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
5	+	New line: Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
6	+	New line: Precondition: every longer window that holds a valid window is valid too.
7	+	New line: add(i) and remove(i) update the window's state for index i.
8	+	New line: Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
9	+	New line: T = the cost of one add, remove or is_valid call.
10	+	New line: Time: O(N * T) \| Space: O(1) besides the window's state
11	+	New line: """
12	+	New line: if is_valid():
13	+	New line: return (0, 0) # Nothing needs to change: the empty window is already valid
14
15		left = 0
16	+	New line: min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
17
18	+	New line: for right in range(n):
19		# 1. Expand Right Frontier:
20	+	New line: # Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
21	+	New line: add(right)
22
23		# 2. While Valid, Record And Shrink:
24	+	New line: # A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
25	+	New line: while is_valid():
26	+	New line: if right - left + 1 < min_len:
27	+	New line: min_len, best_left = right - left + 1, left
28	+	New line: remove(left)
29		left += 1
30
31	+	New line: return (min_len, best_left)

Cost: O(N * T), where T is the cost of one add, remove or is_valid call.

Before	After	What changed
`curr_sum += nums[right]`	`add(right)`	Expanding the window becomes `add`.
`while curr_sum >= target:`	`while is_valid():`	The sum check becomes `is_valid`.
`curr_sum -= nums[left]`	`remove(left)`	Contracting the window becomes `remove`.
`min_len = min(min_len, right - left + 1)`	`min_len, best_left = right - left + 1, left` (when smaller)	The template also remembers where the shortest window started.

Practice

Canonical LeetCode:Minimum Size Subarray Sum (LC 209)Minimum Window Substring (LC 76)Replace the Substring for Balanced String (LC 1234)Minimum Consecutive Cards to Pick Up (LC 2260)

Theory Context•Two Pointers & Sliding Window

Builds on Longest Window, which you haven’t finished yet.

P1MediumBuilt on Longest Window~4 min speedrun

Variable-Size Sliding Window (Minimum Window)

Built on

Longest WindowShrink the window while it is still valid and record its length each time, instead of shrinking only when it becomes invalid.

The problem

Minimum Size Subarray Sum (LC 209)(opens leetcode.com)

Example 1

Input:target = 7, nums = [2,3,1,2,4,3]

Output:2

The subarray [4,3] sums to 7, meeting the target with the fewest elements possible.

Shortest Window

left -> right -> (Expand to Validate, Shrink to Minimize)

Spot it when: You want the shortest contiguous subarray or substring that meets a condition, where adding elements only makes the condition easier to meet.

Shortest Window

Python

1	from typing import Callable, List, Tuple
2
3
4	def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
5	"""Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
6	Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
7	Precondition: every longer window that holds a valid window is valid too.
8	add(i) and remove(i) update the window's state for index i.
9	Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
10	T = the cost of one add, remove or is_valid call.
11	Time: O(N * T) \| Space: O(1) besides the window's state
12	"""
13	if is_valid():
14	return (0, 0) # Nothing needs to change: the empty window is already valid
15
16	left = 0
17	min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
18
19	for right in range(n):
20	# 1. Expand Right Frontier:
21	# Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
22	add(right)
23
24	# 2. While Valid, Record And Shrink:
25	# A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
26	while is_valid():
27	if right - left + 1 < min_len:
28	min_len, best_left = right - left + 1, left
29	remove(left)
30	left += 1
31
32	return (min_len, best_left)

Invariant: curr_sum is the sum of nums[left..right], and every window that starts before left has already had its shortest valid length recorded.

Grow the window by moving right. As soon as it is valid (curr_sum >= target), shrink it from left while it stays valid, recording its length each time.

Once a window starting at left is valid, any longer window from the same start is worse, so left can move on for good: neither pointer ever moves back, and no shorter window is skipped.

See it run

Shortest Window, step by step

left 0right -curr_sum 0min_len -

Each box is one entry of nums, with its index above it. The window runs from left to right.

left the first index of the window
right the last index of the window
left, right a window of one entry
window an entry between left and right
removed the entry that left the window

Start: left = 0 and curr_sum = 0. Move right to grow the window until curr_sum reaches 7.

1 / 13

Gotchas1 of 4

The trap
Gotcha 1: Using the shrinking window when nums has negative numbers
Mistake
```
minSubArrayLen(k, nums)
```
Fix
```
shortest_subarray(nums, k)
```
What happens: The loop shrinks by dropping nums[left], and it expects curr_sum to go down. A negative nums[left] makes curr_sum go up instead. So the sum can fall below target and then rise again as more values leave. The loop stops at the first fall and misses the shorter windows. Shortest Subarray with Sum at Least K (LC 862) allows negatives. It needs prefix sums with a monotonic deque, as in shortest_subarray.
Example: Shortest Subarray with Sum at Least K (LC 862): nums = [1, -1, 5], k = 5
Mistake: returns 3Fix: returns 1
Gotcha 2: Recording the length after the shrinking loop
Mistake
```
while curr_sum >= target:
    curr_sum -= nums[left]
    left += 1
min_len = min(min_len, right - left + 1)
```
Fix
```
while curr_sum >= target:
    min_len = min(min_len, right - left + 1)
    curr_sum -= nums[left]
    left += 1
```
What happens: The shrinking loop stops when curr_sum is below target. So after the loop, the window is not valid. The mistake records the length of that invalid window. It even records a length on steps where no window was ever valid. The answer comes out too small.
Example: nums = [2, 3, 1, 2, 4, 3], target = 7
Mistake: returns 1Fix: returns 2
Gotcha 3: Returning the inf placeholder when no window is valid
Mistake
```
return min_len
```
Fix
```
return 0 if min_len == float('inf') else min_len
```
What happens: min_len starts at float('inf'), so any real length is smaller. When no window reaches target, min_len never changes. Minimum Size Subarray Sum (LC 209) asks for 0 in that case, not infinity.
Example: nums = [1, 1], target = 5
Mistake: returns infFix: returns 0
Gotcha 4: Comparing whole count maps in Minimum Window Substring (LC 76)
What happens: In Minimum Window Substring (LC 76), the window is valid when it holds every required character often enough. Comparing two whole count maps reads every character at every step. Keep one number, formed, instead. Add 1 to formed only when a required character's running count in the window equals its required count, checked with ==, never >=: >= would add 1 again on every extra duplicate past the quota (a 5th 'A' when only 2 are required), making formed climb on a character that is already satisfied while a character still short, like 'B' or 'C', never gets counted for it. Subtract 1 from formed when a required character's running count drops below its required count. The window is valid when formed == required. The answer is the same, and each step costs O(1).

Not this one if…

The question asks for the longest window that stays within a limit, as in Longest Substring Without Repeating Characters (LC 3): adding elements makes the window worse, not better. See Longest Window
The sum must be exactly k and values can be negative, as in Subarray Sum Equals K (LC 560): adding an element does not always move the window closer to valid. See Prefix Sum Map

Theory

The question we build

What we know

nums holds non-negative integers. Adding an element to a window never lowers its sum, so a window that is valid stays valid as it grows.

What the problem gives us

The input is nums and target. Return the length of the shortest contiguous subarray whose sum is at least target, or 0 if none exists.

The question we build

Narrowing down to the template

Step 1: Every window

Check every window (left, right), summing it from scratch. Correct: the sum is recomputed for each window. States the contract in one listing: the shortest window whose sum is at least target.

Step 1: Every windowPython

1		def min_sub_array_len_brute(target, nums):
2		n = len(nums)
3		best = float('inf')
4		for left in range(n):
5		total = 0
6		for right in range(left, n):
7		total += nums[right]
8		if total >= target:
9		best = min(best, right - left + 1)
10		break # Longer windows from this left are worse
11		return 0 if best == float('inf') else best

Cost: O(N^2) time, O(1) extra space.

Step 2: Grow and shrink

Step 2: Grow and shrinkPython

1		def minSubArrayLen(target: int, nums: List[int]) -> int:
2		left = 0
3		curr_sum = 0 # sum of nums[left..right], the current window
4		min_len = float('inf')
5
6		for right in range(len(nums)):
7		# 1. Expand Right Frontier:
8		# Growing the window with nums[right] can only help reach curr_sum >= target, since every value added only raises the sum.
9		curr_sum += nums[right]
10
11		# 2. While Valid, Record And Shrink:
12		# A window starting at left that already reaches target stays at least as large as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
13		while curr_sum >= target:
14		min_len = min(min_len, right - left + 1)
15		curr_sum -= nums[left]
16		left += 1
17
18		return 0 if min_len == float('inf') else min_len

Cost: O(N) time, O(1) extra space.

Step 3: The named template

The loop does not change between problems. Only add, remove and is_valid change.

Step 3: The named templatePython

1	+	New line: from typing import Callable, Tuple
2
3	+	New line: def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
4	+	New line: """Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
5	+	New line: Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
6	+	New line: Precondition: every longer window that holds a valid window is valid too.
7	+	New line: add(i) and remove(i) update the window's state for index i.
8	+	New line: Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
9	+	New line: T = the cost of one add, remove or is_valid call.
10	+	New line: Time: O(N * T) \| Space: O(1) besides the window's state
11	+	New line: """
12	+	New line: if is_valid():
13	+	New line: return (0, 0) # Nothing needs to change: the empty window is already valid
14
15		left = 0
16	+	New line: min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
17
18	+	New line: for right in range(n):
19		# 1. Expand Right Frontier:
20	+	New line: # Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
21	+	New line: add(right)
22
23		# 2. While Valid, Record And Shrink:
24	+	New line: # A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
25	+	New line: while is_valid():
26	+	New line: if right - left + 1 < min_len:
27	+	New line: min_len, best_left = right - left + 1, left
28	+	New line: remove(left)
29		left += 1
30
31	+	New line: return (min_len, best_left)

Cost: O(N * T), where T is the cost of one add, remove or is_valid call.

Before	After	What changed
`curr_sum += nums[right]`	`add(right)`	Expanding the window becomes `add`.
`while curr_sum >= target:`	`while is_valid():`	The sum check becomes `is_valid`.
`curr_sum -= nums[left]`	`remove(left)`	Contracting the window becomes `remove`.
`min_len = min(min_len, right - left + 1)`	`min_len, best_left = right - left + 1, left` (when smaller)	The template also remembers where the shortest window started.

Practice

Canonical LeetCode:Minimum Size Subarray Sum (LC 209)Minimum Window Substring (LC 76)Replace the Substring for Balanced String (LC 1234)Minimum Consecutive Cards to Pick Up (LC 2260)

Theory Context•Two Pointers & Sliding Window

Builds on Longest Window, which you haven’t finished yet.

P1MediumBuilt on Longest Window~4 min speedrun

Variable-Size Sliding Window (Minimum Window)

Built on

Longest WindowShrink the window while it is still valid and record its length each time, instead of shrinking only when it becomes invalid.

The problem

Minimum Size Subarray Sum (LC 209)(opens leetcode.com)

Example 1

Input:target = 7, nums = [2,3,1,2,4,3]

Output:2

The subarray [4,3] sums to 7, meeting the target with the fewest elements possible.

Shortest Window

left -> right -> (Expand to Validate, Shrink to Minimize)

Spot it when: You want the shortest contiguous subarray or substring that meets a condition, where adding elements only makes the condition easier to meet.

Shortest Window

Python

1	from typing import Callable, List, Tuple
2
3
4	def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
5	"""Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
6	Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
7	Precondition: every longer window that holds a valid window is valid too.
8	add(i) and remove(i) update the window's state for index i.
9	Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
10	T = the cost of one add, remove or is_valid call.
11	Time: O(N * T) \| Space: O(1) besides the window's state
12	"""
13	if is_valid():
14	return (0, 0) # Nothing needs to change: the empty window is already valid
15
16	left = 0
17	min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
18
19	for right in range(n):
20	# 1. Expand Right Frontier:
21	# Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
22	add(right)
23
24	# 2. While Valid, Record And Shrink:
25	# A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
26	while is_valid():
27	if right - left + 1 < min_len:
28	min_len, best_left = right - left + 1, left
29	remove(left)
30	left += 1
31
32	return (min_len, best_left)

Invariant: curr_sum is the sum of nums[left..right], and every window that starts before left has already had its shortest valid length recorded.

Grow the window by moving right. As soon as it is valid (curr_sum >= target), shrink it from left while it stays valid, recording its length each time.

Once a window starting at left is valid, any longer window from the same start is worse, so left can move on for good: neither pointer ever moves back, and no shorter window is skipped.

See it run

Shortest Window, step by step

left 0right -curr_sum 0min_len -

Each box is one entry of nums, with its index above it. The window runs from left to right.

left the first index of the window
right the last index of the window
left, right a window of one entry
window an entry between left and right
removed the entry that left the window

Start: left = 0 and curr_sum = 0. Move right to grow the window until curr_sum reaches 7.

1 / 13

Gotchas1 of 4

The trap
Gotcha 1: Using the shrinking window when nums has negative numbers
Mistake
```
minSubArrayLen(k, nums)
```
Fix
```
shortest_subarray(nums, k)
```
What happens: The loop shrinks by dropping nums[left], and it expects curr_sum to go down. A negative nums[left] makes curr_sum go up instead. So the sum can fall below target and then rise again as more values leave. The loop stops at the first fall and misses the shorter windows. Shortest Subarray with Sum at Least K (LC 862) allows negatives. It needs prefix sums with a monotonic deque, as in shortest_subarray.
Example: Shortest Subarray with Sum at Least K (LC 862): nums = [1, -1, 5], k = 5
Mistake: returns 3Fix: returns 1
Gotcha 2: Recording the length after the shrinking loop
Mistake
```
while curr_sum >= target:
    curr_sum -= nums[left]
    left += 1
min_len = min(min_len, right - left + 1)
```
Fix
```
while curr_sum >= target:
    min_len = min(min_len, right - left + 1)
    curr_sum -= nums[left]
    left += 1
```
What happens: The shrinking loop stops when curr_sum is below target. So after the loop, the window is not valid. The mistake records the length of that invalid window. It even records a length on steps where no window was ever valid. The answer comes out too small.
Example: nums = [2, 3, 1, 2, 4, 3], target = 7
Mistake: returns 1Fix: returns 2
Gotcha 3: Returning the inf placeholder when no window is valid
Mistake
```
return min_len
```
Fix
```
return 0 if min_len == float('inf') else min_len
```
What happens: min_len starts at float('inf'), so any real length is smaller. When no window reaches target, min_len never changes. Minimum Size Subarray Sum (LC 209) asks for 0 in that case, not infinity.
Example: nums = [1, 1], target = 5
Mistake: returns infFix: returns 0
Gotcha 4: Comparing whole count maps in Minimum Window Substring (LC 76)
What happens: In Minimum Window Substring (LC 76), the window is valid when it holds every required character often enough. Comparing two whole count maps reads every character at every step. Keep one number, formed, instead. Add 1 to formed only when a required character's running count in the window equals its required count, checked with ==, never >=: >= would add 1 again on every extra duplicate past the quota (a 5th 'A' when only 2 are required), making formed climb on a character that is already satisfied while a character still short, like 'B' or 'C', never gets counted for it. Subtract 1 from formed when a required character's running count drops below its required count. The window is valid when formed == required. The answer is the same, and each step costs O(1).

Not this one if…

The question asks for the longest window that stays within a limit, as in Longest Substring Without Repeating Characters (LC 3): adding elements makes the window worse, not better. See Longest Window
The sum must be exactly k and values can be negative, as in Subarray Sum Equals K (LC 560): adding an element does not always move the window closer to valid. See Prefix Sum Map

Theory

The question we build

What we know

nums holds non-negative integers. Adding an element to a window never lowers its sum, so a window that is valid stays valid as it grows.

What the problem gives us

The input is nums and target. Return the length of the shortest contiguous subarray whose sum is at least target, or 0 if none exists.

The question we build

Narrowing down to the template

Step 1: Every window

Check every window (left, right), summing it from scratch. Correct: the sum is recomputed for each window. States the contract in one listing: the shortest window whose sum is at least target.

Step 1: Every windowPython

1		def min_sub_array_len_brute(target, nums):
2		n = len(nums)
3		best = float('inf')
4		for left in range(n):
5		total = 0
6		for right in range(left, n):
7		total += nums[right]
8		if total >= target:
9		best = min(best, right - left + 1)
10		break # Longer windows from this left are worse
11		return 0 if best == float('inf') else best

Cost: O(N^2) time, O(1) extra space.

Step 2: Grow and shrink

Step 2: Grow and shrinkPython

1		def minSubArrayLen(target: int, nums: List[int]) -> int:
2		left = 0
3		curr_sum = 0 # sum of nums[left..right], the current window
4		min_len = float('inf')
5
6		for right in range(len(nums)):
7		# 1. Expand Right Frontier:
8		# Growing the window with nums[right] can only help reach curr_sum >= target, since every value added only raises the sum.
9		curr_sum += nums[right]
10
11		# 2. While Valid, Record And Shrink:
12		# A window starting at left that already reaches target stays at least as large as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
13		while curr_sum >= target:
14		min_len = min(min_len, right - left + 1)
15		curr_sum -= nums[left]
16		left += 1
17
18		return 0 if min_len == float('inf') else min_len

Cost: O(N) time, O(1) extra space.

Step 3: The named template

The loop does not change between problems. Only add, remove and is_valid change.

Step 3: The named templatePython

1	+	New line: from typing import Callable, Tuple
2
3	+	New line: def shortest_window(n: int, add: Callable[[int], None], remove: Callable[[int], None], is_valid: Callable[[], bool]) -> Tuple[float, int]:
4	+	New line: """Shortest Window: the shortest valid window [left, right] of indices 0..n-1, as (length, left).
5	+	New line: Returns (0, 0) when the empty window is already valid, and (float('inf'), -1) when no window is valid.
6	+	New line: Precondition: every longer window that holds a valid window is valid too.
7	+	New line: add(i) and remove(i) update the window's state for index i.
8	+	New line: Smallest Range Covering Elements from K Lists does not fit, because it measures a range of values, not a length.
9	+	New line: T = the cost of one add, remove or is_valid call.
10	+	New line: Time: O(N * T) \| Space: O(1) besides the window's state
11	+	New line: """
12	+	New line: if is_valid():
13	+	New line: return (0, 0) # Nothing needs to change: the empty window is already valid
14
15		left = 0
16	+	New line: min_len, best_left = float('inf'), -1 # length and start of the shortest valid window found so far
17
18	+	New line: for right in range(n):
19		# 1. Expand Right Frontier:
20	+	New line: # Growing the window with the next index can only help reach a valid window, since add never removes anything the window already needed.
21	+	New line: add(right)
22
23		# 2. While Valid, Record And Shrink:
24	+	New line: # A window starting at left that is already valid stays valid or better as it grows, so any longer window from the same left is worse; record it, then shrink from left since no longer window from this left can beat the one just recorded.
25	+	New line: while is_valid():
26	+	New line: if right - left + 1 < min_len:
27	+	New line: min_len, best_left = right - left + 1, left
28	+	New line: remove(left)
29		left += 1
30
31	+	New line: return (min_len, best_left)

Cost: O(N * T), where T is the cost of one add, remove or is_valid call.

Before	After	What changed
`curr_sum += nums[right]`	`add(right)`	Expanding the window becomes `add`.
`while curr_sum >= target:`	`while is_valid():`	The sum check becomes `is_valid`.
`curr_sum -= nums[left]`	`remove(left)`	Contracting the window becomes `remove`.
`min_len = min(min_len, right - left + 1)`	`min_len, best_left = right - left + 1, left` (when smaller)	The template also remembers where the shortest window started.

Practice

Canonical LeetCode:Minimum Size Subarray Sum (LC 209)Minimum Window Substring (LC 76)Replace the Substring for Balanced String (LC 1234)Minimum Consecutive Cards to Pick Up (LC 2260)