Sliding window algorithm in Rest API - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of sliding window sum calculation

What is the output of this REST API response when calculating the sum of every 3 consecutive numbers in the list?

Rest API

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

A [3, 5, 7]

B [1, 3, 5, 7, 9]

C [15, 21, 27]

D [9, 15, 21]

💡 Hint

Think about how many sums you get when sliding a window of size 3 over 5 numbers.

The sliding window sums are: 1+3+5=9, 3+5+7=15, 5+7+9=21. So the output list is [9, 15, 21].

🧠 Conceptual

intermediate

Sliding window algorithm main advantage

What is the main advantage of using a sliding window algorithm over a naive approach when processing sequences?

A It reduces time complexity by avoiding repeated calculations.

B It uses more memory to store all intermediate results.

C It always produces exact results without approximation.

D It requires sorting the input data first.

💡 Hint

Think about how sliding windows reuse previous computations.

Sliding window algorithms reuse previous computations to avoid recalculating sums or other metrics, reducing time complexity.

🔧 Debug

advanced

Identify the error in sliding window max calculation

This code tries to find the maximum value in every sliding window of size 2 but produces wrong output. What is the error?

Rest API

nums = [4, 2, 12, 3]
window = 2
max_values = []
for i in range(len(nums) - window):
    max_values.append(max(nums[i:i+window]))
print(max_values)

A The window size variable is not defined before the loop.

B The max function is used incorrectly; it should be min instead.

C The loop range should be len(nums) - window + 1 to include the last window.

D The slice nums[i:i+window] should be nums[i:i+window-1].

💡 Hint

Check how many windows the loop covers compared to the input length.

The loop stops one index too early because it uses len(nums) - window instead of len(nums) - window + 1, missing the last window.

📝 Syntax

advanced

Syntax error in sliding window average calculation

Which option contains the correct syntax to calculate the average of every sliding window of size 4 in a list?

Rest API

data = [10, 20, 30, 40, 50, 60]
window_size = 4
averages = []
for i in range(len(data) - window_size + 1):
    avg = sum(data[i:i+window_size]) / window_size
    averages.append(avg)
print(averages)

A

for i in range(len(data) - window_size + 1): avg = sum(data[i:i+window_size]) / window_size
averages.append(avg)

B for i in range(len(data) - window_size + 1): avg = sum(data[i:i+window_size]) / window_size; averages.append(avg)

