Sliding Window on Arrays in DSA Python - Execution Trace

Concept Flow - Sliding Window on Arrays

Initialize window start and end pointers

↓

Expand window by moving end pointer

↓

Check window size or condition

↓

Process window

↓

Slide window by moving start pointer

↓

Repeat until end reaches array end

Start with a window covering part of the array, expand it by moving the end pointer, process when window size or condition is met, then slide the window forward by moving the start pointer, repeat until the end reaches the array's end.

Execution Sample

DSA Python

arr = [1, 3, 2, 5, 7, 2]
window_size = 3
start = 0
for end in range(len(arr)):
    if end - start + 1 == window_size:
        print(arr[start:end+1])
        start += 1

Prints all subarrays of size 3 using a sliding window.

Execution Table

Step	Operation	start	end	Window Elements	Action	Visual State
1	Initialize start=0, end=0	0	0	[1]	Window size < 3, expand end	Window: [1]
2	Move end to 1	0	1	[1, 3]	Window size < 3, expand end	Window: [1, 3]
3	Move end to 2	0	2	[1, 3, 2]	Window size == 3, print and slide start	Window: [1, 3, 2]
4	Slide start to 1	1	2	[3, 2]	Prepare for next window	Window: [3, 2]
5	Move end to 3	1	3	[3, 2, 5]	Window size == 3, print and slide start	Window: [3, 2, 5]
6	Slide start to 2	2	3	[2, 5]	Prepare for next window	Window: [2, 5]
7	Move end to 4	2	4	[2, 5, 7]	Window size == 3, print and slide start	Window: [2, 5, 7]
8	Slide start to 3	3	4	[5, 7]	Prepare for next window	Window: [5, 7]
9	Move end to 5	3	5	[5, 7, 2]	Window size == 3, print and slide start	Window: [5, 7, 2]
10	Slide start to 4	4	5	[7, 2]	End reached, stop	Window: [7, 2]

💡 End pointer reached the last element, no more full windows of size 3

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	After Step 5	After Step 6	After Step 7	After Step 8	After Step 9	Final
start	0	0	0	0	1	1	2	2	3	3	4
end	0	0	1	2	2	3	3	4	4	5	5
window_elements	[1]	[1]	[1,3]	[1,3,2]	[3,2]	[3,2,5]	[2,5]	[2,5,7]	[5,7]	[5,7,2]	[7,2]

Key Moments - 3 Insights

Why do we check if window size equals the target size before processing?

Because only when the window size matches the target (3 here) do we have a complete subarray to process, as shown in steps 3, 5, 7, and 9 in the execution_table.

Why do we move the start pointer after processing the window?

Moving the start pointer slides the window forward to consider the next subarray, which is why after printing the window at steps 3, 5, 7, and 9, start is incremented in the next step.

What happens when the end pointer reaches the last element?

When end reaches the last element (step 10), we cannot form a new full window of the target size, so the process stops, as noted in the exit_note.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what are the elements in the window?

A [3, 2, 5]

B [2, 5, 7]

C [1, 3, 2]

D [5, 7, 2]

💡 Hint

Check the 'Window Elements' column at step 3 in the execution_table.

At which step does the start pointer first move from 0 to 1?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Look at the 'start' variable in variable_tracker after each step.

If the window size was 2 instead of 3, how would the action at step 3 change?

A Window would never be processed

B Window would be processed and start moved earlier, at step 2

C Window would be processed at step 3 as before

D Start pointer would not move

💡 Hint

Think about when the window size condition is met for size 2 compared to size 3.

Concept Snapshot

Sliding Window on Arrays:
- Use two pointers: start and end
- Expand end to grow window
- When window size matches target, process window
- Slide start to move window forward
- Repeat until end reaches array end

Full Transcript

Sliding window on arrays uses two pointers to create a moving window over the array. We start both pointers at the beginning. We move the end pointer to expand the window. When the window size equals the target size, we process the window (like printing the elements). Then we move the start pointer forward to slide the window. This repeats until the end pointer reaches the last element. This method efficiently processes all subarrays of a fixed size without re-examining elements unnecessarily.