Added tasks 39, 41, 42, 45.

Author: ThanhNIT

src/main/kotlin/g0001_0100/s0008_string_to_integer_atoi/Solution.kt

@@ -27,7 +27,7 @@ class Solution {
             var tem = input[i] - '0'
             tem = if (negativeSign) -tem else tem
             // avoid invalid number like 038
-            if (num == 0 && tem == '0'.code) {
+            if (num == 0 && tem == '0'.toInt()) {
                 i++
             } else if (num == Int.MIN_VALUE / 10 && tem <= -8 || num < Int.MIN_VALUE / 10) {
                 return Int.MIN_VALUE

src/main/kotlin/g0001_0100/s0039_combination_sum/Solution.kt

@@ -0,0 +1,29 @@
+package g0001_0100.s0039_combination_sum
+
+// #Medium #Top_100_Liked_Questions #Array #Backtracking #Algorithm_II_Day_10_Recursion_Backtracking
+// #Level_2_Day_20_Brute_Force/Backtracking #Udemy_Backtracking/Recursion
+// #2022_08_27_Time_317_ms_(86.85%)_Space_45.1_MB_(63.75%)
+
+class Solution {
+    fun combinationSum(candidates: IntArray, target: Int): List<List<Int>> {
+        val result = mutableListOf<List<Int>>()
+
+        fun backtrack(start: Int, case: MutableList<Int>, sum: Int) {
+            if (sum >= target) {
+                if (sum == target) {
+                    result.add(case.toList())
+                }
+                return
+            }
+
+            for (i in start until candidates.size) {
+                case.add(candidates[i])
+                backtrack(i, case, sum + candidates[i])
+                case.removeAt(case.size - 1)
+            }
+        }
+
+        backtrack(0, mutableListOf(), 0)
+        return result
+    }
+}

src/main/kotlin/g0001_0100/s0039_combination_sum/readme.md

@@ -0,0 +1,41 @@
+39\. Combination Sum
+
+Medium
+
+Given an array of **distinct** integers `candidates` and a target integer `target`, return _a list of all **unique combinations** of_ `candidates` _where the chosen numbers sum to_ `target`_._ You may return the combinations in **any order**.
+
+The **same** number may be chosen from `candidates` an **unlimited number of times**. Two combinations are unique if the frequency of at least one of the chosen numbers is different.
+
+It is **guaranteed** that the number of unique combinations that sum up to `target` is less than `150` combinations for the given input.
+
+**Example 1:**
+
+**Input:** candidates = [2,3,6,7], target = 7
+
+**Output:** [[2,2,3],[7]]
+
+**Explanation:** 
+2 and 3 are candidates, and 2 + 2 + 3 = 7. Note that 2 can be used multiple times.
+
+7 is a candidate, and 7 = 7. 
+
+These are the only two combinations.
+
+**Example 2:**
+
+**Input:** candidates = [2,3,5], target = 8
+
+**Output:** [[2,2,2,2],[2,3,3],[3,5]]
+
+**Example 3:**
+
+**Input:** candidates = [2], target = 1
+
+**Output:** []
+
+**Constraints:**
+
+*   `1 <= candidates.length <= 30`
+*   `1 <= candidates[i] <= 200`
+*   All elements of `candidates` are **distinct**.
+*   `1 <= target <= 500`

src/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt

@@ -0,0 +1,35 @@
+package g0001_0100.s0041_first_missing_positive
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Hash_Table #Udemy_Arrays
+// #2022_08_27_Time_345_ms_(100.00%)_Space_47.3_MB_(100.00%)
+
+class Solution {
+    fun firstMissingPositive(nums: IntArray): Int {
+        var noOne = true
+        for (i in 0..(nums.size - 1)) {
+            if (noOne && nums[i] == 1) {
+                noOne = false
+            } else if (nums[i] <= 0) {
+                nums[i] = 1
+            }
+        }
+        if (noOne) {
+            return 1
+        }
+        var high = 0
+        var k: Int
+        for (x in nums) {
+            k = kotlin.math.abs(x)
+            high = kotlin.math.max(high, k)
+            if (k - 1 < nums.size) {
+                nums[k - 1] = -1 * kotlin.math.abs(nums[k - 1])
+            }
+        }
+        for (i in nums.indices) {
+            if (nums[i] > 0) {
+                return i + 1
+            }
+        }
+        return high + 1
+    }
+}

src/main/kotlin/g0001_0100/s0041_first_missing_positive/readme.md

@@ -0,0 +1,36 @@
+41\. First Missing Positive
+
+Hard
+
+Given an unsorted integer array `nums`, return the smallest missing positive integer.
+
+You must implement an algorithm that runs in `O(n)` time and uses constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [1,2,0]
+
+**Output:** 3
+
+**Explanation:** The numbers in the range [1,2] are all in the array.
+
+**Example 2:**
+
+**Input:** nums = [3,4,-1,1]
+
+**Output:** 2
+
+**Explanation:** 1 is in the array but 2 is missing.
+
+**Example 3:**
+
+**Input:** nums = [7,8,9,11,12]
+
+**Output:** 1
+
+**Explanation:** The smallest positive integer 1 is missing.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>

src/main/kotlin/g0001_0100/s0042_trapping_rain_water/Solution.kt

@@ -0,0 +1,36 @@
+package g0001_0100.s0042_trapping_rain_water
+
+// #Hard #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming #Two_Pointers
+// #Stack #Monotonic_Stack #Dynamic_Programming_I_Day_9 #Udemy_Two_Pointers
+// #2022_08_27_Time_196_ms_(100.00%)_Space_36.9_MB_(98.52%)
+
+class Solution {
+    fun trap(height: IntArray): Int {
+        val size = height.size
+        var maxLeft = 0
+        var maxRight = 0
+        var totalWater = 0
+        var leftPtr = 0
+        var rightPtr = size - 1
+
+        while (leftPtr < rightPtr) {
+            if (height[leftPtr] <= height[rightPtr]) {
+                if (maxLeft > height[leftPtr]) {
+                    totalWater = totalWater + maxLeft - height[leftPtr]
+                } else {
+                    maxLeft = height[leftPtr]
+                }
+                ++leftPtr
+            } else {
+                if (maxRight > height[rightPtr]) {
+                    totalWater = totalWater + maxRight - height[rightPtr]
+                } else {
+                    maxRight = height[rightPtr]
+                }
+                --rightPtr
+            }
+        }
+
+        return totalWater
+    }
+}

src/main/kotlin/g0001_0100/s0042_trapping_rain_water/readme.md

@@ -0,0 +1,27 @@
+42\. Trapping Rain Water
+
+Hard
+
+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:**
+
+![](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`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   <code>0 <= height[i] <= 10<sup>5</sup></code>

src/main/kotlin/g0001_0100/s0045_jump_game_ii/Solution.kt

@@ -0,0 +1,23 @@
+package g0001_0100.s0045_jump_game_ii
+
+// #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Greedy
+// #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_4
+// #2022_08_27_Time_231_ms_(98.08%)_Space_36.8_MB_(100.00%)
+
+class Solution {
+    fun jump(nums: IntArray): Int {
+        var jumps = 0
+        var minJump = 0
+        var maxJump = 0
+
+        while (maxJump < nums.lastIndex) {
+            var nextJump = 0
+            for (i in minJump..maxJump) nextJump = maxOf(nextJump, i + nums[i])
+            minJump = maxJump + 1
+            maxJump = nextJump
+            jumps++
+        }
+
+        return jumps
+    }
+}

src/main/kotlin/g0001_0100/s0045_jump_game_ii/readme.md

@@ -0,0 +1,30 @@
+45\. Jump Game II
+
+Medium
+
+Given an array of non-negative integers `nums`, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Your goal is to reach the last index in the minimum number of jumps.
+
+You can assume that you can always reach the last index.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** 2
+
+**Explanation:** The minimum number of jumps to reach the last index is 2. Jump 1 step from index 0 to 1, then 3 steps to the last index.
+
+**Example 2:**
+
+**Input:** nums = [2,3,0,1,4]
+
+**Output:** 2
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   `0 <= nums[i] <= 1000`

src/test/kotlin/g0001_0100/s0039_combination_sum/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0039_combination_sum
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun combinationSum() {
+        assertThat(Solution().combinationSum(intArrayOf(2, 3, 6, 7), 7), equalTo(arrayOf(intArrayOf(2, 2, 3).toList(), intArrayOf(7).toList()).toList()))
+    }
+
+    @Test
+    fun combinationSum2() {
+        assertThat(Solution().combinationSum(intArrayOf(2, 3, 5), 8), equalTo(arrayOf(intArrayOf(2, 2, 2, 2).toList(), intArrayOf(2, 3, 3).toList(), intArrayOf(3, 5).toList()).toList()))
+    }
+
+    @Test
+    fun combinationSum3() {
+        assertThat(Solution().combinationSum(intArrayOf(2), 1), equalTo(emptyArray<Int>().toList()))
+    }
+}

src/test/kotlin/g0001_0100/s0041_first_missing_positive/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0001_0100.s0041_first_missing_positive
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun firstMissingPositive() {
+        assertThat(Solution().firstMissingPositive(intArrayOf(1, 2, 0)), equalTo(3))
+    }
+
+    @Test
+    fun firstMissingPositive2() {
+        assertThat(Solution().firstMissingPositive(intArrayOf(3, 4, -1, 1)), equalTo(2))
+    }
+
+    @Test
+    fun firstMissingPositive3() {
+        assertThat(Solution().firstMissingPositive(intArrayOf(7, 8, 9, 11, 12)), equalTo(1))
+    }
+}

src/test/kotlin/g0001_0100/s0042_trapping_rain_water/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0001_0100.s0042_trapping_rain_water
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun trap() {
+        assertThat(Solution().trap(intArrayOf(0, 1, 0, 2, 1, 0, 1, 3, 2, 1, 2, 1)), equalTo(6))
+    }
+
+    @Test
+    fun trap2() {
+        assertThat(Solution().trap(intArrayOf(4, 2, 0, 3, 2, 5)), equalTo(9))
+    }
+}

src/test/kotlin/g0001_0100/s0045_jump_game_ii/SolutionTest.kt

@@ -0,0 +1,17 @@
+package g0001_0100.s0045_jump_game_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun jump() {
+        assertThat(Solution().jump(intArrayOf(2, 3, 1, 1, 4)), equalTo(2))
+    }
+
+    @Test
+    fun jump2() {
+        assertThat(Solution().jump(intArrayOf(2, 3, 0, 1, 4)), equalTo(2))
+    }
+}