Sliding Window on Arrays in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to calculate the sum of the first window of size k in the array.

DSA Python

def initial_window_sum(arr, k):
    window_sum = sum(arr[[1]:k])
    return window_sum

Drag options to blanks, or click blank then click option'

A0

B-1

Ck

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting the slice at 1 instead of 0, which misses the first element.

Using k as the start index, which results in an empty slice.

The first window starts at index 0, so we sum from index 0 to k-1.

2fill in blank

medium

Complete the code to slide the window by one position and update the sum.

DSA Python

def slide_window_sum(arr, window_sum, start, k):
    window_sum = window_sum - arr[start] + arr[start + [1]]
    return window_sum

Drag options to blanks, or click blank then click option'

A1

Bk - 1

Cstart

Dk

Attempts:

3 left

💡 Hint

Common Mistakes

Using start + 1 instead of start + k, which adds the wrong element.

Using k - 1 which is off by one for the new element index.

When sliding the window, we remove the element at the start and add the element at start + k.

3fill in blank

hard

Fix the error in the code to correctly find the maximum sum of any window of size k.

DSA Python

def max_window_sum(arr, k):
    max_sum = sum(arr[0:k])
    window_sum = max_sum
    for i in range(1, len(arr) - k + 1):
        window_sum = window_sum - arr[i - 1] + arr[i + [1]]
        if window_sum > max_sum:
            max_sum = window_sum
    return max_sum

Drag options to blanks, or click blank then click option'

Ak

Bk - 1

C1

Di

Attempts:

3 left

💡 Hint

Common Mistakes

Using i + k which goes out of range.

Using i which is the start index, not the new element index.

The new element index is i + k - 1 because the window covers k elements starting at i.

4fill in blank

hard

Fill both blanks to create a dictionary of window sums keyed by the window's start index.

DSA Python

def window_sums_dict(arr, k):
    sums = {}
    current_sum = sum(arr[0:k])
    sums[0] = current_sum
    for i in range(1, len(arr) - k + 1):
        current_sum = current_sum - arr[i - [1]] + arr[i + [2]]
        sums[i] = current_sum
    return sums

Drag options to blanks, or click blank then click option'

A1

Bk

Ck - 1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using k instead of 1 for the leaving element index.

Using k instead of k - 1 for the entering element index.

Subtract the element leaving at i-1 and add the element entering at i + k - 1.

5fill in blank

hard

Fill all three blanks to create a list of averages of each sliding window of size k.

DSA Python

def sliding_window_averages(arr, k):
    averages = []
    window_sum = sum(arr[0:k])
    averages.append(window_sum / [1])
    for i in range(1, len(arr) - k + 1):
        window_sum = window_sum - arr[i - [2]] + arr[i + [3]]
        averages.append(window_sum / k)
    return averages

Drag options to blanks, or click blank then click option'

Ak

B1

Ck - 1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Dividing by 1 instead of k for the average.

Using wrong indices for elements leaving or entering the window.

The average divides the sum by k. The element leaving is at i-1 and the entering element is at i + k - 1.

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