Sliding Window on Arrays in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of sliding window maximum sum

What is the output of the following code that finds the maximum sum of any subarray of size 3 using sliding window?

DSA Python

arr = [2, 1, 5, 1, 3, 2]
window_size = 3
max_sum = 0
window_sum = sum(arr[:window_size])
max_sum = window_sum
for i in range(window_size, len(arr)):
    window_sum += arr[i] - arr[i - window_size]
    if window_sum > max_sum:
        max_sum = window_sum
print(max_sum)

A 9

B 8

C 7

D 6

💡 Hint

Think about how the window slides and updates the sum by adding the new element and removing the old one.

The sliding window sums are: 2+1+5=8, then 1+5+1=7, then 5+1+3=9, then 1+3+2=6. The maximum is 9.

❓ Predict Output

intermediate

Output of minimum average subarray

What is the output of this code that finds the minimum average of any subarray of size 4?

DSA Python

arr = [4, 2, 2, 5, 1, 5, 8]
window_size = 4
window_sum = sum(arr[:window_size])
min_sum = window_sum
for i in range(window_size, len(arr)):
    window_sum += arr[i] - arr[i - window_size]
    if window_sum < min_sum:
        min_sum = window_sum
min_avg = min_sum / window_size
print(min_avg)

A 3.25

B 2.5

C 3.0

D 4.0

💡 Hint

Calculate sums of each 4-element window and find the smallest sum, then divide by 4.

The sums of windows are: 4+2+2+5=13, 2+2+5+1=10, 2+5+1+5=13, 5+1+5+8=19. The minimum sum is 10, so average is 10/4=2.5.

🔧 Debug

advanced

Identify the error in sliding window code

What error does this code raise when trying to find the maximum sum of subarrays of size 3?

DSA Python

arr = [1, 2, 3, 4, 5]
window_size = 3
max_sum = 0
window_sum = sum(arr[:window_size])
for i in range(window_size, len(arr)):
    window_sum += arr[i] - arr[i - window_size]
    if window_sum > max_sum:
        max_sum = window_sum
print(max_sum)

A No error, output is 12

B IndexError: list index out of range

C NameError: name 'max_sum' is not defined

D TypeError: unsupported operand type(s)

💡 Hint

Check if all variables are defined and indices are valid.

All variables are defined and indices are valid. The code runs without error and outputs 12, which is the sum of last 3 elements (3+4+5).

🚀 Application

advanced

Find the count of subarrays with sum equal to k

Given an array and a number k, which option correctly counts the number of continuous subarrays whose sum equals k using sliding window?

DSA Python

arr = [1, 1, 1, 2, 3]
k = 3
count = 0
start = 0
current_sum = 0
for end in range(len(arr)):
    current_sum += arr[end]
    while current_sum > k and start <= end:
        current_sum -= arr[start]
        start += 1
    if current_sum == k:
        count += 1
print(count)

A 2

B 1

C 4

D 3

💡 Hint

Think about how the window shrinks when sum exceeds k and counts when sum equals k.

The subarrays with sum 3 are: [1,1,1], [1,2], [3]. So count is 3.

🧠 Conceptual

expert

Why sliding window fails for negative numbers in subarray sum problem?

Why does the sliding window technique fail to find the count of subarrays with sum equal to k if the array contains negative numbers?

A Because sliding window cannot handle arrays longer than 100 elements

B Because negative numbers cause index errors in sliding window

C Because sliding window assumes all numbers are positive to shrink window correctly

D Because sliding window requires sorted arrays

💡 Hint

Think about how the window shrinks when sum exceeds k and how negative numbers affect this logic.

Sliding window works by shrinking the window when sum exceeds k, assuming adding more elements increases sum. Negative numbers can decrease sum, breaking this logic.

Practice

1. What does the sliding window technique help to optimize when working with arrays?

easy

A. It reduces the time complexity by avoiding repeated calculations over overlapping subarrays.

B. It sorts the array in ascending order.

C. It finds the maximum element in the entire array.

D. It reverses the array elements.

Solution

1. Step 1: Understand the sliding window purpose

   The sliding window technique moves a fixed-size window over the array to process elements efficiently without recalculating everything each time.

2. Step 2: Identify what it optimizes

   It avoids repeated work on overlapping parts of the array, thus reducing time complexity compared to naive methods.

3. Final Answer:

   It reduces the time complexity by avoiding repeated calculations over overlapping subarrays. -> Option A

4. Quick Check:

   Sliding window = avoids repeated calculations [OK]

Hint: Sliding window avoids redoing work on overlapping parts [OK]

Common Mistakes:

