Added tasks 89, 90, 91, 92.

Author: ThanhNIT

README.md

@@ -105,6 +105,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0078 |[Subsets](src/main/kotlin/g0001_0100/s0078_subsets/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Backtracking | 353 | 30.14
+| 0090 |[Subsets II](src/main/kotlin/g0001_0100/s0090_subsets_ii/Solution.kt)| Medium | Array, Bit_Manipulation, Backtracking | 366 | 58.09
 
 #### Day 10 Recursion Backtracking
 
@@ -145,6 +146,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0091 |[Decode Ways](src/main/kotlin/g0001_0100/s0091_decode_ways/Solution.kt)| Medium | Top_Interview_Questions, String, Dynamic_Programming | 327 | 17.68
 | 0139 |[Word Break](src/main/kotlin/g0101_0200/s0139_word_break/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Dynamic_Programming, Trie, Memoization | 197 | 87.17
 
 #### Day 16 Dynamic Programming
@@ -415,6 +417,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0091 |[Decode Ways](src/main/kotlin/g0001_0100/s0091_decode_ways/Solution.kt)| Medium | Top_Interview_Questions, String, Dynamic_Programming | 327 | 17.68
 
 #### Day 11
 
@@ -1530,6 +1533,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | 0098 |[Validate Binary Search Tree](src/main/kotlin/g0001_0100/s0098_validate_binary_search_tree/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_I_Day_14_Tree, Level_1_Day_8_Binary_Search_Tree, Udemy_Tree_Stack_Queue | 330 | 41.38
 | 0096 |[Unique Binary Search Trees](src/main/kotlin/g0001_0100/s0096_unique_binary_search_trees/Solution.kt)| Medium | Top_100_Liked_Questions, Dynamic_Programming, Math, Tree, Binary_Tree, Binary_Search_Tree, Dynamic_Programming_I_Day_11 | 237 | 26.76
 | 0094 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0094_binary_tree_inorder_traversal/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Data_Structure_I_Day_10_Tree, Udemy_Tree_Stack_Queue | 283 | 17.97
+| 0092 |[Reverse Linked List II](src/main/kotlin/g0001_0100/s0092_reverse_linked_list_ii/Solution.kt)| Medium | Linked_List | 191 | 82.35
+| 0091 |[Decode Ways](src/main/kotlin/g0001_0100/s0091_decode_ways/Solution.kt)| Medium | Top_Interview_Questions, String, Dynamic_Programming, Algorithm_II_Day_15_Dynamic_Programming, Dynamic_Programming_I_Day_10 | 327 | 17.68
+| 0090 |[Subsets II](src/main/kotlin/g0001_0100/s0090_subsets_ii/Solution.kt)| Medium | Array, Bit_Manipulation, Backtracking, Algorithm_II_Day_9_Recursion_Backtracking | 366 | 58.09
+| 0089 |[Gray Code](src/main/kotlin/g0001_0100/s0089_gray_code/Solution.kt)| Medium | Math, Bit_Manipulation, Backtracking | 528 | 62.86
 | 0088 |[Merge Sorted Array](src/main/kotlin/g0001_0100/s0088_merge_sorted_array/Solution.kt)| Easy | Top_Interview_Questions, Array, Sorting, Two_Pointers, Data_Structure_I_Day_2_Array | 311 | 33.40
 | 0087 |[Partition List](src/main/kotlin/g0001_0100/s0087_scramble_string/Solution.kt)| Hard | String, Dynamic_Programming | 366 | 85.00
 | 0086 |[Partition List](src/main/kotlin/g0001_0100/s0086_partition_list/Solution.kt)| Medium | Two_Pointers, Linked_List | 331 | 5.88

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

@@ -0,0 +1,28 @@
+package g0001_0100.s0089_gray_code
+
+// #Medium #Math #Bit_Manipulation #Backtracking
+// #2022_09_26_Time_528_ms_(62.86%)_Space_61.8_MB_(88.57%)
+
+import java.util.Arrays
+
+class Solution {
+    fun grayCode(n: Int): List<Int> {
+        var n = n
+        var n1 = arrayOf<Int?>(0)
+        var shift = 1
+        while (n > 0) {
+            val temp = arrayOfNulls<Int>(n1.size * 2)
+            var pos = 0
+            for (integer in n1) {
+                temp[pos++] = integer
+            }
+            for (i in 0..n1.size - 1) {
+                temp[pos++] = n1[n1.size - i - 1]!! or shift
+            }
+            n1 = temp
+            shift = shift shl 1
+            n--
+        }
+        return Arrays.asList(*n1) as List<Int>
+    }
+}

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

@@ -0,0 +1,31 @@
+89\. Gray Code
+
+Medium
+
+An **n-bit gray code sequence** is a sequence of <code>2<sup>n</sup></code> integers where:
+
+*   Every integer is in the **inclusive** range <code>[0, 2<sup>n</sup> - 1]</code>,
+*   The first integer is `0`,
+*   An integer appears **no more than once** in the sequence,
+*   The binary representation of every pair of **adjacent** integers differs by **exactly one bit**, and
+*   The binary representation of the **first** and **last** integers differs by **exactly one bit**.
+
+Given an integer `n`, return _any valid **n-bit gray code sequence**_.
+
+**Example 1:**
+
+**Input:** n = 2
+
+**Output:** [0,1,3,2]
+
+**Explanation:** The binary representation of [0,1,3,2] is [00,01,11,10]. - 0<ins>0</ins> and 0<ins>1</ins> differ by one bit - <ins>0</ins>1 and <ins>1</ins>1 differ by one bit - 1<ins>1</ins> and 1<ins>0</ins> differ by one bit - <ins>1</ins>0 and <ins>0</ins>0 differ by one bit [0,2,3,1] is also a valid gray code sequence, whose binary representation is [00,10,11,01]. - <ins>0</ins>0 and <ins>1</ins>0 differ by one bit - 1<ins>0</ins> and 1<ins>1</ins> differ by one bit - <ins>1</ins>1 and <ins>0</ins>1 differ by one bit - 0<ins>1</ins> and 0<ins>0</ins> differ by one bit
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** [0,1]
+
+**Constraints:**
+
+*   `1 <= n <= 16`

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

@@ -0,0 +1,34 @@
+package g0001_0100.s0090_subsets_ii
+
+// #Medium #Array #Bit_Manipulation #Backtracking #Algorithm_II_Day_9_Recursion_Backtracking
+// #2022_09_26_Time_366_ms_(58.09%)_Space_38.9_MB_(88.97%
+
+import java.util.Arrays
+
+class Solution {
+    var allComb: MutableList<List<Int>> = ArrayList()
+    var comb: MutableList<Int> = ArrayList()
+    lateinit var nums: IntArray
+    fun subsetsWithDup(nums: IntArray): List<List<Int>> {
+        Arrays.sort(nums)
+        this.nums = nums
+        dfs(0)
+        allComb.add(ArrayList())
+        return allComb
+    }
+
+    private fun dfs(start: Int) {
+        if (start > nums.size) {
+            return
+        }
+        for (i in start until nums.size) {
+            if (i > start && nums[i] == nums[i - 1]) {
+                continue
+            }
+            comb.add(nums[i])
+            allComb.add(ArrayList(comb))
+            dfs(i + 1)
+            comb.removeAt(comb.size - 1)
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+90\. Subsets II
+
+Medium
+
+Given an integer array `nums` that may contain duplicates, return _all possible subsets (the power set)_.
+
+The solution set **must not** contain duplicate subsets. Return the solution in **any order**.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2]
+
+**Output:** [[],[1],[1,2],[1,2,2],[2],[2,2]]
+
+**Example 2:**
+
+**Input:** nums = [0]
+
+**Output:** [[],[0]]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 10`
+*   `-10 <= nums[i] <= 10`

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

@@ -0,0 +1,32 @@
+package g0001_0100.s0091_decode_ways
+
+// #Medium #Top_Interview_Questions #String #Dynamic_Programming
+// #Algorithm_II_Day_15_Dynamic_Programming #Dynamic_Programming_I_Day_10
+// #2022_09_26_Time_327_ms_(17.68%)_Space_34.7_MB_(82.93%)
+
+class Solution {
+    fun numDecodings(s: String): Int {
+        if (s[0] == '0') {
+            return 0
+        }
+        val n = s.length
+        val f = IntArray(n + 1)
+        // Auxiliary
+        f[0] = 1
+        f[1] = 1
+        for (i in 2..n) {
+            // Calculate the independent number
+            if (s[i - 1] != '0') {
+                // As long as the current character is not 0, it means that the previous decoding
+                // number can be inherited
+                f[i] = f[i - 1]
+            }
+            // Calculate the number of combinations
+            val twodigits = (s[i - 2] - '0') * 10 + (s[i - 1] - '0')
+            if (twodigits >= 10 && twodigits <= 26) {
+                f[i] += f[i - 2]
+            }
+        }
+        return f[n]
+    }
+}

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

@@ -0,0 +1,47 @@
+91\. Decode Ways
+
+Medium
+
+A message containing letters from `A-Z` can be **encoded** into numbers using the following mapping:
+
+'A' -> "1" 'B' -> "2" ... 'Z' -> "26"
+
+To **decode** an encoded message, all the digits must be grouped then mapped back into letters using the reverse of the mapping above (there may be multiple ways). For example, `"11106"` can be mapped into:
+
+*   `"AAJF"` with the grouping `(1 1 10 6)`
+*   `"KJF"` with the grouping `(11 10 6)`
+
+Note that the grouping `(1 11 06)` is invalid because `"06"` cannot be mapped into `'F'` since `"6"` is different from `"06"`.
+
+Given a string `s` containing only digits, return _the **number** of ways to **decode** it_.
+
+The test cases are generated so that the answer fits in a **32-bit** integer.
+
+**Example 1:**
+
+**Input:** s = "12"
+
+**Output:** 2
+
+**Explanation:** "12" could be decoded as "AB" (1 2) or "L" (12).
+
+**Example 2:**
+
+**Input:** s = "226"
+
+**Output:** 3
+
+**Explanation:** "226" could be decoded as "BZ" (2 26), "VF" (22 6), or "BBF" (2 2 6).
+
+**Example 3:**
+
+**Input:** s = "06"
+
+**Output:** 0
+
+**Explanation:** "06" cannot be mapped to "F" because of the leading zero ("6" is different from "06").
+
+**Constraints:**
+
+*   `1 <= s.length <= 100`
+*   `s` contains only digits and may contain leading zero(s).

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

@@ -0,0 +1,71 @@
+package g0001_0100.s0092_reverse_linked_list_ii
+
+// #Medium #Linked_List #2022_09_26_Time_191_ms_(82.35%)_Space_34.4_MB_(29.41%)
+
+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 reverseBetween(head: ListNode?, left: Int, right: Int): ListNode? {
+        var head = head
+        var right = right
+        if (left == right) {
+            return head
+        }
+        var prev: ListNode? = null
+        var temp = head
+        val start: ListNode?
+        var k = left
+        while (temp != null && k > 1) {
+            prev = temp
+            temp = temp.next
+            k--
+        }
+        if (left > 1 && prev != null) {
+            prev.next = null
+        }
+        var prev1: ListNode? = null
+        start = temp
+        while (temp != null && right - left >= 0) {
+            prev1 = temp
+            temp = temp.next
+            right--
+        }
+        if (prev1 != null) {
+            prev1.next = null
+        }
+        if (left > 1 && prev != null) {
+            prev.next = reverse(start)
+        } else {
+            head = reverse(start)
+            prev = head
+        }
+        while (prev!!.next != null) {
+            prev = prev.next
+        }
+        prev.next = temp
+        return head
+    }
+
+    fun reverse(head: ListNode?): ListNode? {
+        var p: ListNode?
+        var q: ListNode?
+        var r: ListNode? = null
+        p = head
+        while (p != null) {
+            q = p.next
+            p.next = r
+            r = p
+            p = q
+        }
+        return r
+    }
+}

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

@@ -0,0 +1,28 @@
+92\. Reverse Linked List II
+
+Medium
+
+Given the `head` of a singly linked list and two integers `left` and `right` where `left <= right`, reverse the nodes of the list from position `left` to position `right`, and return _the reversed list_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/rev2ex2.jpg)
+
+**Input:** head = [1,2,3,4,5], left = 2, right = 4
+
+**Output:** [1,4,3,2,5]
+
+**Example 2:**
+
+**Input:** head = [5], left = 1, right = 1
+
+**Output:** [5]
+
+**Constraints:**
+
+*   The number of nodes in the list is `n`.
+*   `1 <= n <= 500`
+*   `-500 <= Node.val <= 500`
+*   `1 <= left <= right <= n`
+
+**Follow up:** Could you do it in one pass?

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

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