Trapping Rain Water Problem in DSA C# - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the total trapped water variable.

DSA C#

int totalWater = [1];

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

A0

B1

C-1

Dheight.Length

Attempts:

3 left

💡 Hint

Common Mistakes

Starting totalWater with 1 or negative values causes wrong results.

We start counting trapped water from zero because initially no water is trapped.

2fill in blank

medium

Complete the code to create an array to store the maximum height to the left of each bar.

DSA C#

int[] leftMax = new int[[1]];

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

AtotalWater

Bheight.Length

C0

Dheight[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using zero or the value of the first bar as the array size causes errors.

The leftMax array must have the same length as the height array to store max heights for each position.

3fill in blank

hard

Fix the error in the loop that fills the leftMax array with the maximum height to the left of each bar.

DSA C#

for (int i = 1; i < height.Length; i++) {
    leftMax[i] = Math.Max(leftMax[i - 1], [1]);
}

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

AleftMax[i]

Bi

Cheight[i]

Dheight[0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using the index i or leftMax[i] instead of height[i] causes wrong max calculation.

We compare the previous max with the current bar's height to update leftMax.

4fill in blank

hard

Fill both blanks to calculate trapped water at each bar using leftMax and rightMax arrays.

DSA C#

for (int i = 0; i < height.Length; i++) {
    int waterLevel = Math.Min([1], [2]);
    if (waterLevel > height[i]) {
        totalWater += waterLevel - height[i];
    }
}

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

AleftMax[i]

BrightMax[i]

Cheight[i]

DtotalWater

Attempts:

3 left

💡 Hint

Common Mistakes

Using height[i] or totalWater instead of leftMax[i] or rightMax[i] causes wrong water level.

The water trapped depends on the smaller of the max heights on left and right sides.

5fill in blank

hard

Fill all three blanks to create the rightMax array by iterating from the end and updating max heights.

DSA C#

int[] rightMax = new int[height.Length];
rightMax[height.Length - 1] = height[height.Length - 1];
for (int i = height.Length - 2; i >= 0; i--) {
    rightMax[i] = Math.[1](rightMax[i + 1], [2]);
}

// Return the total trapped water
return [3];

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

AMax

Bheight[i]

CtotalWater

DMin

Attempts:

3 left

💡 Hint

Common Mistakes

Using Math.Min instead of Math.Max causes wrong max height calculation.

Returning height or rightMax instead of totalWater causes wrong output.

We use Math.Max to update rightMax with the max height seen so far from the right. Finally, we return totalWater.

Practice

1. What does the Trapping Rain Water problem ask you to find given an array of heights?

easy

A. The minimum height of the bars.

B. The maximum height of the bars.

C. The number of bars in the array.

D. The total amount of water that can be trapped between the bars.

Solution

1. Step 1: Understand the problem context

   The problem gives an array representing heights of bars and asks how much water can be trapped after raining.

2. Step 2: Identify the goal

   The goal is to calculate the total trapped water volume between bars, not just heights or counts.

3. Final Answer:

   The total amount of water that can be trapped between the bars. -> Option D

4. Quick Check:

   Trapping Rain Water = Total trapped water [OK]

Hint: Focus on trapped water volume, not bar heights or counts [OK]

Common Mistakes:

• Confusing trapped water with maximum bar height
• Counting bars instead of calculating water volume
• Ignoring the space between bars

2. Which of the following C# code snippets correctly initializes an array of heights for the Trapping Rain Water problem?

easy

A. int[] heights = new int[] {4, 2, 0, 3, 2, 5};

B. int heights = {4, 2, 0, 3, 2, 5};

C. int[] heights = (4, 2, 0, 3, 2, 5);

D. int heights[] = new int[6] {4, 2, 0, 3, 2, 5};

Solution

1. Step 1: Check array initialization syntax in C#

   Correct syntax uses int[] variable = new int[] {values};

2. Step 2: Validate each option

   int[] heights = new int[] {4, 2, 0, 3, 2, 5}; uses correct syntax; B and C have invalid syntax; D has incorrect array declaration style.

3. Final Answer:

   int[] heights = new int[] {4, 2, 0, 3, 2, 5}; -> Option A

4. Quick Check:

   C# array init = new int[] {values} [OK]

Hint: Use 'int[] arr = new int[] {values};' for array initialization [OK]

Common Mistakes:

• Missing 'new int[]' keyword
• Using parentheses instead of braces
• Incorrect array declaration syntax

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

int[] height = {0,1,0,2,1,0,1,3,2,1,2,1};
int trappedWater = Trap(height);
Console.WriteLine(trappedWater);

int Trap(int[] height) {
    int left = 0, right = height.Length - 1;
    int leftMax = 0, rightMax = 0;
    int water = 0;
    while (left < right) {
        if (height[left] < height[right]) {
            if (height[left] >= leftMax) leftMax = height[left];
            else water += leftMax - height[left];
            left++;
        } else {
            if (height[right] >= rightMax) rightMax = height[right];
            else water += rightMax - height[right];
            right--;
        }
    }
    return water;
}

medium

A. 7

B. 6

C. 5

D. 8

Solution

1. Step 1: Understand two-pointer approach in code

   Left and right pointers move inward, tracking max heights and accumulating trapped water.

2. Step 2: Trace the code with given input

   For input {0,1,0,2,1,0,1,3,2,1,2,1}, trapped water calculated is 6 units.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Two-pointer trap water = 6 [OK]

Hint: Use two-pointer method to sum trapped water efficiently [OK]

Common Mistakes:

• Miscounting trapped water units
• Confusing leftMax and rightMax updates
• Incorrect pointer movement logic

4. Identify the bug in the following C# code for the Trapping Rain Water problem:

int Trap(int[] height) {
    int left = 0, right = height.Length - 1;
    int leftMax = 0, rightMax = 0;
    int water = 0;
    while (left <= right) {
        if (height[left] < height[right]) {
            if (height[left] > leftMax) leftMax = height[left];
            else water += leftMax - height[left];
            left++;
        } else {
            if (height[right] > rightMax) rightMax = height[right];
            else water += rightMax - height[right];
            right--;
        }
    }
    return water;
}

medium

A. The loop condition should be 'left < right' instead of 'left <= right'.

B. The comparison operators for updating leftMax and rightMax should be '>=' instead of '>'.

C. The water accumulation should be outside the if-else blocks.

D. The initial values of leftMax and rightMax should be -1.

Solution

1. Step 1: Analyze loop condition impact

   Using 'left <= right' causes double counting when left equals right, leading to incorrect water calculation.

2. Step 2: Correct loop condition

   Changing to 'left < right' prevents overlap and fixes the bug.

3. Final Answer:

   The loop condition should be 'left < right' instead of 'left <= right'. -> Option A

4. Quick Check:

   Loop condition 'left < right' avoids double counting [OK]

Hint: Use strict less-than in loop to avoid double counting [OK]

Common Mistakes:

• Using <= causes overlap and wrong water sum
• Changing comparison operators unnecessarily
• Moving water calculation outside conditions

5. Given the height array {5, 2, 1, 2, 1, 5}, what is the total trapped rain water? Explain why the trapped water forms in this case.

hard

A. 10

B. 8

C. 14

D. 12

Solution

1. Step 1: Calculate trapped water at each position

   Left max array: [5,5,5,5,5,5], Right max array: [5,5,5,5,5,5]. Water trapped = min(leftMax, rightMax) - height at each index: positions 1=3, 2=4, 3=3, 4=4.

2. Step 2: Sum trapped water and explain formation

   Total trapped water = 3+4+3+4 = 14 units. Water forms because tall bars at ends trap water over lower bars inside.

3. Final Answer:

   14 -> Option C

4. Quick Check:

   Sum trapped water = 14 units [OK]

Hint: Use leftMax and rightMax arrays to find trapped water [OK]

Common Mistakes:

• Ignoring max heights on both sides
• Calculating trapped water incorrectly per position
• Forgetting to sum all trapped units