• Thinking it sorts the array
• Assuming it finds max element always
• Confusing it with reversing arrays

2. Which of the following is the correct syntax to initialize a sliding window sum for the first 3 elements of an array arr in Python?

easy

A. window_sum = sum(arr[0:3])

B. window_sum = sum(arr[1:4])

C. window_sum = sum(arr[0:2])

D. window_sum = sum(arr[3:6])

Solution

1. Step 1: Identify the first 3 elements slice

   The first 3 elements are at indices 0, 1, and 2, so the slice is arr[0:3] because the end index is exclusive.

2. Step 2: Use sum function on correct slice

   sum(arr[0:3]) correctly sums elements at indices 0, 1, and 2.

3. Final Answer:

   window_sum = sum(arr[0:3]) -> Option A

4. Quick Check:

   sum(arr[0:3]) sums first 3 elements [OK]

Hint: Remember Python slices exclude the end index [OK]

Common Mistakes:

• Using wrong slice indices like arr[1:4]
• Using arr[0:2] which misses the third element
• Using arr[3:6] which skips first elements

3. What is the output of the following code?

arr = [2, 1, 5, 1, 3, 2]
window_size = 3
window_sum = sum(arr[0:3])
result = [window_sum]
for i in range(3, len(arr)):
    window_sum += arr[i] - arr[i - window_size]
    result.append(window_sum)
print(result)

medium

A. [2, 1, 5, 1]

B. [8, 9, 7, 6]

C. [8, 7, 9, 6]

D. [6, 7, 8, 9]

Solution

1. Step 1: Calculate initial window sum

   sum(arr[0:3]) = 2 + 1 + 5 = 8, so result starts as [8].

2. Step 2: Slide window and update sums

   i=3: window_sum = 8 + arr[3] - arr[0] = 8 + 1 - 2 = 7; result = [8,7] i=4: window_sum = 7 + arr[4] - arr[1] = 7 + 3 - 1 = 9; result = [8,7,9] i=5: window_sum = 9 + arr[5] - arr[2] = 9 + 2 - 5 = 6; result = [8,7,9,6]

3. Final Answer:

   [8, 7, 9, 6] -> Option C

4. Quick Check:

   Sliding sums = [8,7,9,6] [OK]

Hint: Add new element, subtract old element in window sum [OK]

Common Mistakes:

• Not subtracting the element leaving the window
• Incorrect initial sum calculation
• Appending wrong values to result

4. Find the error in the following sliding window code that calculates sums of windows of size 2:

arr = [4, 3, 2, 1]
window_size = 2
window_sum = sum(arr[0:window_size])
result = [window_sum]
for i in range(window_size, len(arr)):
    window_sum = window_sum + arr[i] + arr[i - window_size]
    result.append(window_sum)
print(result)

medium

A. The loop range should start from 0, not window_size.

B. The window_sum update should subtract arr[i - window_size], not add it.

C. The initial window_sum calculation is incorrect.

D. The result list should be initialized as empty.

Solution

1. Step 1: Analyze window_sum update

   The code adds both arr[i] and arr[i - window_size], but it should add the new element and subtract the element leaving the window.

2. Step 2: Correct the update formula

   Change window_sum = window_sum + arr[i] + arr[i - window_size] to window_sum = window_sum + arr[i] - arr[i - window_size].

3. Final Answer:

   The window_sum update should subtract arr[i - window_size], not add it. -> Option B

4. Quick Check:

   Subtract leaving element, not add [OK]

Hint: Subtract old element leaving window, add new element [OK]

Common Mistakes:

• Adding both new and old elements instead of subtracting old
• Wrong loop start index
• Incorrect initial sum

5. Given an array arr = [1, 3, 2, 6, -1, 4, 1, 8, 2] and window size 5, which sliding window sum is the maximum?
Use the sliding window technique to find the maximum sum of any 5 consecutive elements.

hard

A. 16

B. 19

C. 17

D. 18

Solution

1. Step 1: Calculate initial window sum for first 5 elements

   sum(arr[0:5]) = 1 + 3 + 2 + 6 + (-1) = 11

2. Step 2: Slide window and update sums, track max

   i=5: sum = 11 + 4 - 1 = 14 (max=14) i=6: sum = 14 + 1 - 3 = 12 (max=14) i=7: sum = 12 + 8 - 2 = 18 (max=18) i=8: sum = 18 + 2 - 6 = 14 (max=18)

3. Final Answer:

   18 -> Option D

4. Quick Check:

   Max sliding sum = 18 [OK]

Hint: Track max while sliding window sums update [OK]

Common Mistakes:

• Not updating max after each slide
• Wrong initial sum calculation
• Forgetting to subtract element leaving window