Added tasks 86, 87, 88.

Author: ThanhNIT

README.md

@@ -1172,6 +1172,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.4'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0001 |[Two Sum](src/main/kotlin/g0001_0100/s0001_two_sum/Solution.kt)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 234 | 92.75
+| 0088 |[Merge Sorted Array](src/main/kotlin/g0001_0100/s0088_merge_sorted_array/Solution.kt)| Easy | Top_Interview_Questions, Array, Sorting, Two_Pointers | 311 | 33.40
 
 #### Day 3 Array
 
@@ -1529,6 +1530,9 @@ 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
+| 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
 | 0085 |[Maximal Rectangle](src/main/kotlin/g0001_0100/s0085_maximal_rectangle/Solution.kt)| Hard | Array, Dynamic_Programming, Matrix, Stack, Monotonic_Stack | 463 | 55.17
 | 0084 |[Largest Rectangle in Histogram](src/main/kotlin/g0001_0100/s0084_largest_rectangle_in_histogram/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Stack, Monotonic_Stack | 525 | 100.00
 | 0083 |[Remove Duplicates from Sorted List](src/main/kotlin/g0001_0100/s0083_remove_duplicates_from_sorted_list/Solution.kt)| Easy | Linked_List, Data_Structure_I_Day_8_Linked_List | 274 | 77.82

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

@@ -0,0 +1,38 @@
+package g0001_0100.s0086_partition_list
+
+// #Medium #Two_Pointers #Linked_List #2022_09_25_Time_331_ms_(5.88%)_Space_35.6_MB_(35.29%)
+
+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 partition(head: ListNode?, x: Int): ListNode? {
+        var head = head
+        var nHead: ListNode? = ListNode(0)
+        var nTail: ListNode? = ListNode(0)
+        val ptr = nTail
+        val temp = nHead
+        while (head != null) {
+            val nNext = head.next
+            if (head.`val` < x) {
+                nHead!!.next = head
+                nHead = nHead.next
+            } else {
+                nTail!!.next = head
+                nTail = nTail.next
+            }
+            head = nNext
+        }
+        nTail!!.next = null
+        nHead!!.next = ptr!!.next
+        return temp!!.next
+    }
+}

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

