Sliding Window on Arrays in DSA Java - Build from Scratch

Sliding Window on Arrays

📖 Scenario: Imagine you are analyzing daily temperatures for a week. You want to find the highest temperature in every 3-day period to understand the hottest days in each short window.

🎯 Goal: Build a Java program that uses the sliding window technique to find the maximum temperature in every 3-day window from a list of daily temperatures.

📋 What You'll Learn

Create an integer array called temperatures with exactly these values: 30, 32, 31, 35, 33, 34, 36

Create an integer variable called windowSize and set it to 3

Use a for loop with variable i to slide the window over the array and find the maximum temperature in each window

Print the maximum temperatures for each 3-day window separated by spaces

💡 Why This Matters

🌍 Real World

Sliding window technique is used in weather data analysis, stock price monitoring, and network traffic analysis to find trends in fixed-size time frames.

💼 Career

Understanding sliding window algorithms helps in roles like data analysis, software development, and system monitoring where processing continuous data streams efficiently is important.

1

Create the temperature array

Create an integer array called temperatures with these exact values: 30, 32, 31, 35, 33, 34, 36

DSA Java

# Create the temperatures array with the given values
// Your code here

Hint

Use int[] temperatures = {30, 32, 31, 35, 33, 34, 36}; to create the array.

2

Set the window size

Create an integer variable called windowSize and set it to 3

DSA Java

int[] temperatures = {30, 32, 31, 35, 33, 34, 36};
// Create windowSize variable and set it to 3
// Your code here

Hint

Use int windowSize = 3; to set the window size.

3

Find maximum in each sliding window

Use a for loop with variable i to slide the window over temperatures and find the maximum temperature in each window of size windowSize. Store each maximum in an integer array called maxTemps.

DSA Java

int[] temperatures = {30, 32, 31, 35, 33, 34, 36};
int windowSize = 3;
// Use a for loop to find max in each window and store in maxTemps
// Your code here

Hint

Use a nested loop: outer loop slides the window, inner loop finds max in the window.

4

Print the maximum temperatures

Use a for loop with variable i to print each value in maxTemps separated by spaces.

DSA Java

int[] temperatures = {30, 32, 31, 35, 33, 34, 36};
int windowSize = 3;
int n = temperatures.length;
int[] maxTemps = new int[n - windowSize + 1];
for (int i = 0; i  max) {
            max = temperatures[j];
        }
    }
    maxTemps[i] = max;
}
// Print all values in maxTemps separated by spaces
// Your code here

Hint

Use a for loop to print each max temperature followed by a space.

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