Trapping Rain Water Problem in DSA C - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of trapping rain water calculation using two-pointer approach

What is the output of the following C code that calculates trapped rain water using the two-pointer technique?

DSA C

#include <stdio.h>

int trap(int* height, int heightSize) {
    int left = 0, right = heightSize - 1;
    int left_max = 0, right_max = 0;
    int water = 0;
    while (left < right) {
        if (height[left] < height[right]) {
            if (height[left] >= left_max) left_max = height[left];
            else water += left_max - height[left];
            left++;
        } else {
            if (height[right] >= right_max) right_max = height[right];
            else water += right_max - height[right];
            right--;
        }
    }
    return water;
}

int main() {
    int height[] = {0,1,0,2,1,0,1,3,2,1,2,1};
    int size = sizeof(height)/sizeof(height[0]);
    printf("%d\n", trap(height, size));
    return 0;
}

A 6

B 5

C 7

D 8

💡 Hint

Think about how the two-pointer approach accumulates water by comparing left and right heights.

The two-pointer approach calculates trapped water by moving pointers inward and accumulating water where the current height is less than the max height seen so far on that side. For the given input, the total trapped water is 6 units.

🧠 Conceptual

intermediate

Understanding the role of max height arrays in trapping rain water

In the trapping rain water problem, why do we precompute arrays of maximum heights to the left and right of each position?

A To know the highest wall on both sides to calculate trapped water at each position

B To sort the heights for easier calculation

C To find the minimum height in the array

D To count the number of walls taller than current position

💡 Hint

Think about how trapped water depends on the tallest walls around a position.

Trapped water at a position depends on the minimum of the tallest walls to the left and right minus the height at that position. Precomputing max heights arrays helps find these values efficiently.

🔧 Debug

advanced

Identify the error in this trapping rain water implementation

What error does the following C code produce when run?

DSA C

#include <stdio.h>

int trap(int* height, int heightSize) {
    int left_max[heightSize];
    int right_max[heightSize];
    int water = 0;
    left_max[0] = height[0];
    for (int i = 1; i < heightSize; i++) {
        left_max[i] = (height[i] > left_max[i-1]) ? height[i] : left_max[i-1];
    }
    right_max[heightSize] = height[heightSize-1];
    for (int i = heightSize - 2; i >= 0; i--) {
        right_max[i] = (height[i] > right_max[i+1]) ? height[i] : right_max[i+1];
    }
    for (int i = 0; i < heightSize; i++) {
        water += (left_max[i] < right_max[i] ? left_max[i] : right_max[i]) - height[i];
    }
    return water;
}

int main() {
    int height[] = {4,2,0,3,2,5};
    int size = sizeof(height)/sizeof(height[0]);
    printf("%d\n", trap(height, size));
    return 0;
}

A Division by zero error

B Array index out of bounds error at right_max[heightSize]

C No error, outputs 9

D Segmentation fault due to null pointer

💡 Hint

Check array indexing carefully, especially at boundaries.

The code assigns right_max[heightSize] which is out of bounds since valid indices are 0 to heightSize-1. This causes undefined behavior or runtime error.

❓ Predict Output

advanced

Output of trapping rain water using stack approach

What is the output of this C code that calculates trapped rain water using a stack?

DSA C

#include <stdio.h>
#include <stdlib.h>

int trap(int* height, int heightSize) {
    int *stack = (int*)malloc(heightSize * sizeof(int));
    int top = -1;
    int water = 0;
    for (int i = 0; i < heightSize; i++) {
        while (top != -1 && height[i] > height[stack[top]]) {
            int top_height = height[stack[top--]];
            if (top == -1) break;
            int distance = i - stack[top] - 1;
            int bounded_height = (height[i] < height[stack[top]] ? height[i] : height[stack[top]]) - top_height;
            water += distance * bounded_height;
        }
        stack[++top] = i;
    }
    free(stack);
    return water;
}

int main() {
    int height[] = {0,2,0,3,0,1,0,4};
    int size = sizeof(height)/sizeof(height[0]);
    printf("%d\n", trap(height, size));
    return 0;
}

A 9

B 7

C 8

D 10

💡 Hint

Stack stores indices of bars; trapped water is calculated when a higher bar is found.

The stack approach calculates trapped water by popping lower bars and calculating bounded water between current and previous bars. For the input, total trapped water is 10 units.

🧠 Conceptual

expert

Time complexity analysis of trapping rain water algorithms

Which statement correctly describes the time complexity of the three common approaches to the trapping rain water problem: brute force, prefix/suffix max arrays, and two-pointer?

A Brute force is O(n^2), prefix/suffix max arrays is O(n^2), two-pointer is O(n)

B Brute force is O(n), prefix/suffix max arrays is O(n^2), two-pointer is O(n^2)

C Brute force is O(n^2), prefix/suffix max arrays is O(n), two-pointer is O(n)

D All three approaches have O(n) time complexity

💡 Hint

Consider how many times each element is processed in each approach.

Brute force checks max heights for each element scanning entire array, leading to O(n^2). Prefix/suffix max arrays precompute max heights in O(n) and then calculate water in O(n), total O(n). Two-pointer approach also runs in O(n) by scanning once from both ends.

Practice

1. What does the Trapping Rain Water problem aim 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 trapped between the bars after raining

Solution

1. Step 1: Understand the problem context

   The problem involves an array representing heights of bars where water can be trapped between them.