@@ -0,0 +1,27 @@
+86\. Partition List
+
+Medium
+
+Given the `head` of a linked list and a value `x`, partition it such that all nodes **less than** `x` come before nodes **greater than or equal** to `x`.
+
+You should **preserve** the original relative order of the nodes in each of the two partitions.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/partition.jpg)
+
+**Input:** head = [1,4,3,2,5,2], x = 3
+
+**Output:** [1,2,2,4,3,5]
+
+**Example 2:**
+
+**Input:** head = [2,1], x = 2
+
+**Output:** [1,2]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 200]`.
+*   `-100 <= Node.val <= 100`
+*   `-200 <= x <= 200`

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

@@ -0,0 +1,29 @@
+package g0001_0100.s0087_scramble_string
+
+// #Hard #String #Dynamic_Programming #2022_09_25_Time_366_ms_(85.00%)_Space_36.2_MB_(100.00%)
+
+class Solution {
+    fun isScramble(s1: String, s2: String): Boolean {
+        val n = s1.length
+        val dp = Array(n) { Array(n) { BooleanArray(n + 1) } }
+        for (len in 1..n) {
+            for (i in 0..n - len) {
+                for (j in 0..n - len) {
+                    if (len == 1) {
+                        dp[i][j][len] = s1[i] == s2[j]
+                    } else {
+                        var k = 1
+                        while (k < len && !dp[i][j][len]) {
+                            dp[i][j][len] = (
+                                dp[i][j][k] && dp[i + k][j + k][len - k] ||
+                                    dp[i][j + len - k][k] && dp[i + k][j][len - k]
+                                )
+                            k++
+                        }
+                    }
+                }
+            }
+        }
+        return dp[0][0][n]
+    }
+}

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

@@ -0,0 +1,27 @@
+86\. Partition List
+
+Medium
+
+Given the `head` of a linked list and a value `x`, partition it such that all nodes **less than** `x` come before nodes **greater than or equal** to `x`.
+
+You should **preserve** the original relative order of the nodes in each of the two partitions.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/01/04/partition.jpg)
+
+**Input:** head = [1,4,3,2,5,2], x = 3
+
+**Output:** [1,2,2,4,3,5]
+
+**Example 2:**
+
+**Input:** head = [2,1], x = 2
+
+**Output:** [1,2]
+
+**Constraints:**
+
+*   The number of nodes in the list is in the range `[0, 200]`.
+*   `-100 <= Node.val <= 100`
+*   `-200 <= x <= 200`

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

@@ -0,0 +1,19 @@
+package g0001_0100.s0088_merge_sorted_array
+
+// #Easy #Top_Interview_Questions #Array #Sorting #Two_Pointers #Data_Structure_I_Day_2_Array
+// #2022_09_25_Time_311_ms_(33.40%)_Space_35.7_MB_(57.76%)
+
+class Solution {
+    fun merge(nums1: IntArray, m: Int, nums2: IntArray, n: Int) {
+        var i = m - 1
+        var j = nums1.size - 1
+        var p2 = n - 1
+        while (p2 >= 0) {
+            if (i >= 0 && nums1[i] > nums2[p2]) {
+                nums1[j--] = nums1[i--]
+            } else {
+                nums1[j--] = nums2[p2--]
+            }
+        }
+    }
+}

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

@@ -0,0 +1,43 @@
+88\. Merge Sorted Array
+
+Easy
+
+You are given two integer arrays `nums1` and `nums2`, sorted in **non-decreasing order**, and two integers `m` and `n`, representing the number of elements in `nums1` and `nums2` respectively.
+
+**Merge** `nums1` and `nums2` into a single array sorted in **non-decreasing order**.
+
+The final sorted array should not be returned by the function, but instead be _stored inside the array_ `nums1`. To accommodate this, `nums1` has a length of `m + n`, where the first `m` elements denote the elements that should be merged, and the last `n` elements are set to `0` and should be ignored. `nums2` has a length of `n`.
+
+**Example 1:**
+
+**Input:** nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
+
+**Output:** [1,2,2,3,5,6]
+
+**Explanation:** The arrays we are merging are [1,2,3] and [2,5,6]. The result of the merge is [<ins>1</ins>,<ins>2</ins>,2,<ins>3</ins>,5,6] with the underlined elements coming from nums1.
+
+**Example 2:**
+
+**Input:** nums1 = [1], m = 1, nums2 = [], n = 0
+
+**Output:** [1]
+
+**Explanation:** The arrays we are merging are [1] and []. The result of the merge is [1].
+
+**Example 3:**
+
+**Input:** nums1 = [0], m = 0, nums2 = [1], n = 1
+
+**Output:** [1]
+
+**Explanation:** The arrays we are merging are [] and [1]. The result of the merge is [1]. Note that because m = 0, there are no elements in nums1. The 0 is only there to ensure the merge result can fit in nums1.
+
+**Constraints:**
+
+*   `nums1.length == m + n`
+*   `nums2.length == n`
+*   `0 <= m, n <= 200`
+*   `1 <= m + n <= 200`
+*   <code>-10<sup>9</sup> <= nums1[i], nums2[j] <= 10<sup>9</sup></code>
+
+**Follow up:** Can you come up with an algorithm that runs in `O(m + n)` time?

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

@@ -0,0 +1,21 @@
+package g0001_0100.s0086_partition_list
+
+import com_github_leetcode.LinkedListUtils.createSinglyLinkedList
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+import java.util.Arrays
+
+internal class SolutionTest {
+    @Test
+    fun partition() {
+        val head = createSinglyLinkedList(Arrays.asList(1, 4, 3, 2, 5, 2))
+        assertThat(Solution().partition(head, 3).toString(), equalTo("1, 2, 2, 4, 3, 5"))
+    }
+
+    @Test
+    fun partition2() {
+        val head = createSinglyLinkedList(Arrays.asList(2, 1))
+        assertThat(Solution().partition(head, 2).toString(), equalTo("1, 2"))
+    }
+}

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

@@ -0,0 +1,22 @@
+package g0001_0100.s0087_scramble_string
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isScramble() {
+        assertThat(Solution().isScramble("great", "rgeat"), equalTo(true))
+    }
+
+    @Test
+    fun isScramble2() {
+        assertThat(Solution().isScramble("abcde", "caebd"), equalTo(false))
+    }
+
+    @Test
+    fun isScramble3() {
+        assertThat(Solution().isScramble("a", "a"), equalTo(true))
+    }
+}

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

@@ -0,0 +1,21 @@
+package g0001_0100.s0088_merge_sorted_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun merge() {
+        val array = intArrayOf(1, 2, 3, 0, 0, 0)
+        Solution().merge(array, 3, intArrayOf(2, 5, 6), 3)
+        assertThat(array, equalTo(intArrayOf(1, 2, 2, 3, 5, 6)))
+    }
+
+    @Test
+    fun merge2() {
+        val array = intArrayOf(1)
+        Solution().merge(array, 1, intArrayOf(), 0)
+        assertThat(array, equalTo(intArrayOf(1)))
+    }
+}