feat: add Trapping Rain Water

Author: wislertt

.templates/leetcode/json/trapping_rain_water.json

@@ -0,0 +1,40 @@
+{
+    "problem_name": "trapping_rain_water",
+    "solution_class_name": "Solution",
+    "problem_number": "42",
+    "problem_title": "Trapping Rain Water",
+    "difficulty": "Hard",
+    "topics": "Array, Two Pointers, Dynamic Programming, Stack, Monotonic Stack",
+    "tags": ["grind-75"],
+    "readme_description": "Given `n` non-negative integers representing an elevation map where the width of each bar is `1`, compute how much water it can trap after raining.",
+    "readme_examples": [
+        {
+            "content": "![Example 1](https://assets.leetcode.com/uploads/2018/10/22/rainwatertrap.png)\n\n```\nInput: height = [0,1,0,2,1,0,1,3,2,1,2,1]\nOutput: 6\n```\n**Explanation:** The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped."
+        },
+        { "content": "```\nInput: height = [4,2,0,3,2,5]\nOutput: 9\n```" }
+    ],
+    "readme_constraints": "- `n == height.length`\n- `1 <= n <= 2 * 10^4`\n- `0 <= height[i] <= 10^5`",
+    "readme_additional": "",
+    "solution_imports": "",
+    "solution_methods": [
+        { "name": "trap", "parameters": "height: list[int]", "return_type": "int", "dummy_return": "0" }
+    ],
+    "test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .solution import Solution",
+    "test_class_name": "TrappingRainWater",
+    "test_helper_methods": [
+        { "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }
+    ],
+    "test_methods": [
+        {
+            "name": "test_trap",
+            "parametrize": "height, expected",
+            "parametrize_typed": "height: list[int], expected: int",
+            "test_cases": "[([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1], 6), ([4, 2, 0, 3, 2, 5], 9), ([3, 0, 2, 0, 4], 7), ([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1], 6)]",
+            "body": "result = self.solution.trap(height)\nassert result == expected"
+        }
+    ],
+    "playground_imports": "from solution import Solution",
+    "playground_test_case": "# Example test case\nheight = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]\nexpected = 6",
+    "playground_execution": "result = Solution().trap(height)\nresult",
+    "playground_assertion": "assert result == expected"
+}

Makefile

@@ -1,5 +1,5 @@
 PYTHON_VERSION = 3.13
-PROBLEM ?= largest_rectangle_in_histogram
+PROBLEM ?= trapping_rain_water
 FORCE ?= 0
 COMMA := ,
 

leetcode/trapping_rain_water/README.md

@@ -0,0 +1,37 @@
+# Trapping Rain Water
+
+**Difficulty:** Hard
+**Topics:** Array, Two Pointers, Dynamic Programming, Stack, Monotonic Stack
+**Tags:** grind-75
+
+**LeetCode:** [Problem 42](https://leetcode.com/problems/trapping-rain-water/description/)
+
+## Problem Description
+
+Given `n` non-negative integers representing an elevation map where the width of each bar is `1`, compute how much water it can trap after raining.
+
+## Examples
+
+### Example 1:
+
+![Example 1](https://assets.leetcode.com/uploads/2018/10/22/rainwatertrap.png)
+
+```
+Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+Output: 6
+```
+
+**Explanation:** The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped.
+
+### Example 2:
+
+```
+Input: height = [4,2,0,3,2,5]
+Output: 9
+```
+
+## Constraints
+
+- `n == height.length`
+- `1 <= n <= 2 * 10^4`
+- `0 <= height[i] <= 10^5`

leetcode/trapping_rain_water/__init__.py

@@ -0,0 +1,79 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "imports",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from solution import Solution"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "setup",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Example test case\n",
+    "height = [0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1]\n",
+    "expected = 6"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "execute",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "6"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "result = Solution().trap(height)\n",
+    "result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "test",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "assert result == expected"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "leetcode-py-py3.13",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

leetcode/trapping_rain_water/playground.ipynb

@@ -0,0 +1,52 @@
+# class Solution:
+#     # Time: O(n)
+#     # Space: O(1)
+#     def trap(self, height: list[int]) -> int:
+#         if not height:
+#             return 0
+
+#         left, right = 0, len(height) - 1
+#         left_max = right_max = 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
+
+
+class Solution:
+    # Time: O(n)
+    # Space: O(1)
+    def trap(self, height: list[int]) -> int:
+        if not height:
+            return 0
+
+        left, right = 0, len(height) - 1
+        left_max = right_max = 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

leetcode/trapping_rain_water/solution.py

@@ -0,0 +1,42 @@
+import pytest
+
+from leetcode_py.test_utils import logged_test
+
+from .solution import Solution
+
+
+class TestTrappingRainWater:
+    def setup_method(self):
+        self.solution = Solution()
+
+    @pytest.mark.parametrize(
+        "height, expected",
+        [
+            # Original examples
+            ([0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1], 6),
+            ([4, 2, 0, 3, 2, 5], 9),
+            ([3, 0, 2, 0, 4], 7),
+            # Edge cases
+            ([], 0),
+            ([1], 0),
+            ([1, 2], 0),
+            ([2, 1], 0),
+            # No water trapped
+            ([1, 2, 3, 4, 5], 0),
+            ([5, 4, 3, 2, 1], 0),
+            # Simple cases
+            ([3, 0, 3], 3),
+            ([2, 1, 2], 1),
+            ([5, 2, 7, 2, 6, 1, 5, 3, 2, 4], 14),
+            # All same height
+            ([3, 3, 3, 3], 0),
+            # Valley pattern
+            ([3, 2, 1, 2, 3], 4),
+            # Multiple peaks
+            ([0, 2, 0, 4, 0, 3, 0, 4, 0, 2, 0], 13),
+        ],
+    )
+    @logged_test
+    def test_trap(self, height: list[int], expected: int):
+        result = self.solution.trap(height)
+        assert result == expected