2. Step 2: Identify the goal

   The goal is to calculate how much water can be trapped after raining between these bars.

3. Final Answer:

   The total amount of water trapped between the bars after raining -> Option D

4. Quick Check:

   Trapping Rain Water = Total trapped water [OK]

Hint: Think of bars as walls holding water in between [OK]

Common Mistakes:

• Confusing trapped water with bar heights
• Calculating max or min height instead of trapped water
• Ignoring the space between bars

2. Which of the following C code snippets correctly declares an array to store bar heights for the Trapping Rain Water problem?

easy

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

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

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

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

Solution

1. Step 1: Check array declaration syntax in C

   Arrays are declared with type, name, and initializer list in braces {}.

2. Step 2: Validate each option

   int heights[] = {4, 2, 0, 3, 2, 5}; uses correct syntax: int heights[] = {4, 2, 0, 3, 2, 5}; Options A, B, D have syntax errors.

3. Final Answer:

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

4. Quick Check:

   Correct C array syntax = int heights[] = {4, 2, 0, 3, 2, 5}; [OK]

Hint: Use braces {} to initialize arrays in C [OK]

Common Mistakes:

• Using parentheses () instead of braces {}
• Missing array size or incorrect initializer syntax
• Using square brackets [] for initialization

3. What is the output of the following C code snippet that calculates trapped water?

int heights[] = {3, 0, 2, 0, 4};
int n = 5;
int left_max[5], right_max[5];
int water = 0;

// Calculate left max
left_max[0] = heights[0];
for (int i = 1; i < n; i++) {
    left_max[i] = (heights[i] > left_max[i-1]) ? heights[i] : left_max[i-1];
}

// Calculate right max
right_max[n-1] = heights[n-1];
for (int i = n-2; i >= 0; i--) {
    right_max[i] = (heights[i] > right_max[i+1]) ? heights[i] : right_max[i+1];
}

// Calculate trapped water
for (int i = 0; i < n; i++) {
    water += (left_max[i] < right_max[i] ? left_max[i] : right_max[i]) - heights[i];
}

printf("%d\n", water);

medium

A. 4

B. 6

C. 7

D. 5

Solution

1. Step 1: Calculate left_max and right_max arrays

   left_max = [3, 3, 3, 3, 4], right_max = [4, 4, 4, 4, 4]

2. Step 2: Calculate trapped water at each index

   Water trapped = sum of min(left_max[i], right_max[i]) - heights[i] = (3-3)+(3-0)+(3-2)+(3-0)+(4-4) = 0+3+1+3+0 = 7

3. Final Answer:

   7 -> Option C

4. Quick Check:

   Sum trapped water = 7 [OK]

Hint: Use left_max and right_max arrays to find trapped water fast [OK]

Common Mistakes:

• Mixing up left_max and right_max arrays
• Forgetting to subtract heights from min of max arrays
• Off-by-one errors in loops

4. Identify the bug in this C code snippet for calculating trapped rain water:

int trap(int* height, int heightSize) {
    int left_max[heightSize];
    int right_max[heightSize];
    int water = 0;

    left_max[0] = height[0];
    for (int i = 1; i < heightSize; i++) {
        left_max[i] = height[i] > left_max[i-1] ? height[i] : left_max[i-1];
    }

    right_max[heightSize-1] = height[heightSize-1];
    for (int i = heightSize-2; i >= 0; i--) {
        right_max[i] = height[i] > right_max[i+1] ? height[i] : right_max[i+1];
    }

    for (int i = 0; i < heightSize; i++) {
        water += (left_max[i] < right_max[i] ? left_max[i] : right_max[i]) - height[i];
    }

    return water;
}

medium

A. Incorrect comparison operator in left_max calculation

B. Using variable length arrays (VLA) which may not be supported

C. Wrong loop range in right_max calculation

D. Missing initialization of water variable

Solution

1. Step 1: Analyze array declarations

   The code uses int left_max[heightSize]; and int right_max[heightSize]; which are variable length arrays (VLA).

2. Step 2: Understand VLA support in C

   VLAs are optional in C11 and may not be supported by all compilers, causing portability issues or errors.

3. Final Answer:

   Using variable length arrays (VLA) which may not be supported -> Option B

4. Quick Check:

   VLAs may cause errors = Using variable length arrays (VLA) which may not be supported [OK]

Hint: Avoid VLAs; use dynamic memory or fixed size arrays [OK]

Common Mistakes:

• Assuming VLAs always work in all C compilers
• Ignoring compiler warnings about VLAs
• Confusing VLA issue with logic errors

5. Given the heights array {0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1}, what is the total trapped rain water using the two-pointer approach in C?

hard

A. 6

B. 5

C. 7

D. 8

Solution

1. Step 1: Understand two-pointer approach

   Use two pointers left and right starting at ends, track left_max and right_max, move pointers inward calculating trapped water.

2. Step 2: Dry run the array

   Heights: [0,1,0,2,1,0,1,3,2,1,2,1] Water trapped = 6 units after calculating min(left_max, right_max) - height at each step.

3. Final Answer:

   6 -> Option A

4. Quick Check:

   Two-pointer trapped water = 6 [OK]

Hint: Use two pointers and track max heights from both ends [OK]

Common Mistakes:

• Not updating left_max and right_max correctly
• Moving pointers incorrectly causing missed water
• Confusing two-pointer with prefix arrays method