Trapping Rain Water Problem in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the total trapped water to zero.

DSA Python

water = [1]

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

A0

B1

CNone

D[]

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing water with 1 or None instead of 0.

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

2fill in blank

medium

Complete the code to find the maximum height to the left of the current bar.

DSA Python

left_max = max(height[:[1]])

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

Ai

Bi+1

Ci-1

Dlen(height)

Attempts:

3 left

💡 Hint

Common Mistakes

Using i+1 includes the current bar, which is incorrect.

We take all bars to the left of the current index i, so slicing up to i excludes the current bar.

3fill in blank

hard

Fix the error in the code to calculate trapped water at index i.

DSA Python

water += min(left_max, right_max) - [1]

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

Aleft_max

Bright_max

Cheight[i]

Dwater

Attempts:

3 left

💡 Hint

Common Mistakes

Subtracting left_max or right_max instead of height[i].

We subtract the height of the current bar to find how much water can be trapped above it.

4fill in blank

hard

Fill both blanks to complete the loop that iterates over the bars except the first and last.

DSA Python

for i in range([1], [2]):

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

A1

B0

Clen(height) - 1

Dlen(height)

Attempts:

3 left

💡 Hint

Common Mistakes

Starting from 0 or ending at len(height) includes bars that can't trap water.

We skip the first and last bars because they cannot trap water.

5fill in blank

hard

Fill all three blanks to complete the function that calculates trapped rain water.

DSA Python

def trap(height):
    water = [1]
    for i in range([2], [3]):
        left_max = max(height[:i])
        right_max = max(height[i+1:])
        water += min(left_max, right_max) - height[i]
    return water

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

A0

B1

Clen(height) - 1

Dlen(height)

Attempts:

3 left

💡 Hint

Common Mistakes

Incorrect loop range or water initialization.

The function initializes water to zero, loops from the second bar to the second last bar, and calculates trapped water correctly.

Practice

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

easy

A. The number of bars taller than a given height

B. The highest bar in the array

C. The total amount of water that can be trapped between the bars after raining

D. The sum of all bar heights

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 between them after rain.

2. Step 2: Identify the goal

   The goal is to calculate the total trapped water volume between bars, not just the tallest bar or sum of heights.

3. Final Answer:

   The total amount of water trapped between bars -> Option C

4. Quick Check:

   Trapped water = total water held between bars [OK]

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

Common Mistakes:

• Confusing trapped water with tallest bar height
• Summing bar heights instead of water trapped
• Ignoring spaces between bars where water collects

2. Which of the following Python code snippets correctly initializes two pointers for the two-pointer approach in the Trapping Rain Water problem?

easy

A. left, right = 0, len(height) - 1

B. left, right = 1, len(height)

C. left, right = 0, len(height)

D. left, right = -1, len(height) - 1

Solution

1. Step 1: Understand pointer initialization

   Two pointers start at the ends: left at 0, right at last index (length - 1).

2. Step 2: Check each option

   left, right = 0, len(height) - 1 correctly sets left=0 and right=len(height)-1. Others have invalid indices.

3. Final Answer:

   left, right = 0, len(height) - 1 -> Option A

4. Quick Check:

   Start pointers at array ends [OK]

Hint: Two pointers start at first and last index [OK]

Common Mistakes:

• Setting right pointer to len(height) (out of range)
• Starting left pointer at 1 instead of 0
• Using negative indices incorrectly

3. What is the output of the following Python code for trapping rain water?

def trap(height):
    left, right = 0, len(height) - 1
    left_max = right_max = 0
    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 += 1
        else:
            if height[right] >= right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1
    return water

print(trap([0,1,0,2,1,0,1,3,2,1,2,1]))

medium

A. 5

B. 6

C. 4

D. 7

Solution

1. Step 1: Trace pointers and water accumulation

   Using two pointers, water trapped is calculated by comparing left and right heights and updating max heights.

2. Step 2: Calculate trapped water for given input

   For input [0,1,0,2,1,0,1,3,2,1,2,1], total trapped water is 6 units.

3. Final Answer:

   6 -> Option B

4. Quick Check:

   Standard example result = 6 [OK]

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

Common Mistakes:

• Miscounting trapped water units
• Not updating max heights correctly
• Confusing left and right pointer moves

4. Find the error in this Python code snippet for the Trapping Rain Water problem:

def trap(height):
    left, right = 0, len(height) - 1
    left_max = right_max = 0
    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 += 1
        else:
            if height[right] > right_max:
                right_max = height[right]
            else:
                water += right_max - height[right]
            right -= 1
    return water

medium

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

B. The comparison operators '>' should be '>=' when updating max heights

C. The water accumulation formula is incorrect

D. The pointers should be initialized to 1 and len(height) - 2

Solution

1. Step 1: Analyze the loop condition

   The loop uses 'left <= right', which causes pointers to cross and double count or error.

2. Step 2: Correct loop condition

   Changing to 'left < right' prevents overlap and ensures correct water calculation.

3. Final Answer:

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

4. Quick Check:

   Loop ends before pointers cross [OK]

Hint: Use strict less than in loop to avoid pointer overlap [OK]

Common Mistakes:

• Using <= causes double counting
• Not updating max heights correctly
• Incorrect pointer initialization

5. Given the height array [4,2,0,3,2,5], what is the total trapped rain water? Use the two-pointer approach to solve.

hard

A. 7

B. 8

C. 6

D. 9

Solution

1. Step 1: Initialize pointers and max heights

   left=0, right=5, left_max=0, right_max=0, water=0.

2. Step 2: Move pointers and calculate trapped water

   Walk through: - left=0 (4), right=5 (5), left < right - height[left]

3. Final Answer:

   9 -> Option D

4. Quick Check:

   Sum trapped water units = 9 [OK]

Hint: Add water trapped at each step using max heights [OK]

Common Mistakes:

• Miscounting trapped water at zero height bars
• Not updating left_max and right_max correctly
• Stopping loop too early or late