Trapping Rain Water Problem in DSA Python - Build from Scratch

Trapping Rain Water Problem

📖 Scenario: Imagine a street with buildings of different heights. When it rains, water gets trapped between these buildings. We want to find out how much water is trapped after the rain stops.

🎯 Goal: Build a program that calculates the total amount of water trapped between buildings represented by their heights.

📋 What You'll Learn

Create a list called heights with exact building heights

Create two lists called left_max and right_max to store maximum heights from left and right

Use a loop to fill left_max and right_max

Calculate trapped water using the minimum of left_max and right_max for each building

Print the total trapped water

💡 Why This Matters

🌍 Real World

This problem models how water collects in valleys between buildings or hills, useful in urban planning and flood prediction.

💼 Career

Understanding this problem helps in software roles involving algorithms, problem solving, and optimization.

1

Create the building heights list

Create a list called heights with these exact values: [0, 2, 0, 3, 0, 1, 0, 4, 0, 2]

DSA Python

# Create the list of building heights
# Your code here

Hint

Use square brackets [] to create the list and separate numbers with commas.

2

Create left_max and right_max lists

Create two lists called left_max and right_max with the same length as heights, filled with zeros

DSA Python

heights = [0, 2, 0, 3, 0, 1, 0, 4, 0, 2]
# Create left_max and right_max lists filled with zeros
# Your code here

Hint

Use len(heights) to get the length and multiply a list with zero to create the lists.

3

Fill left_max and right_max lists

Use a for loop with variable i from 1 to len(heights) - 1 to fill left_max where each element is the maximum of left_max[i-1] and heights[i-1]. Then use a for loop with variable i from len(heights) - 2 down to 0 to fill right_max where each element is the maximum of right_max[i+1] and heights[i+1].

DSA Python

heights = [0, 2, 0, 3, 0, 1, 0, 4, 0, 2]
left_max = [0] * len(heights)
right_max = [0] * len(heights)
# Fill left_max and right_max lists using for loops
# Your code here

Hint

Use range with start, stop, and step to loop forward and backward.

4

Calculate and print total trapped water

Create a variable called total_water and set it to 0. Use a for loop with variable i from 0 to len(heights) - 1 to add to total_water the difference between the minimum of left_max[i] and right_max[i] and heights[i]. Then print total_water.

DSA Python

heights = [0, 2, 0, 3, 0, 1, 0, 4, 0, 2]
left_max = [0] * len(heights)
right_max = [0] * len(heights)

for i in range(1, len(heights)):
    left_max[i] = max(left_max[i-1], heights[i-1])

for i in range(len(heights) - 2, -1, -1):
    right_max[i] = max(right_max[i+1], heights[i+1])

# Calculate total trapped water and print it
# Your code here

Hint

Use min to find the smaller of two values and add the difference only if it is positive.

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