Sliding Window on Arrays in DSA C# - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Maximum Sum Subarray with Fixed Window Size

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

DSA C#

int[] arr = {2, 1, 5, 1, 3, 2};
int windowSize = 3;
int maxSum = 0, windowSum = 0;
for (int i = 0; i < windowSize; i++) {
    windowSum += arr[i];
}
maxSum = windowSum;
for (int i = windowSize; i < arr.Length; i++) {
    windowSum += arr[i] - arr[i - windowSize];
    if (windowSum > maxSum) maxSum = windowSum;
}
System.Console.WriteLine(maxSum);

A 9

B 8

C 7

D 6

💡 Hint

Think about the sums of subarrays of size 3: (2+1+5), (1+5+1), (5+1+3), (1+3+2).

The subarrays of size 3 are: [2,1,5] sum=8, [1,5,1] sum=7, [5,1,3] sum=9, [1,3,2] sum=6. The maximum sum is 9.

❓ Predict Output

intermediate

Output of Minimum Length Subarray Sum

What is the output of this C# code that finds the minimum length of a contiguous subarray with sum >= 7?

DSA C#

int[] nums = {2,3,1,2,4,3};
int target = 7;
int minLength = int.MaxValue;
int sum = 0, left = 0;
for (int right = 0; right < nums.Length; right++) {
    sum += nums[right];
    while (sum >= target) {
        minLength = Math.Min(minLength, right - left + 1);
        sum -= nums[left];
        left++;
    }
}
System.Console.WriteLine(minLength == int.MaxValue ? 0 : minLength);

A 4

B 3

C 2

D 1

💡 Hint

Check subarrays with sums >= 7 and find the smallest length.

The subarray [4,3] has sum 7 and length 2, which is the smallest possible length meeting the condition.

🔧 Debug

advanced

Identify the Error in Sliding Window Maximum Code

What error does this C# code produce when trying to find the maximum value in each sliding window of size 3?

DSA C#

int[] nums = {1,3,-1,-3,5,3,6,7};
int k = 3;
List<int> result = new List<int>();
for (int i = 0; i <= nums.Length - k; i++) {
    int max = int.MinValue;
    for (int j = i; j < i + k; j++) {
        if (nums[j] > max) max = nums[j];
    }
    result.Add(max);
}
System.Console.WriteLine(string.Join(",", result));

A No error; output is '3,3,5,5,6,7'

B IndexOutOfRangeException at line with nums[j]

C NullReferenceException on result.Add(max)

D Compilation error due to missing semicolon

💡 Hint

Check the loop boundaries and indexing carefully.

The code correctly iterates over all windows of size 3 and finds the max in each window. It produces output '3,3,5,5,6,7' without errors.

❓ Predict Output

advanced

Output of Count of Subarrays with Sum Equals K

What is the output of this C# code that counts the number of continuous subarrays whose sum equals 3?

DSA C#

int[] nums = {1,1,1};
int k = 3;
int count = 0;
for (int start = 0; start < nums.Length; start++) {
    int sum = 0;
    for (int end = start; end < nums.Length; end++) {
        sum += nums[end];
        if (sum == k) count++;
    }
}
System.Console.WriteLine(count);

A 0

B 3

C 1

D 2

💡 Hint

Consider all subarrays and count those with sum exactly 3.

There are three continuous subarrays whose sum equals 3: [1,1,1], [1,1,1] starting at different indices (actually, the subarrays are [1,1,1], [1,1], and [1,1] but sum 3 only for the full array). Actually, the correct count is 1.

🧠 Conceptual

expert

Minimum Window Substring Concept

Given a string S and a string T, which sliding window approach correctly finds the minimum window in S which contains all characters of T?

A Sort both strings and compare characters to find minimum window.

B Move left pointer forward until all characters in T are included, then expand right pointer to find larger windows.

C Use two pointers moving simultaneously at the same speed to find windows containing T.

D Expand right pointer to include characters until all in T are covered, then move left pointer to shrink window while still covering T, update minimum window size accordingly.

💡 Hint

Think about expanding and shrinking the window to cover all required characters efficiently.

The correct approach is to expand the right pointer to include all required characters, then shrink from the left to find the smallest window covering T.

Practice

