Added tasks 53, 54, 55, 56.

Author: ThanhNIT

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

@@ -0,0 +1,22 @@
+package g0001_0100.s0053_maximum_subarray
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming
+// #Divide_and_Conquer #Data_Structure_I_Day_1_Array #Dynamic_Programming_I_Day_5
+// #Udemy_Famous_Algorithm #2022_08_29_Time_662_ms_(82.48%)_Space_97.8_MB_(24.28%)
+
+class Solution {
+    fun maxSubArray(nums: IntArray): Int {
+        var nextMax = nums[0]
+        var curMax = nums[0]
+        for (i in 1 until nums.size) {
+            nextMax += nums[i]
+            if (nextMax < nums[i]) {
+                nextMax = nums[i]
+            }
+            if (nextMax > curMax) {
+                curMax = nextMax
+            }
+        }
+        return curMax
+    }
+}

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

@@ -0,0 +1,34 @@
+53\. Maximum Subarray
+
+Medium
+
+Given an integer array `nums`, find the contiguous subarray (containing at least one number) which has the largest sum and return _its sum_.
+
+A **subarray** is a **contiguous** part of an array.
+
+**Example 1:**
+
+**Input:** nums = [-2,1,-3,4,-1,2,1,-5,4]
+
+**Output:** 6
+
+**Explanation:** [4,-1,2,1] has the largest sum = 6.
+
+**Example 2:**
+
+**Input:** nums = [1]
+
+**Output:** 1
+
+**Example 3:**
+
+**Input:** nums = [5,4,-1,7,8]
+
+**Output:** 23
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>4</sup> <= nums[i] <= 10<sup>4</sup></code>
+
+**Follow up:** If you have figured out the `O(n)` solution, try coding another solution using the **divide and conquer** approach, which is more subtle.

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

@@ -0,0 +1,40 @@
+package g0001_0100.s0054_spiral_matrix
+
+// #Medium #Top_Interview_Questions #Array #Matrix #Simulation #Programming_Skills_II_Day_8
+// #Level_2_Day_1_Implementation/Simulation #Udemy_2D_Arrays/Matrix
+// #2022_08_29_Time_224_ms_(62.50%)_Space_34.4_MB_(63.36%)
+
+class Solution {
+    fun spiralOrder(matrix: Array<IntArray>): List<Int> {
+        val list: MutableList<Int> = ArrayList()
+        var r = 0
+        var c = 0
+        var bigR = matrix.size - 1
+        var bigC: Int = matrix[0].size - 1
+        while (r <= bigR && c <= bigC) {
+            for (i in c..bigC) {
+                list.add(matrix[r][i])
+            }
+            r++
+            for (i in r..bigR) {
+                list.add(matrix[i][bigC])
+            }
+            bigC--
+            run {
+                var i = bigC
+                while (i >= c && r <= bigR) {
+                    list.add(matrix[bigR][i])
+                    i--
+                }
+            }
+            bigR--
+            var i = bigR
+            while (i >= r && c <= bigC) {
+                list.add(matrix[i][c])
+                i--
+            }
+            c++
+        }
+        return list
+    }
+}

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

