Sliding Window on Arrays in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the window sum with the first k elements.

DSA Java

int windowSum = 0;
for (int i = 0; i < [1]; i++) {
    windowSum += nums[i];
}

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

Ak - 1

Bnums.length

Ck

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using nums.length instead of k causes summing the whole array.

Using k - 1 misses the last element in the window.

We sum the first k elements to initialize the sliding window sum.

2fill in blank

medium

Complete the code to slide the window by removing the left element and adding the right element.

DSA Java

for (int i = [1]; i < nums.length; i++) {
    windowSum = windowSum - nums[i - k] + nums[i];
}

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

Ak

Bk - 1

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from 0 causes index errors when subtracting.

Starting from k - 1 misses the first slide.

The loop starts from index k to slide the window forward.

3fill in blank

hard

Fix the error in the code to update the maximum sum correctly inside the loop.

DSA Java

int maxSum = windowSum;
for (int i = k; i < nums.length; i++) {
    windowSum = windowSum - nums[i - k] + nums[i];
    maxSum = [1];
}

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

AMath.max(maxSum, windowSum)

BMath.min(maxSum, windowSum)

CmaxSum + windowSum

DwindowSum

Attempts:

3 left

💡 Hint

Common Mistakes

Using Math.min updates maxSum incorrectly.

Adding maxSum and windowSum accumulates sums wrongly.

We update maxSum to the larger of current maxSum and windowSum.

4fill in blank

hard

Fill both blanks to create a sliding window that finds the minimum sum of any subarray of size k.

DSA Java

int windowSum = 0;
for (int i = 0; i < [1]; i++) {
    windowSum += nums[i];
}
int minSum = windowSum;
for (int i = [2]; i < nums.length; i++) {
    windowSum = windowSum - nums[i - k] + nums[i];
    minSum = Math.min(minSum, windowSum);
}

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

Ak

Bk - 1

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using k - 1 causes off-by-one errors.

Starting sliding from 0 causes index errors.

Both loops use k to define the window size and start sliding from index k.

5fill in blank

hard

Fill all three blanks to create a sliding window that counts how many subarrays of size k have sum greater than threshold.

DSA Java

int count = 0;
int windowSum = 0;
for (int i = 0; i < [1]; i++) {
    windowSum += nums[i];
}
if (windowSum > [2]) {
    count++;
}
for (int i = [3]; i < nums.length; i++) {
    windowSum = windowSum - nums[i - k] + nums[i];
    if (windowSum > threshold) {
        count++;
    }
}

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

Ak

Bthreshold

Dk - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using k - 1 for loop start causes missing subarrays.

Comparing with wrong variable instead of threshold.

Initialize window with first k elements, compare sum with threshold, and slide starting from k.

Practice

1. What is the main purpose of the sliding window technique on arrays?

easy

A. To efficiently find subarray sums or properties without recomputing everything

B. To sort the array elements in ascending order

C. To reverse the array elements

D. To find the maximum element in the entire array

Solution

1. Step 1: Understand the sliding window concept

   The sliding window technique moves a fixed-size window over the array to avoid repeated calculations.

2. Step 2: Identify the main use case

   It helps find sums or other properties of subarrays efficiently by updating the window incrementally.

3. Final Answer:

   To efficiently find subarray sums or properties without recomputing everything -> Option A

4. Quick Check:

   Sliding window = efficient subarray calculation [OK]

Hint: Think of a moving window to avoid repeated work [OK]

Common Mistakes:

• Confusing sliding window with sorting
• Thinking it reverses the array
• Assuming it finds max element globally

2. Which of the following Java code snippets correctly initializes a sliding window sum for the first k elements of an array arr?

easy

A. int sum = 0; for(int i = 1; i < k; i++) sum += arr[i];

B. int sum = arr[0]; for(int i = 1; i <= k; i++) sum += arr[i];

C. int sum = 0; for(int i = 0; i <= k; i++) sum += arr[i];

D. int sum = 0; for(int i = 0; i < k; i++) sum += arr[i];

Solution

1. Step 1: Check loop boundaries for summing first k elements

   The loop should run from 0 to k-1 to include exactly k elements.