1. What is the main purpose of the sliding window technique when working with arrays?

easy

A. To efficiently find subarray sums or properties without recalculating everything each time

B. To sort the array 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 calculate values like sums or averages efficiently.

2. Step 2: Identify the purpose

   It avoids recalculating the sum or property for each new window by updating the previous result, making it efficient.

3. Final Answer:

   To efficiently find subarray sums or properties without recalculating everything each time -> Option A

4. Quick Check:

   Sliding window = efficient subarray calculation [OK]

Hint: Think of a moving window updating results fast [OK]

Common Mistakes:

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

2. Which of the following is the correct syntax to start a sliding window loop of size k over an array arr in C#?

easy

A. for (int i = 1; i <= arr.Length - k; i++)

B. for (int i = 0; i <= arr.Length - k; i++)

C. for (int i = k; i < arr.Length; i++)

D. for (int i = 0; i < arr.Length + k; i++)

Solution

1. Step 1: Determine valid window start indices

   The window of size k can start at index 0 up to index arr.Length - k to avoid overflow.

2. Step 2: Check loop condition

   The loop must run while i <= arr.Length - k to include the last valid window.

3. Final Answer:

   for (int i = 0; i <= arr.Length - k; i++) -> Option B

4. Quick Check:

   Loop runs from 0 to arr.Length - k [OK]

Hint: Window ends at arr.Length - k index [OK]

Common Mistakes:

• Using < instead of <= causing last window skip
• Starting loop at 1 instead of 0
• Looping beyond array length causing errors

3. What is the output of the following C# code?

int[] arr = {1, 3, 2, 6, -1, 4, 1, 8, 2};
int k = 5;
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;
}
Console.WriteLine(maxSum);

medium

A. 16

B. 17

C. 18

D. 20

Solution

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

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

2. Step 2: Slide window and update sums

   Next windows and sums: - 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
• Starting loop from wrong index
• Incorrect initial sum calculation

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

int maxSum = 0;
int windowSum = 0;
for (int i = 0; i < arr.Length; i++) {
    windowSum += arr[i];
    if (i >= k) {
        windowSum -= arr[i - k];
        if (windowSum > maxSum)
            maxSum = windowSum;
    }
}
Console.WriteLine(maxSum);

medium

A. maxSum should be initialized to int.MinValue to handle negative sums

B. The if condition should be i > k instead of i >= k

C. The loop should start from i = k instead of 0

D. windowSum should be reset to 0 inside the loop

Solution

1. Step 1: Analyze maxSum initialization

   maxSum is 0 initially, which fails if all sums are negative because maxSum will never update.

2. Step 2: Correct initialization for negative values

   Initialize maxSum to int.MinValue to correctly track maximum sum even if negative.

3. Final Answer:

   maxSum should be initialized to int.MinValue to handle negative sums -> Option A

4. Quick Check:

   maxSum init = int.MinValue for negatives [OK]

Hint: Use int.MinValue for max tracking with negatives [OK]

Common Mistakes:

• Initializing maxSum to 0 causes wrong max for negative arrays
• Changing loop start incorrectly
• Resetting windowSum inside loop breaks sliding window

5. Given an array of integers, write a sliding window approach to find the length of the longest subarray with sum less than or equal to S. Which of the following describes the correct approach?

hard

A. Use a stack to store elements and pop when sum exceeds S

B. Sort the array and use binary search to find subarrays with sum ≤ S

C. Calculate sum of all subarrays and pick the longest with sum ≤ S

D. Use two pointers to expand and shrink the window, updating sum and max length accordingly

Solution

1. Step 1: Use two pointers to represent window boundaries

   Start both pointers at the beginning and expand the right pointer to include elements while sum ≤ S.

2. Step 2: Shrink window from left when sum exceeds S

   If sum > S, move left pointer forward subtracting elements until sum ≤ S again, tracking max length.

3. Final Answer:

   Use two pointers to expand and shrink the window, updating sum and max length accordingly -> Option D

4. Quick Check:

   Two-pointer sliding window for variable length subarray [OK]

Hint: Expand right, shrink left to keep sum ≤ S [OK]

Common Mistakes:

• Sorting array breaks original order needed
• Checking all subarrays is inefficient
• Using stack is not suitable for sum constraints