Added tasks 896, 897, 898, 899

Author: ThanhNIT

README.md

@@ -1504,6 +1504,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0896 |[Monotonic Array](src/main/kotlin/g0801_0900/s0896_monotonic_array/Solution.kt)| Easy | Array | 576 | 90.91
 | 0028 |[Find the Index of the First Occurrence in a String](src.save/main/kotlin/g0001_0100/s0028_implement_strstr/Solution.kt)| Easy | Top_Interview_Questions, String, Two_Pointers, String_Matching | 257 | 32.35
 
 #### Day 2
@@ -1725,6 +1726,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.11'
 |------|----------------|-------------|-------------|----------|---------
 | 1143 |[Longest Common Subsequence](src/main/kotlin/g1101_1200/s1143_longest_common_subsequence/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming, Algorithm_II_Day_17_Dynamic_Programming, Dynamic_Programming_I_Day_19, Udemy_Dynamic_Programming | 307 | 38.36
 | 0994 |[Rotting Oranges](src/main/kotlin/g0901_1000/s0994_rotting_oranges/Solution.kt)| Medium | Array, Breadth_First_Search, Matrix, Algorithm_I_Day_9_Breadth_First_Search_Depth_First_Search, Level_2_Day_10_Graph/BFS/DFS | 308 | 57.93
+| 0899 |[Orderly Queue](src/main/kotlin/g0801_0900/s0899_orderly_queue/Solution.kt)| Hard | String, Math, Sorting | 148 | 100.00
+| 0898 |[Bitwise ORs of Subarrays](src/main/kotlin/g0801_0900/s0898_bitwise_ors_of_subarrays/Solution.kt)| Medium | Array, Dynamic_Programming, Bit_Manipulation | 812 | 100.00
+| 0897 |[Increasing Order Search Tree](src/main/kotlin/g0801_0900/s0897_increasing_order_search_tree/Solution.kt)| Easy | Depth_First_Search, Tree, Binary_Tree, Stack, Binary_Search_Tree | 128 | 85.71
+| 0896 |[Monotonic Array](src/main/kotlin/g0801_0900/s0896_monotonic_array/Solution.kt)| Easy | Array, Programming_Skills_II_Day_1 | 576 | 90.91
 | 0895 |[Maximum Frequency Stack](src/main/kotlin/g0801_0900/s0895_maximum_frequency_stack/FreqStack.kt)| Hard | Hash_Table, Stack, Design, Ordered_Set | 617 | 100.00
 | 0894 |[All Possible Full Binary Trees](src/main/kotlin/g0801_0900/s0894_all_possible_full_binary_trees/Solution.kt)| Medium | Dynamic_Programming, Tree, Binary_Tree, Recursion, Memoization | 257 | 100.00
 | 0893 |[Groups of Special-Equivalent Strings](src/main/kotlin/g0801_0900/s0893_groups_of_special_equivalent_strings/Solution.kt)| Medium | Array, String, Hash_Table | 141 | 100.00

src/main/kotlin/g0801_0900/s0896_monotonic_array/Solution.kt

@@ -0,0 +1,26 @@
+package g0801_0900.s0896_monotonic_array
+
+// #Easy #Array #Programming_Skills_II_Day_1 #2023_04_12_Time_576_ms_(90.91%)_Space_55.5_MB_(95.45%)
+
+class Solution {
+    fun isMonotonic(nums: IntArray): Boolean {
+        var i = 0
+        while (i < nums.size - 1) {
+            if (nums[i] > nums[i + 1]) {
+                break
+            }
+            i++
+        }
+        if (i == nums.size - 1) {
+            return true
+        }
+        i = 0
+        while (i < nums.size - 1) {
+            if (nums[i] < nums[i + 1]) {
+                break
+            }
+            i++
+        }
+        return i == nums.size - 1
+    }
+}

src/main/kotlin/g0801_0900/s0896_monotonic_array/readme.md

@@ -0,0 +1,32 @@
+896\. Monotonic Array
+
+Easy
+
+An array is **monotonic** if it is either monotone increasing or monotone decreasing.
+
+An array `nums` is monotone increasing if for all `i <= j`, `nums[i] <= nums[j]`. An array `nums` is monotone decreasing if for all `i <= j`, `nums[i] >= nums[j]`.
+
+Given an integer array `nums`, return `true` _if the given array is monotonic, or_ `false` _otherwise_.
+
+**Example 1:**
+
+**Input:** nums = [1,2,2,3]
+
+**Output:** true
+
+**Example 2:**
+
+**Input:** nums = [6,5,4,4]
+
+**Output:** true
+
+**Example 3:**
+
+**Input:** nums = [1,3,2]
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>5</sup> <= nums[i] <= 10<sup>5</sup></code>

src/main/kotlin/g0801_0900/s0897_increasing_order_search_tree/Solution.kt

@@ -0,0 +1,37 @@
+package g0801_0900.s0897_increasing_order_search_tree
+
+// #Easy #Depth_First_Search #Tree #Binary_Tree #Stack #Binary_Search_Tree
+// #2023_04_12_Time_128_ms_(85.71%)_Space_34_MB_(14.29%)
+
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+
+/*
+ * Example:
+ * var ti = TreeNode(5)
+ * var v = ti.`val`
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+class Solution {
+    fun increasingBST(root: TreeNode?): TreeNode {
+        val list: MutableList<TreeNode> = LinkedList<TreeNode>()
+        traverse(root, list)
+        for (i in 1 until list.size) {
+            list[i - 1].right = list[i]
+            list[i].left = null
+        }
+        return list[0]
+    }
+
+    private fun traverse(root: TreeNode?, list: MutableList<TreeNode>) {
+        if (root != null) {
+            traverse(root.left, list)
+            list.add(root)
+            traverse(root.right, list)
+        }
+    }
+}

src/main/kotlin/g0801_0900/s0897_increasing_order_search_tree/readme.md

@@ -0,0 +1,26 @@
+897\. Increasing Order Search Tree
+
+Easy
+
+Given the `root` of a binary search tree, rearrange the tree in **in-order** so that the leftmost node in the tree is now the root of the tree, and every node has no left child and only one right child.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/17/ex1.jpg)
+
+**Input:** root = [5,3,6,2,4,null,8,1,null,null,null,7,9]
+
+**Output:** [1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/17/ex2.jpg)
+
+**Input:** root = [5,1,7]
+
+**Output:** [1,null,5,null,7]
+
+**Constraints:**
+
+*   The number of nodes in the given tree will be in the range `[1, 100]`.
+*   `0 <= Node.val <= 1000`

src/main/kotlin/g0801_0900/s0898_bitwise_ors_of_subarrays/Solution.kt

@@ -0,0 +1,21 @@
+package g0801_0900.s0898_bitwise_ors_of_subarrays
+
+// #Medium #Array #Dynamic_Programming #Bit_Manipulation
+// #2023_04_12_Time_812_ms_(100.00%)_Space_60.1_MB_(100.00%)
+
+class Solution {
+    fun subarrayBitwiseORs(arr: IntArray): Int {
+        val set: MutableSet<Int> = HashSet()
+        for (i in arr.indices) {
+            set.add(arr[i])
+            for (j in i - 1 downTo 0) {
+                if (arr[i] or arr[j] == arr[j]) {
+                    break
+                }
+                arr[j] = arr[j] or arr[i]
+                set.add(arr[j])
+            }
+        }
+        return set.size
+    }
+}

src/main/kotlin/g0801_0900/s0898_bitwise_ors_of_subarrays/readme.md

@@ -0,0 +1,42 @@
+898\. Bitwise ORs of Subarrays
+
+Medium
+
+Given an integer array `arr`, return _the number of distinct bitwise ORs of all the non-empty subarrays of_ `arr`.
+
+The bitwise OR of a subarray is the bitwise OR of each integer in the subarray. The bitwise OR of a subarray of one integer is that integer.
+
+A **subarray** is a contiguous non-empty sequence of elements within an array.
+
+**Example 1:**
+
+**Input:** arr = [0]
+
+**Output:** 1
+
+**Explanation:** There is only one possible result: 0.
+
+**Example 2:**
+
+**Input:** arr = [1,1,2]
+
+**Output:** 3
+
+**Explanation:** The possible subarrays are [1], [1], [2], [1, 1], [1, 2], [1, 1, 2]. 
+
+These yield the results 1, 1, 2, 1, 3, 3. 
+
+There are 3 unique values, so the answer is 3.
+
+**Example 3:**
+
+**Input:** arr = [1,2,4]
+
+**Output:** 6
+
+**Explanation:** The possible results are 1, 2, 3, 4, 6, and 7.
+
+**Constraints:**
+
+*   <code>1 <= arr.length <= 5 * 10<sup>4</sup></code>
+*   <code>0 <= arr[i] <= 10<sup>9</sup></code>

src/main/kotlin/g0801_0900/s0899_orderly_queue/Solution.kt

@@ -0,0 +1,35 @@
+package g0801_0900.s0899_orderly_queue
+
+// #Hard #String #Math #Sorting #2023_04_12_Time_148_ms_(100.00%)_Space_35.6_MB_(66.67%)
+
+class Solution {
+    fun orderlyQueue(s: String, k: Int): String {
+        if (k > 1) {
+            val ans = s.toCharArray()
+            ans.sort()
+            return String(ans)
+        }
+        var min = 'z'
+        val list = ArrayList<Int>()
+        for (element in s) {
+            if (element < min) {
+                min = element
+            }
+        }
+        for (i in s.indices) {
+            if (s[i] == min) {
+                list.add(i)
+            }
+        }
+        var ans = s
+        for (integer in list) {
+            val after = s.substring(0, integer)
+            val before = s.substring(integer)
+            val f = before + after
+            if (f < ans) {
+                ans = f
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g0801_0900/s0899_orderly_queue/readme.md

@@ -0,0 +1,36 @@
+899\. Orderly Queue
+
+Hard
+
+You are given a string `s` and an integer `k`. You can choose one of the first `k` letters of `s` and append it at the end of the string..
+
+Return _the lexicographically smallest string you could have after applying the mentioned step any number of moves_.
+
+**Example 1:**
+
+**Input:** s = "cba", k = 1
+
+**Output:** "acb"
+
+**Explanation:**
+
+In the first move, we move the 1<sup>st</sup> character 'c' to the end, obtaining the string "bac".
+
+In the second move, we move the 1<sup>st</sup> character 'b' to the end, obtaining the final result "acb".
+
+**Example 2:**
+
+**Input:** s = "baaca", k = 3
+
+**Output:** "aaabc"
+
+**Explanation:**
+
+In the first move, we move the 1<sup>st</sup> character 'b' to the end, obtaining the string "aacab".
+
+In the second move, we move the 3<sup>rd</sup> character 'c' to the end, obtaining the final result "aaabc".
+
+**Constraints:**
+
+*   `1 <= k <= s.length <= 1000`
+*   `s` consist of lowercase English letters.

src/test/kotlin/g0801_0900/s0896_monotonic_array/SolutionTest.kt

@@ -0,0 +1,22 @@
+package g0801_0900.s0896_monotonic_array
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun isMonotonic() {
+        assertThat(Solution().isMonotonic(intArrayOf(1, 2, 2, 3)), equalTo(true))
+    }
+
+    @Test
+    fun isMonotonic2() {
+        assertThat(Solution().isMonotonic(intArrayOf(6, 5, 4, 4)), equalTo(true))
+    }
+
+    @Test
+    fun isMonotonic3() {
+        assertThat(Solution().isMonotonic(intArrayOf(1, 3, 2)), equalTo(false))
+    }
+}