C )gva(dneppa.segareva ezis_wodniw / )]ezis_wodniw+i:i[atad(mus = gva :)1 + ezis_wodniw - )atad(nel(egnar ni i rof

D for i in range(len(data) - window_size + 1): avg = sum(data[i:i+window_size]) / window_size averages.append(avg)

💡 Hint

Check for proper line breaks or statement separators in Python loops.

In Python, each statement inside a loop must be on its own line or separated by a semicolon. Option A correctly uses a newline.

🚀 Application

expert

Sliding window for longest substring without repeating characters

Given the string 'abcabcbb', what is the length of the longest substring without repeating characters using a sliding window approach?

A 4

B 3

C 2

D 5

💡 Hint

Try to find the longest substring where no character repeats by moving the window.

The longest substring without repeating characters is 'abc' with length 3.

Practice

1. What is the main advantage of using the sliding window algorithm in processing data streams?

easy

A. It processes data in fixed-size chunks efficiently by reusing previous computations.

B. It sorts the entire data before processing.

C. It stores all data in memory for faster access.

D. It processes data randomly without any order.

Solution

1. Step 1: Understand the sliding window concept

   The sliding window algorithm processes data in fixed-size chunks, moving forward by removing the oldest data and adding new data.

2. Step 2: Identify the main advantage

   This approach avoids recalculating over the entire data repeatedly, saving time and memory.

3. Final Answer:

   It processes data in fixed-size chunks efficiently by reusing previous computations. -> Option A

4. Quick Check:

   Sliding window = efficient chunk processing [OK]

Hint: Remember: sliding window reuses old results to save time [OK]

Common Mistakes:

• Thinking it sorts data first
• Assuming it stores all data in memory
• Believing it processes data randomly

2. Which of the following is the correct way to initialize a sliding window of size 3 over a list named data in Python?

easy

A. window = data[3]

B. window = data[0:3]

C. window = data(0,3)

D. window = data[:]

Solution

1. Step 1: Recall Python list slicing syntax

   To get the first 3 elements, use data[0:3], which includes indices 0, 1, and 2.

2. Step 2: Check other options

   data(0,3) is invalid syntax, data[3] gets only one element at index 3, data[:] gets the whole list.

3. Final Answer:

   window = data[0:3] -> Option B

4. Quick Check:

   Slice first 3 elements = data[0:3] [OK]

Hint: Use data[start:end] to slice lists in Python [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Selecting a single element instead of a slice
• Taking the whole list instead of a window

3. Given the Python code below, what will be the output?

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

medium

A. [1, 3, 5]

B. [15, 21, 27]

C. [3, 5, 7]

D. [9, 15, 21]

Solution

1. Step 1: Understand the loop range and slicing

   The loop runs from i=0 to i=2 (5 - 3 + 1 = 3 iterations). Each slice is data[i:i+3].

2. Step 2: Calculate sums for each window

   i=0: sum([1,3,5])=9; i=1: sum([3,5,7])=15; i=2: sum([5,7,9])=21.

3. Final Answer:

   [9, 15, 21] -> Option D

4. Quick Check:

   Sliding sums = [9, 15, 21] [OK]

Hint: Sum slices of size window_size in a loop [OK]

Common Mistakes:

• Incorrect loop range causing index errors
• Summing wrong slices
• Confusing window size with list length

4. The following code tries to implement a sliding window sum but has a bug. What is the error?

data = [2, 4, 6, 8]
window_size = 2
result = []
for i in range(len(data) - window_size):
    window_sum = sum(data[i:i+window_size])
    result.append(window_sum)
print(result)

medium

A. The result list is not initialized.

B. The sum function is used incorrectly.

C. The loop range misses the last window, causing incomplete results.

D. Window size is larger than data length.

Solution

1. Step 1: Analyze the loop range

   The loop runs from 0 to len(data) - window_size - 1, which is 4 - 2 - 1 = 1, so only indices 0 and 1.

2. Step 2: Identify missing last window

   The last valid window starts at index 2 (data[2:4]), but the loop excludes it because it should run to len(data) - window_size + 1.

3. Final Answer:

   The loop range misses the last window, causing incomplete results. -> Option C

4. Quick Check:

   Loop range must cover all windows [OK]

Hint: Use range(len(data) - window_size + 1) for full coverage [OK]

Common Mistakes:

• Using wrong loop range causing missed windows
• Misusing sum function
• Not initializing result list

5. You want to find the maximum sum of any sliding window of size 4 in a large list data. Which approach is most efficient?

hard

A. Use a sliding window by adding the new element and subtracting the oldest element from the previous sum.

B. Calculate sum of each window from scratch using sum(data[i:i+4]) in a loop.

C. Sort the entire list and pick the top 4 elements to sum.

D. Use recursion to calculate sums of all windows.

Solution

1. Step 1: Understand the problem of efficiency

   Calculating sum from scratch for each window is slow for large data because it repeats work.

2. Step 2: Apply sliding window optimization

   By keeping the previous window sum, add the new element and subtract the oldest element to get the next sum quickly.

3. Step 3: Evaluate other options

   Sorting does not help find consecutive window sums; recursion adds overhead and is inefficient here.

4. Final Answer:

   Use a sliding window by adding the new element and subtracting the oldest element from the previous sum. -> Option A

5. Quick Check:

   Sliding window sum update = add new - remove old [OK]

Hint: Update sums by adding new and removing old element [OK]

Common Mistakes:

• Recalculating sums fully each time
• Sorting unrelated to consecutive sums
• Using recursion unnecessarily