Added tasks 62, 64, 70, 72.

Author: ThanhNIT

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

@@ -0,0 +1,23 @@
+package g0001_0100.s0062_unique_paths
+
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Math
+// #Combinatorics #Algorithm_II_Day_13_Dynamic_Programming #Dynamic_Programming_I_Day_15
+// #Level_1_Day_11_Dynamic_Programming #2022_08_30_Time_209_ms_(49.18%)_Space_33.5_MB_(60.44%)
+
+class Solution {
+    fun uniquePaths(m: Int, n: Int): Int {
+        val dp = Array(m) { IntArray(n) }
+        for (i in 0 until m) {
+            dp[i][0] = 1
+        }
+        for (j in 0 until n) {
+            dp[0][j] = 1
+        }
+        for (i in 1 until m) {
+            for (j in 1 until n) {
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+            }
+        }
+        return dp[m - 1][n - 1]
+    }
+}

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

@@ -0,0 +1,35 @@
+62\. Unique Paths
+
+Medium
+
+There is a robot on an `m x n` grid. The robot is initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any point in time.
+
+Given the two integers `m` and `n`, return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The test cases are generated so that the answer will be less than or equal to <code>2 * 10<sup>9</sup></code>.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2018/10/22/robot_maze.png)
+
+**Input:** m = 3, n = 7
+
+**Output:** 28
+
+**Example 2:**
+
+**Input:** m = 3, n = 2
+
+**Output:** 3
+
+**Explanation:** From the top-left corner, there are a total of 3 ways to reach the bottom-right corner: 
+
+1. Right -> Down -> Down 
+
+2. Down -> Down -> Right 
+
+3. Down -> Right -> Down
+
+**Constraints:**
+
+*   `1 <= m, n <= 100`

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

@@ -0,0 +1,27 @@
+package g0001_0100.s0064_minimum_path_sum
+
+// #Medium #Top_100_Liked_Questions #Array #Dynamic_Programming #Matrix
+// #Dynamic_Programming_I_Day_16 #Udemy_Dynamic_Programming
+// #2022_08_30_Time_222_ms_(95.70%)_Space_38_MB_(98.92%)
+
+class Solution {
+    fun minPathSum(grid: Array<IntArray>): Int {
+        val m = grid.size
+        val n = grid[0].size
+        val dp = Array(m) { Array(n) { 0 } }
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                if (i == 0 && j == 0) {
+                    dp[i][j] = grid[i][j]
+                } else if (i == 0) {
+                    dp[i][j] = dp[i][j - 1] + grid[i][j]
+                } else if (j == 0) {
+                    dp[i][j] = dp[i - 1][j] + grid[i][j]
+                } else {
+                    dp[i][j] = minOf(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]
+                }
+            }
+        }
+        return dp[m - 1][n - 1]
+    }
+}

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

@@ -0,0 +1,30 @@
+64\. Minimum Path Sum
+
+Medium
+
+Given a `m x n` `grid` filled with non-negative numbers, find a path from top left to bottom right, which minimizes the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/05/minpath.jpg)
+
+**Input:** grid = [[1,3,1],[1,5,1],[4,2,1]]
+
+**Output:** 7
+
+**Explanation:** Because the path 1 → 3 → 1 → 1 → 1 minimizes the sum.
+
+**Example 2:**
+
+**Input:** grid = [[1,2,3],[4,5,6]]
+
+**Output:** 12
+
+**Constraints:**
+
+*   `m == grid.length`
+*   `n == grid[i].length`
+*   `1 <= m, n <= 200`
+*   `0 <= grid[i][j] <= 100`

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

@@ -0,0 +1,28 @@
+package g0001_0100.s0070_climbing_stairs
+
+// #Easy #Top_100_Liked_Questions #Top_Interview_Questions #Dynamic_Programming #Math #Memoization
+// #Algorithm_I_Day_12_Dynamic_Programming #Dynamic_Programming_I_Day_2
+// #Level_1_Day_10_Dynamic_Programming #Udemy_Dynamic_Programming
+// #2022_08_30_Time_127_ms_(97.06%)_Space_32.7_MB_(97.70%)
+
+class Solution {
+    fun climbStairs(n: Int): Int {
+        if (n < 2) {
+            return n
+        }
+        val cache = IntArray(n)
+        // creating a cache or DP to store the result
+        // so that we dont have to iterate multiple times
+        // for the same values;
+
+        // for 0 and 1 the result array i.e cache values would be 1 and 2
+        // in loop we are just getting ith values i.e 5th step values from
+        // i-1 and i-2 which are 4th step and 3rd step values.
+        cache[0] = 1
+        cache[1] = 2
+        for (i in 2 until n) {
+            cache[i] = cache[i - 1] + cache[i - 2]
+        }
+        return cache[n - 1]
+    }
+}

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