2. Step 2: Verify each option's loop range

   int sum = 0; for(int i = 0; i < k; i++) sum += arr[i]; loops i from 0 to less than k, summing arr[0] to arr[k-1], which is correct.

3. Final Answer:

   int sum = 0; for(int i = 0; i < k; i++) sum += arr[i]; -> Option D

4. Quick Check:

   Loop 0 to k-1 sums first k elements [OK]

Hint: Loop from 0 to less than k to sum k elements [OK]

Common Mistakes:

• Using <= k causes out-of-bound errors
• Starting loop from 1 misses first element
• Initializing sum with arr[0] and looping incorrectly

3. What will be the output of the following Java code?

int[] arr = {1, 3, 2, 6, -1, 4, 1, 8, 2};
int k = 5;
int maxSum = 0, windowSum = 0;
for(int i = 0; i < k; i++) {
    windowSum += arr[i];
}
maxSum = windowSum;
for(int i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k];
    if(windowSum > maxSum) {
        maxSum = windowSum;
    }
}
System.out.println(maxSum);

medium

A. 16

B. 17

C. 18

D. 19

Solution

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

   Sum of arr[0..4] = 1+3+2+6+(-1) = 11

2. Step 2: Slide window and update maxSum

   i=5: windowSum=11+4-1=14, maxSum=14
   i=6: windowSum=14+1-3=12, maxSum=14
   i=7: windowSum=12+8-2=18, maxSum=18
   i=8: windowSum=18+2-6=14, maxSum=18

3. Final Answer:

   18 -> Option C

4. Quick Check:

   Max sliding window sum = 18 [OK]

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

Common Mistakes:

• Not subtracting the element leaving the window
• Incorrect initial sum calculation
• Updating maxSum incorrectly

4. Identify the bug in the following sliding window code that finds the maximum sum of subarrays of size k:

int maxSum = 0;
int windowSum = 0;
for(int i = 0; i <= k; i++) {
    windowSum += arr[i];
}
maxSum = windowSum;
for(int i = k; i < arr.length; i++) {
    windowSum += arr[i] - arr[i - k];
    if(windowSum > maxSum) {
        maxSum = windowSum;
    }
}
System.out.println(maxSum);

medium

A. The first loop should run from i = 0 to i < k, not i <= k

B. maxSum should be initialized to Integer.MIN_VALUE

C. The second loop should start from i = k + 1

D. windowSum should be reset to 0 before the second loop

Solution

1. Step 1: Check the first loop boundary

   The first loop runs i from 0 to k inclusive, which sums k+1 elements causing out-of-bounds error.

2. Step 2: Correct loop boundary

   The loop should run from 0 to less than k to sum exactly k elements.

3. Final Answer:

   The first loop should run from i = 0 to i < k, not i <= k -> Option A

4. Quick Check:

   Loop boundary off by one causes error [OK]

Hint: Use < k, not <= k, for k elements [OK]

Common Mistakes:

• Using <= k causes array index out of bounds
• Incorrect initialization of maxSum
• Wrong start index in second loop

5. Given an array of integers, write a Java method using the sliding window technique to find the length of the longest subarray with sum less than or equal to a given value target. Which approach correctly solves this problem?

hard

A. Sort the array and use binary search to find subarrays with sum ≤ target

B. Use two pointers to expand and shrink the window, updating max length when sum ≤ target

C. Use nested loops to check all subarrays and track the longest valid one

D. Use a stack to store sums and pop when sum exceeds target

Solution

1. Step 1: Understand the problem constraints

   We want the longest subarray with sum ≤ target, which requires dynamic window size.

2. Step 2: Apply sliding window with two pointers

   Use two pointers to expand the window adding elements, shrink from left when sum > target, track max length.

3. Final Answer:

   Use two pointers to expand and shrink the window, updating max length when sum ≤ target -> Option B

4. Quick Check:

   Two-pointer sliding window finds longest valid subarray [OK]

Hint: Expand window, shrink when sum too big, track max length [OK]

Common Mistakes:

• Sorting breaks original order, invalid for subarrays
• Nested loops are inefficient for large arrays
• Stack is not suitable for sum-based sliding window