Added tasks 59, 60, 61, 63.

Author: ThanhNIT

README.md

@@ -439,6 +439,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0062 |[Unique Paths](src/main/kotlin/g0001_0100/s0062_unique_paths/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Math, Combinatorics | 209 | 49.18
+| 0063 |[Unique Paths II](src/main/kotlin/g0001_0100/s0063_unique_paths_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix | 187 | 84.62
 
 #### Day 16
 
@@ -631,6 +632,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0061 |[Rotate List](src/main/kotlin/g0001_0100/s0061_rotate_list/Solution.kt)| Medium | Two_Pointers, Linked_List | 355 | 13.54
 
 #### Day 17
 
@@ -1076,6 +1078,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0114 |[Flatten Binary Tree to Linked List](src/main/kotlin/g0101_0200/s0114_flatten_binary_tree_to_linked_list/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Linked_List | 305 | 26.30
+| 0061 |[Rotate List](src/main/kotlin/g0001_0100/s0061_rotate_list/Solution.kt)| Medium | Two_Pointers, Linked_List | 355 | 13.54
 | 0024 |[Swap Nodes in Pairs](src/main/kotlin/g0001_0100/s0024_swap_nodes_in_pairs/Solution.kt)| Medium | Top_100_Liked_Questions, Linked_List, Recursion | 149 | 99.39
 | 0142 |[Linked List Cycle II](src/main/kotlin/g0101_0200/s0142_linked_list_cycle_ii/Solution.kt)| Medium | Top_100_Liked_Questions, Hash_Table, Two_Pointers, Linked_List | 192 | 63.39
 | 0141 |[Linked List Cycle](src/main/kotlin/g0101_0200/s0141_linked_list_cycle/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Two_Pointers, Linked_List | 223 | 91.85
@@ -1257,6 +1260,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0048 |[Rotate Image](src/main/kotlin/g0001_0100/s0048_rotate_image/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Math, Matrix | 287 | 46.50
+| 0059 |[Spiral Matrix II](src/main/kotlin/g0001_0100/s0059_spiral_matrix_ii/Solution.kt)| Medium | Array, Matrix, Simulation | 292 | 18.33
 
 #### Day 4 Array
 
@@ -1525,7 +1529,11 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0072 |[Edit Distance](src/main/kotlin/g0001_0100/s0072_edit_distance/Solution.kt)| Hard | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_18_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 320 | 63.53
 | 0070 |[Climbing Stairs](src/main/kotlin/g0001_0100/s0070_climbing_stairs/Solution.kt)| 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 | 127 | 97.06
 | 0064 |[Minimum Path Sum](src/main/kotlin/g0001_0100/s0064_minimum_path_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_16, Udemy_Dynamic_Programming | 222 | 95.70
+| 0063 |[Unique Paths II](src/main/kotlin/g0001_0100/s0063_unique_paths_ii/Solution.kt)| Medium | Array, Dynamic_Programming, Matrix, Dynamic_Programming_I_Day_15 | 187 | 84.62
 | 0062 |[Unique Paths](src/main/kotlin/g0001_0100/s0062_unique_paths/Solution.kt)| 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 | 209 | 49.18
+| 0061 |[Rotate List](src/main/kotlin/g0001_0100/s0061_rotate_list/Solution.kt)| Medium | Two_Pointers, Linked_List, Programming_Skills_II_Day_16, Udemy_Linked_List | 355 | 13.54
+| 0060 |[Permutation Sequence](src/main/kotlin/g0001_0100/s0060_permutation_sequence/Solution.kt)| Hard | Math, Recursion | 293 | 27.78
+| 0059 |[Spiral Matrix II](src/main/kotlin/g0001_0100/s0059_spiral_matrix_ii/Solution.kt)| Medium | Array, Matrix, Simulation, Data_Structure_II_Day_3_Array | 292 | 18.33
 | 0058 |[Length of Last Word](src/main/kotlin/g0001_0100/s0058_length_of_last_word/Solution.kt)| Easy | String, Programming_Skills_II_Day_6, Udemy_Arrays | 243 | 63.33
 | 0057 |[Insert Interval](src/main/kotlin/g0001_0100/s0057_insert_interval/Solution.kt)| Medium | Array, Level_2_Day_17_Interval | 257 | 99.52
 | 0056 |[Merge Intervals](src/main/kotlin/g0001_0100/s0056_merge_intervals/Solution.kt)| 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 | 323 | 99.68

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

@@ -0,0 +1,38 @@
+package g0001_0100.s0059_spiral_matrix_ii
+
+// #Medium #Array #Matrix #Simulation #Data_Structure_II_Day_3_Array
+// #2022_09_22_Time_292_ms_(18.33%)_Space_34.7_MB_(71.67%)
+
+class Solution {
+    fun generateMatrix(n: Int): Array<IntArray> {
+        var num = 1
+        var rStart = 0
+        var rEnd = n - 1
+        var cStart = 0
+        var cEnd = n - 1
+        val spiral = Array(n) { IntArray(n) }
+        while (rStart <= rEnd && cStart <= cEnd) {
+            for (k in cStart..cEnd) {
+                spiral[rStart][k] = num++
+            }
+            rStart++
+            for (k in rStart..rEnd) {
+                spiral[k][cEnd] = num++
+            }
+            cEnd--
+            if (rStart <= rEnd) {
+                for (k in cEnd downTo cStart) {
+                    spiral[rEnd][k] = num++
+                }
+            }
+            rEnd--
+            if (cStart <= cEnd) {
+                for (k in rEnd downTo rStart) {
+                    spiral[k][cStart] = num++
+                }
+            }
+            cStart++
+        }
+        return spiral
+    }
+}

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

@@ -0,0 +1,23 @@
+59\. Spiral Matrix II
+
+Medium
+
+Given a positive integer `n`, generate an `n x n` `matrix` filled with elements from `1` to <code>n<sup>2</sup></code> in spiral order.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiraln.jpg)
+
+**Input:** n = 3
+
+**Output:** [[1,2,3],[8,9,4],[7,6,5]]
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [[1]]
+
+**Constraints:**
+
+*   `1 <= n <= 20`

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

@@ -0,0 +1,33 @@
+package g0001_0100.s0060_permutation_sequence
+
+// #Hard #Math #Recursion #2022_09_22_Time_293_ms_(27.78%)_Space_34.2_MB_(61.11%)
+
+class Solution {
+    fun getPermutation(n: Int, k: Int): String {
+        var k = k
+        val res = CharArray(n)
+        // We want the permutation sequence to be zero-indexed
+        k = k - 1
+        // The set bits indicate the available digits
+        var a = (1 shl n) - 1
+        var m = 1
+        for (i in 2 until n) {
+            // m = (n - 1)!
+            m *= i
+        }
+        for (i in 0 until n) {
+            var b = a
+            for (j in 0 until k / m) {
+                b = b and b - 1
+            }
+            // b is the bit corresponding to the digit we want
+            b = b and b.inv() + 1
+            res[i] = ('1'.code + Integer.bitCount(b - 1)).toChar()
+            // Remove b from the set of available digits
+            a = a and b.inv()
+            k %= m
+            m /= Math.max(1, n - i - 1)
+        }
+        return String(res)
+    }
+}

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

@@ -0,0 +1,39 @@
+60\. Permutation Sequence
+
+Hard
+
+The set `[1, 2, 3, ..., n]` contains a total of `n!` unique permutations.
+
+By listing and labeling all of the permutations in order, we get the following sequence for `n = 3`:
+
+1.  `"123"`
+2.  `"132"`
+3.  `"213"`
+4.  `"231"`
+5.  `"312"`
+6.  `"321"`
+
+Given `n` and `k`, return the <code>k<sup>th</sup></code> permutation sequence.
+
+**Example 1:**
+
+**Input:** n = 3, k = 3
+
+**Output:** "213"
+
+**Example 2:**
+
+**Input:** n = 4, k = 9
+
+**Output:** "2314"
+
+**Example 3:**
+
+**Input:** n = 3, k = 1
+
+**Output:** "123"
+
+**Constraints:**
+
+*   `1 <= n <= 9`
+*   `1 <= k <= n!`

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

@@ -0,0 +1,50 @@
+package g0001_0100.s0061_rotate_list
+
+// #Medium #Two_Pointers #Linked_List #Programming_Skills_II_Day_16 #Udemy_Linked_List
+// #2022_09_22_Time_355_ms_(13.54%)_Space_35.5_MB_(85.42%)
+
+import com_github_leetcode.ListNode
+
+/**
+ * Example:
+ * var li = ListNode(5)
+ * var v = li.`val`
+ * Definition for singly-linked list.
+ * class ListNode(var `val`: Int) {
+ *     var next: ListNode? = null
+ * }
+ */
+class Solution {
+    fun rotateRight(head: ListNode?, k: Int): ListNode? {
+        if (head == null || k == 0) {
+            return head
+        }
+        var tail = head
+        // find the count and let tail points to last node
+        var count = 1
+        while (tail != null && tail.next != null) {
+            count++
+            tail = tail.next
+        }
+        // calculate number of times to rotate by count modulas
+        val times = k % count
+        if (times == 0) {
+            return head
+        }
+        var temp = head
+        // iterate and go to the K+1 th node from the end or count - K - 1 node from
+        // start
+        var i = 1
+        while (i <= count - times - 1 && temp != null) {
+            temp = temp.next
+            i++
+        }
+        var newHead: ListNode? = null
+        if (temp != null && tail != null) {
+            newHead = temp.next
+            temp.next = null
+            tail.next = head
+        }
+        return newHead
+    }
+}

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

@@ -0,0 +1,27 @@
+61\. Rotate List
+
+Medium
+
+Given the `head` of a linked list, rotate the list to the right by `k` places.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/rotate1.jpg)
+
+**Input:** head = [1,2,3,4,5], k = 2
+
+**Output:** [4,5,1,2,3]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/roate2.jpg)
+
+**Input:** head = [0,1,2], k = 4
+
+**Output:** [2,0,1]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 500]`.
+*   `-100 <= Node.val <= 100`
+*   <code>0 <= k <= 2 * 10<sup>9</sup></code>

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

@@ -0,0 +1,40 @@
+package g0001_0100.s0063_unique_paths_ii
+
+// #Medium #Array #Dynamic_Programming #Matrix #Dynamic_Programming_I_Day_15
+// #2022_09_22_Time_187_ms_(84.62%)_Space_43.5_MB_(6.15%)
+
+class Solution {
+    fun uniquePathsWithObstacles(obstacleGrid: Array<IntArray>): Int {
+        // if start point has obstacle, there's no path
+        if (obstacleGrid[0][0] == 1) {
+            return 0
+        }
+        obstacleGrid[0][0] = 1
+        val m = obstacleGrid.size
+        val n: Int = obstacleGrid[0].size
+        for (i in 1 until m) {
+            if (obstacleGrid[i][0] == 1) {
+                obstacleGrid[i][0] = 0
+            } else {
+                obstacleGrid[i][0] = obstacleGrid[i - 1][0]
+            }
+        }
+        for (j in 1 until n) {
+            if (obstacleGrid[0][j] == 1) {
+                obstacleGrid[0][j] = 0
+            } else {
+                obstacleGrid[0][j] = obstacleGrid[0][j - 1]
+            }
+        }
+        for (i in 1 until m) {
+            for (j in 1 until n) {
+                if (obstacleGrid[i][j] == 1) {
+                    obstacleGrid[i][j] = 0
+                } else {
+                    obstacleGrid[i][j] = obstacleGrid[i - 1][j] + obstacleGrid[i][j - 1]
+                }
+            }
+        }
+        return obstacleGrid[m - 1][n - 1]
+    }
+}

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

@@ -0,0 +1,42 @@
+63\. Unique Paths II
+
+Medium
+
+You are given an `m x n` integer array `grid`. There is a robot 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.
+
+An obstacle and space are marked as `1` or `0` respectively in `grid`. A path that the robot takes cannot include **any** square that is an obstacle.
+
+Return _the number of possible unique paths that the robot can take to reach the bottom-right corner_.
+
+The testcases 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/2020/11/04/robot1.jpg)
+
+**Input:** obstacleGrid = [[0,0,0],[0,1,0],[0,0,0]]
+
+**Output:** 2
+
+**Explanation:** There is one obstacle in the middle of the 3x3 grid above. 
+
+There are two ways to reach the bottom-right corner: 
+
+1. Right -> Right -> Down -> Down 
+
+2. Down -> Down -> Right -> Right
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/04/robot2.jpg)
+
+**Input:** obstacleGrid = [[0,1],[0,0]]
+
+**Output:** 1
+
+**Constraints:**
+
+*   `m == obstacleGrid.length`
+*   `n == obstacleGrid[i].length`
+*   `1 <= m, n <= 100`
+*   `obstacleGrid[i][j]` is `0` or `1`.

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

@@ -0,0 +1,20 @@
+package g0001_0100.s0059_spiral_matrix_ii
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun generateMatrix() {
+        assertThat(
+            Solution().generateMatrix(3),
+            equalTo(arrayOf(intArrayOf(1, 2, 3), intArrayOf(8, 9, 4), intArrayOf(7, 6, 5)))
+        )
+    }
+
+    @Test
+    fun generateMatrix2() {
+        assertThat(Solution().generateMatrix(1), equalTo(arrayOf(intArrayOf(1))))
+    }
+}