@@ -0,0 +1,37 @@
+70\. Climbing Stairs
+
+Easy
+
+You are climbing a staircase. It takes `n` steps to reach the top.
+
+Each time you can either climb `1` or `2` steps. In how many distinct ways can you climb to the top?
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** 2
+
+**Explanation:** There are two ways to climb to the top. 
+
+1. 1 step + 1 step 
+
+2. 2 steps
+
+**Example 2:**
+
+**Input:** n = 3
+
+**Output:** 3
+
+**Explanation:** There are three ways to climb to the top. 
+
+1. 1 step + 1 step + 1 step 
+
+2. 1 step + 2 steps 
+
+3. 2 steps + 1 step
+
+**Constraints:**
+
+*   `1 <= n <= 45`

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

@@ -0,0 +1,29 @@
+package g0001_0100.s0072_edit_distance
+
+// #Hard #Top_100_Liked_Questions #String #Dynamic_Programming
+// #Algorithm_II_Day_18_Dynamic_Programming #Dynamic_Programming_I_Day_19
+// #Udemy_Dynamic_Programming #2022_08_30_Time_320_ms_(63.53%)_Space_37.2_MB_(83.53%)
+
+class Solution {
+    fun minDistance(w1: String, w2: String): Int {
+        val n1 = w1.length
+        val n2 = w2.length
+        if (n2 > n1) {
+            return minDistance(w2, w1)
+        }
+        val dp = IntArray(n2 + 1)
+        for (j in 0..n2) {
+            dp[j] = j
+        }
+        for (i in 1..n1) {
+            var pre = dp[0]
+            dp[0] = i
+            for (j in 1..n2) {
+                val tmp = dp[j]
+                dp[j] = if (w1[i - 1] != w2[j - 1]) 1 + Math.min(pre, Math.min(dp[j], dp[j - 1])) else pre
+                pre = tmp
+            }
+        }
+        return dp[n2]
+    }
+}

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

@@ -0,0 +1,48 @@
+72\. Edit Distance
+
+Hard
+
+Given two strings `word1` and `word2`, return _the minimum number of operations required to convert `word1` to `word2`_.
+
+You have the following three operations permitted on a word:
+
+*   Insert a character
+*   Delete a character
+*   Replace a character
+
+**Example 1:**
+
+**Input:** word1 = "horse", word2 = "ros"
+
+**Output:** 3
+
+**Explanation:** 
+
+horse -> rorse (replace 'h' with 'r') 
+
+rorse -> rose (remove 'r') 
+
+rose -> ros (remove 'e')
+
+**Example 2:**
+
+**Input:** word1 = "intention", word2 = "execution"
+
+**Output:** 5
+
+**Explanation:** 
+
+intention -> inention (remove 't') 
+
+inention -> enention (replace 'i' with 'e') 
+
+enention -> exention (replace 'n' with 'x') 
+
+exention -> exection (replace 'n' with 'c') 
+
+exection -> execution (insert 'u')
+
+**Constraints:**
+
+*   `0 <= word1.length, word2.length <= 500`
+*   `word1` and `word2` consist of lowercase English letters.

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

@@ -0,0 +1,17 @@
+package g0001_0100.s0062_unique_paths
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun uniquePaths() {
+        assertThat(Solution().uniquePaths(3, 7), equalTo(28))
+    }
+
+    @Test
+    fun uniquePaths2() {
+        assertThat(Solution().uniquePaths(3, 2), equalTo(3))
+    }
+}

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

@@ -0,0 +1,17 @@
+package g0001_0100.s0064_minimum_path_sum
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minPathSum() {
+        assertThat(Solution().minPathSum(arrayOf(intArrayOf(1, 3, 1), intArrayOf(1, 5, 1), intArrayOf(4, 2, 1))), equalTo(7))
+    }
+
+    @Test
+    fun minPathSum2() {
+        assertThat(Solution().minPathSum(arrayOf(intArrayOf(1, 2, 3), intArrayOf(4, 5, 6))), equalTo(12))
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+package g0001_0100.s0072_edit_distance
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun minDistance() {
+        assertThat(Solution().minDistance("horse", "ros"), equalTo(3))
+    }
+
+    @Test
+    fun minDistance2() {
+        assertThat(Solution().minDistance("intention", "execution"), equalTo(5))
+    }
+}