@@ -0,0 +1,28 @@
+54\. Spiral Matrix
+
+Medium
+
+Given an `m x n` `matrix`, return _all elements of the_ `matrix` _in spiral order_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg)
+
+**Input:** matrix = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [1,2,3,6,9,8,7,4,5]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral.jpg)
+
+**Input:** matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+
+**Output:** [1,2,3,4,8,12,11,10,9,5,6,7]
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 10`
+*   `-100 <= matrix[i][j] <= 100`

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

@@ -0,0 +1,42 @@
+package g0001_0100.s0055_jump_game
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Dynamic_Programming #Greedy
+// #Algorithm_II_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_4 #Udemy_Arrays
+// #2022_08_29_Time_670_ms_(66.67%)_Space_71.2_MB_(44.45%)
+
+class Solution {
+    fun canJump(nums: IntArray): Boolean {
+        val sz = nums.size
+        // we set 1 so it won't break on the first iteration
+        var tmp = 1
+        for (i in 0 until sz) {
+            // we always deduct tmp for every iteration
+            tmp--
+            if (tmp < 0) {
+                // if from previous iteration tmp is already 0, it will be <0 here
+                // leading to false value
+                return false
+            }
+            // we get the maximum value because this value is supposed
+            // to be our iterator, if both values are 0, then the next
+            // iteration we will return false
+            // if either both or one of them are not 0 then we will keep doing this and check.
+
+            // We can stop the whole iteration with this condition. without this condition the code
+            // runs in 2ms 79.6%, adding this condition improves the performance into 1ms 100%
+            // because if the test case jump value is quite large, instead of just iterate, we can
+            // just check using this condition
+            // example: [10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] -> we can just jump to the end without
+            // iterating whole array
+            tmp = Math.max(tmp, nums[i])
+            if (i + tmp >= sz - 1) {
+                return true
+            }
+        }
+        // we can just return true at the end, because if tmp is 0 on previous
+        // iteration,
+        // even though the next iteration index is the last one, it will return false under the
+        // tmp<0 condition
+        return true
+    }
+}

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

@@ -0,0 +1,28 @@
+55\. Jump Game
+
+Medium
+
+You are given an integer array `nums`. You are initially positioned at the array's **first index**, and each element in the array represents your maximum jump length at that position.
+
+Return `true` _if you can reach the last index, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** nums = [2,3,1,1,4]
+
+**Output:** true
+
+**Explanation:** Jump 1 step from index 0 to 1, then 3 steps to the last index.
+
+**Example 2:**
+
+**Input:** nums = [3,2,1,0,4]
+
+**Output:** false
+
+**Explanation:** You will always arrive at index 3 no matter what. Its maximum jump length is 0, which makes it impossible to reach the last index.
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>4</sup></code>
+*   <code>0 <= nums[i] <= 10<sup>5</sup></code>

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

@@ -0,0 +1,32 @@
+package g0001_0100.s0056_merge_intervals
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Sorting
+// #Data_Structure_II_Day_2_Array #Level_2_Day_17_Interval #Udemy_2D_Arrays/Matrix
+// #2022_08_29_Time_323_ms_(99.68%)_Space_43_MB_(99.04%)
+
+import java.util.Arrays
+
+class Solution {
+    fun merge(intervals: Array<IntArray>): Array<IntArray> {
+        Arrays.sort(
+            intervals
+        ) { a: IntArray, b: IntArray ->
+            Integer.compare(
+                a[0],
+                b[0]
+            )
+        }
+        val list: MutableList<IntArray> = ArrayList()
+        var current = intervals[0]
+        list.add(current)
+        for (next in intervals) {
+            if (current[1] >= next[0]) {
+                current[1] = Math.max(current[1], next[1])
+            } else {
+                current = next
+                list.add(current)
+            }
+        }
+        return list.toTypedArray()
+    }
+}

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

@@ -0,0 +1,27 @@
+56\. Merge Intervals
+
+Medium
+
+Given an array of `intervals` where <code>intervals[i] = [start<sub>i</sub>, end<sub>i</sub>]</code>, merge all overlapping intervals, and return _an array of the non-overlapping intervals that cover all the intervals in the input_.
+
+**Example 1:**
+
+**Input:** intervals = [[1,3],[2,6],[8,10],[15,18]]
+
+**Output:** [[1,6],[8,10],[15,18]]
+
+**Explanation:** Since intervals [1,3] and [2,6] overlap, merge them into [1,6].
+
+**Example 2:**
+
+**Input:** intervals = [[1,4],[4,5]]
+
+**Output:** [[1,5]]
+
+**Explanation:** Intervals [1,4] and [4,5] are considered overlapping.
+
+**Constraints:**
+
+*   <code>1 <= intervals.length <= 10<sup>4</sup></code>
+*   `intervals[i].length == 2`
+*   <code>0 <= start<sub>i</sub> <= end<sub>i</sub> <= 10<sup>4</sup></code>

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

@@ -0,0 +1,22 @@
+package g0001_0100.s0053_maximum_subarray
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun maxSubArray() {
+        assertThat(Solution().maxSubArray(intArrayOf(-2, 1, -3, 4, -1, 2, 1, -5, 4)), equalTo(6))
+    }
+
+    @Test
+    fun maxSubArray2() {
+        assertThat(Solution().maxSubArray(intArrayOf(1)), equalTo(1))
+    }
+
+    @Test
+    fun maxSubArray3() {
+        assertThat(Solution().maxSubArray(intArrayOf(5, 4, -1, 7, 8)), equalTo(23))
+    }
+}

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

@@ -0,0 +1,27 @@
+package g0001_0100.s0054_spiral_matrix
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun spiralOrder() {
+        assertThat(
+            Solution().spiralOrder(arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6), intArrayOf(7, 8, 9))),
+            equalTo(
+                intArrayOf(1, 2, 3, 6, 9, 8, 7, 4, 5).toList()
+            )
+        )
+    }
+
+    @Test
+    fun spiralOrder2() {
+        assertThat(
+            Solution().spiralOrder(arrayOf(intArrayOf(1, 2, 3, 4), intArrayOf(5, 6, 7, 8), intArrayOf(9, 10, 11, 12))),
+            equalTo(
+                intArrayOf(1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7).toList()
+            )
+        )
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+package g0001_0100.s0056_merge_intervals
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun merge() {
+        assertThat(
+            Solution().merge(arrayOf(intArrayOf(1, 3), intArrayOf(2, 6), intArrayOf(8, 10), intArrayOf(15, 18))),
+            equalTo(
+                arrayOf(intArrayOf(1, 6), intArrayOf(8, 10), intArrayOf(15, 18))
+            )
+        )
+    }
+
+    @Test
+    fun merge2() {
+        assertThat(
+            Solution().merge(arrayOf(intArrayOf(1, 4), intArrayOf(4, 5))),
+            equalTo(
+                arrayOf(intArrayOf(1, 5))
+            )
+        )
+    }
+}