42: Trapping Rain Water

Author: emanuelschmoczer

README.md

@@ -10,6 +10,7 @@ My solutions to LeetCode problems in Kotlin.
 |                [5](https://leetcode.com/problems/longest-palindromic-substring/)                 |         [Longest Palindromic Substring](src/main/kotlin/com/schmoczer/leetcode/_0005/LongestPalindromicSubstring.kt)         |   Medium   |
 |                    [8](https://leetcode.com/problems/string-to-integer-atoi/)                    |                 [String to Integer (atoi)](src/main/kotlin/com/schmoczer/leetcode/_0008/StringToInteger.kt)                  |   Medium   |
 |                      [20](https://leetcode.com/problems/valid-parentheses/)                      |                    [Valid Parentheses](src/main/kotlin/com/schmoczer/leetcode/_0020/ValidParentheses.kt)                     |    Easy    |
+|                     [42](https://leetcode.com/problems/trapping-rain-water/)                     |                   [Trapping Rain Water](src/main/kotlin/com/schmoczer/leetcode/_0042/TrappingRainWater.kt)                   |    Hard    |
 |                       [49](https://leetcode.com/problems/group-anagrams/)                        |                       [Group Anagrams](src/main/kotlin/com/schmoczer/leetcode/_0049/GroupAnagrams.kt)                        |   Medium   |
 |                      [125](https://leetcode.com/problems/valid-palindrome/)                      |                     [Valid Palindrome](src/main/kotlin/com/schmoczer/leetcode/_0125/ValidPalindrome.kt)                      |    Easy    |
 |                 [151](https://leetcode.com/problems/reverse-words-in-a-string/)                  |              [Reverse Words in a String](src/main/kotlin/com/schmoczer/leetcode/_0151/ReverseWordsInString.kt)               |   Medium   |

src/main/kotlin/com/schmoczer/leetcode/_0042/README.md

@@ -0,0 +1,22 @@
+# Trapping Rain Water
+
+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.
+
+Example 1:
+
+> Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
+>
+> Output: 6
+
+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`

src/main/kotlin/com/schmoczer/leetcode/_0042/TrappingRainWater.kt

@@ -0,0 +1,56 @@
+package com.schmoczer.leetcode._0042
+
+import kotlin.math.max
+import kotlin.math.min
+
+class TrappingRainWater {
+    // Approach 1: bruteforce
+    fun trap1(height: IntArray): Int {
+        if (height.size < 3) {
+            return 0
+        }
+        var water = 0
+        var leftHeight = height.first()
+        var rightHeight = height.copyOfRange(2, height.size).max()
+        for (i in 1 until height.size - 1) {
+            val currentHeight = height[i]
+            height[i - 1].let {
+                if (it > leftHeight) {
+                    leftHeight = it
+                }
+            }
+            if (currentHeight == rightHeight) {
+                rightHeight = height.copyOfRange(i + 1, height.size).max()
+            }
+            val lowest = min(leftHeight, rightHeight)
+            if (lowest > currentHeight) {
+                water += lowest - currentHeight
+            }
+        }
+        return water
+    }
+
+    // Approach 2: 2 pointers, Runtime 1ms Beats 100.00%
+    fun trap(height: IntArray): Int {
+        if (height.size < 3) {
+            return 0
+        }
+        var water = 0
+        var leftIndex = 0
+        var rightIndex = height.size - 1
+        var leftHeight = 0
+        var rightHeight = 0
+        while (leftIndex < rightIndex) {
+            if (height[leftIndex] < height[rightIndex]) {
+                leftHeight = max(leftHeight, height[leftIndex])
+                water += leftHeight - height[leftIndex]
+                leftIndex++
+            } else {
+                rightHeight = max(rightHeight, height[rightIndex])
+                water += rightHeight - height[rightIndex]
+                rightIndex--
+            }
+        }
+        return water
+    }
+}

src/test/kotlin/com/schmoczer/leetcode/_0042/TrappingRainWaterTests.kt

@@ -0,0 +1,28 @@
+package com.schmoczer.leetcode._0042
+
+import org.junit.jupiter.api.BeforeEach
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class TrappingRainWaterTests {
+    private lateinit var sut: TrappingRainWater
+
+    @BeforeEach
+    fun setUp() {
+        sut = TrappingRainWater()
+    }
+
+    @Test
+    fun `0,1,0,2,1,0,1,3,2,1,2,1 traps 6 water`() {
+        val input = intArrayOf(0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1)
+
+        assertEquals(6, sut.trap(input))
+    }
+
+    @Test
+    fun `4,2,0,3,2,5 traps 9 water`() {
+        val input = intArrayOf(4, 2, 0, 3, 2, 5)
+
+        assertEquals(9, sut.trap(input))
+    }
+}