Added tasks 654, 655, 657, 658

Author: ThanhNIT

README.md

@@ -1344,6 +1344,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0658 |[Find K Closest Elements](src/main/kotlin/g0601_0700/s0658_find_k_closest_elements/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers, Heap_Priority_Queue | 375 | 95.16
 
 #### Day 3
 
@@ -1674,6 +1675,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 0864 |[Shortest Path to Get All Keys](src/main/kotlin/g0801_0900/s0864_shortest_path_to_get_all_keys/Solution.kt)| Hard | Breadth_First_Search, Bit_Manipulation | 176 | 100.00
 | 0763 |[Partition Labels](src/main/kotlin/g0701_0800/s0763_partition_labels/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Greedy, Two_Pointers, Data_Structure_II_Day_7_String | 235 | 84.75
 | 0739 |[Daily Temperatures](src/main/kotlin/g0701_0800/s0739_daily_temperatures/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Stack, Monotonic_Stack, Programming_Skills_II_Day_6 | 936 | 80.54
+| 0658 |[Find K Closest Elements](src/main/kotlin/g0601_0700/s0658_find_k_closest_elements/Solution.kt)| Medium | Array, Sorting, Binary_Search, Two_Pointers, Heap_Priority_Queue, Binary_Search_II_Day_2 | 375 | 95.16
+| 0657 |[Robot Return to Origin](src/main/kotlin/g0601_0700/s0657_robot_return_to_origin/Solution.kt)| Easy | String, Simulation | 186 | 100.00
+| 0655 |[Print Binary Tree](src/main/kotlin/g0601_0700/s0655_print_binary_tree/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 176 | 100.00
+| 0654 |[Maximum Binary Tree](src/main/kotlin/g0601_0700/s0654_maximum_binary_tree/Solution.kt)| Medium | Array, Tree, Binary_Tree, Stack, Monotonic_Stack, Divide_and_Conquer | 271 | 90.00
 | 0653 |[Two Sum IV - Input is a BST](src/main/kotlin/g0601_0700/s0653_two_sum_iv_input_is_a_bst/Solution.kt)| Easy | Hash_Table, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Two_Pointers, Binary_Search_Tree, Data_Structure_I_Day_14_Tree | 231 | 96.08
 | 0652 |[Find Duplicate Subtrees](src/main/kotlin/g0601_0700/s0652_find_duplicate_subtrees/Solution.kt)| Medium | Hash_Table, Depth_First_Search, Tree, Binary_Tree | 266 | 76.00
 | 0650 |[2 Keys Keyboard](src/main/kotlin/g0601_0700/s0650_2_keys_keyboard/Solution.kt)| Medium | Dynamic_Programming, Math | 115 | 100.00

src/main/kotlin/g0601_0700/s0654_maximum_binary_tree/Solution.kt

@@ -0,0 +1,43 @@
+package g0601_0700.s0654_maximum_binary_tree
+
+// #Medium #Array #Tree #Binary_Tree #Stack #Monotonic_Stack #Divide_and_Conquer
+// #2023_02_13_Time_271_ms_(90.00%)_Space_37.8_MB_(95.00%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * 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 constructMaximumBinaryTree(nums: IntArray): TreeNode? {
+        return mbt(nums, 0, nums.size - 1)
+    }
+
+    private fun mbt(nums: IntArray, l: Int, r: Int): TreeNode? {
+        if (l > r || l >= nums.size || r < 0) {
+            return null
+        }
+        if (l == r) {
+            return TreeNode(nums[r])
+        }
+        var max = Int.MIN_VALUE
+        var maxidx = 0
+        for (i in l..r) {
+            if (nums[i] > max) {
+                max = nums[i]
+                maxidx = i
+            }
+        }
+        val root = TreeNode(max)
+        root.left = mbt(nums, l, maxidx - 1)
+        root.right = mbt(nums, maxidx + 1, r)
+        return root
+    }
+}

src/main/kotlin/g0601_0700/s0654_maximum_binary_tree/readme.md

@@ -0,0 +1,53 @@
+654\. Maximum Binary Tree
+
+Medium
+
+You are given an integer array `nums` with no duplicates. A **maximum binary tree** can be built recursively from `nums` using the following algorithm:
+
+1.  Create a root node whose value is the maximum value in `nums`.
+2.  Recursively build the left subtree on the **subarray prefix** to the **left** of the maximum value.
+3.  Recursively build the right subtree on the **subarray suffix** to the **right** of the maximum value.
+
+Return _the **maximum binary tree** built from_ `nums`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/12/24/tree1.jpg)
+
+**Input:** nums = [3,2,1,6,0,5]
+
+**Output:** [6,3,5,null,2,0,null,null,1]
+
+**Explanation:** The recursive calls are as follow:
+
+- The largest value in [3,2,1,6,0,5] is 6. Left prefix is [3,2,1] and right suffix is [0,5].
+
+    - The largest value in [3,2,1] is 3. Left prefix is [] and right suffix is [2,1].
+
+        - Empty array, so no child.
+
+        - The largest value in [2,1] is 2. Left prefix is [] and right suffix is [1].
+
+            - Empty array, so no child.
+
+            - Only one element, so child is a node with value 1.
+
+    - The largest value in [0,5] is 5. Left prefix is [0] and right suffix is [].
+
+        - Only one element, so child is a node with value 0.
+
+        - Empty array, so no child.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/12/24/tree2.jpg)
+
+**Input:** nums = [3,2,1]
+
+**Output:** [3,null,2,null,1]
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   `0 <= nums[i] <= 1000`
+*   All integers in `nums` are **unique**.

src/main/kotlin/g0601_0700/s0655_print_binary_tree/Solution.kt

@@ -0,0 +1,57 @@
+package g0601_0700.s0655_print_binary_tree
+
+// #Medium #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #2023_02_13_Time_176_ms_(100.00%)_Space_36_MB_(80.00%)
+
+import com_github_leetcode.TreeNode
+import java.util.LinkedList
+import kotlin.math.pow
+
+/*
+ * 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 printTree(root: TreeNode?): List<MutableList<String>> {
+        val result: MutableList<MutableList<String>> = LinkedList()
+        val height = if (root == null) 1 else getHeight(root)
+        val columns = (2.0.pow(height.toDouble()) - 1).toInt()
+        val row: MutableList<String> = ArrayList()
+        for (i in 0 until columns) {
+            row.add("")
+        }
+        for (i in 0 until height) {
+            result.add(ArrayList(row))
+        }
+        populateResult(root, result, 0, height, 0, columns - 1)
+        return result
+    }
+
+    private fun populateResult(
+        root: TreeNode?,
+        result: List<MutableList<String>>,
+        row: Int,
+        totalRows: Int,
+        i: Int,
+        j: Int
+    ) {
+        if (row == totalRows || root == null) {
+            return
+        }
+        result[row][(i + j) / 2] = root.`val`.toString()
+        populateResult(root.left, result, row + 1, totalRows, i, (i + j) / 2 - 1)
+        populateResult(root.right, result, row + 1, totalRows, (i + j) / 2 + 1, j)
+    }
+
+    private fun getHeight(root: TreeNode?): Int {
+        return if (root == null) {
+            0
+        } else 1 + getHeight(root.left).coerceAtLeast(getHeight(root.right))
+    }
+}

src/main/kotlin/g0601_0700/s0655_print_binary_tree/readme.md

@@ -0,0 +1,43 @@
+655\. Print Binary Tree
+
+Medium
+
+Given the `root` of a binary tree, construct a **0-indexed** `m x n` string matrix `res` that represents a **formatted layout** of the tree. The formatted layout matrix should be constructed using the following rules:
+
+*   The **height** of the tree is `height` and the number of rows `m` should be equal to `height + 1`.
+*   The number of columns `n` should be equal to <code>2<sup>height+1</sup> - 1</code>.
+*   Place the **root node** in the **middle** of the **top row** (more formally, at location `res[0][(n-1)/2]`).
+*   For each node that has been placed in the matrix at position `res[r][c]`, place its **left child** at <code>res[r+1][c-2<sup>height-r-1</sup>]</code> and its **right child** at <code>res[r+1][c+2<sup>height-r-1</sup>]</code>.
+*   Continue this process until all the nodes in the tree have been placed.
+*   Any empty cells should contain the empty string `""`.
+
+Return _the constructed matrix_ `res`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/print1-tree.jpg)
+
+**Input:** root = [1,2]
+
+**Output:** 
+    
+    [["","1",""],
+     ["2","",""]]
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/05/03/print2-tree.jpg)
+
+**Input:** root = [1,2,3,null,4]
+
+**Output:** 
+
+    [["","","","1","","",""], 
+     ["","2","","","","3",""], 
+     ["","","4","","","",""]]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 2<sup>10</sup>]</code>.
+*   `-99 <= Node.val <= 99`
+*   The depth of the tree will be in the range `[1, 10]`.

src/main/kotlin/g0601_0700/s0657_robot_return_to_origin/Solution.kt

@@ -0,0 +1,14 @@
+package g0601_0700.s0657_robot_return_to_origin
+
+// #Easy #String #Simulation #2023_02_13_Time_186_ms_(100.00%)_Space_35.9_MB_(100.00%)
+
+class Solution {
+    fun judgeCircle(moves: String): Boolean {
+        val map = IntArray(26)
+        for (c in moves.toCharArray()) {
+            map[c.code - 'A'.code]++
+        }
+        return map['U'.code - 'A'.code] == map['D'.code - 'A'.code] &&
+            map['L'.code - 'A'.code] == map['R'.code - 'A'.code]
+    }
+}

src/main/kotlin/g0601_0700/s0657_robot_return_to_origin/readme.md

@@ -0,0 +1,32 @@
+657\. Robot Return to Origin
+
+Easy
+
+There is a robot starting at the position `(0, 0)`, the origin, on a 2D plane. Given a sequence of its moves, judge if this robot **ends up at** `(0, 0)` after it completes its moves.
+
+You are given a string `moves` that represents the move sequence of the robot where `moves[i]` represents its <code>i<sup>th</sup></code> move. Valid moves are `'R'` (right), `'L'` (left), `'U'` (up), and `'D'` (down).
+
+Return `true` _if the robot returns to the origin after it finishes all of its moves, or_ `false` _otherwise_.
+
+**Note**: The way that the robot is "facing" is irrelevant. `'R'` will always make the robot move to the right once, `'L'` will always make it move left, etc. Also, assume that the magnitude of the robot's movement is the same for each move.
+
+**Example 1:**
+
+**Input:** moves = "UD"
+
+**Output:** true
+
+**Explanation:**: The robot moves up once, and then down once. All moves have the same magnitude, so it ended up at the origin where it started. Therefore, we return true.
+
+**Example 2:**
+
+**Input:** moves = "LL"
+
+**Output:** false
+
+**Explanation:**: The robot moves left twice. It ends up two "moves" to the left of the origin. We return false because it is not at the origin at the end of its moves.
+
+**Constraints:**
+
+*   <code>1 <= moves.length <= 2 * 10<sup>4</sup></code>
+*   `moves` only contains the characters `'U'`, `'D'`, `'L'` and `'R'`.

src/main/kotlin/g0601_0700/s0658_find_k_closest_elements/Solution.kt

@@ -0,0 +1,24 @@
+package g0601_0700.s0658_find_k_closest_elements
+
+// #Medium #Array #Sorting #Binary_Search #Two_Pointers #Heap_Priority_Queue #Binary_Search_II_Day_2
+// #2023_02_13_Time_375_ms_(95.16%)_Space_37.8_MB_(98.39%)
+
+class Solution {
+    fun findClosestElements(arr: IntArray, k: Int, x: Int): List<Int> {
+        var left = 0
+        var right = arr.size - k
+        val answer: MutableList<Int> = ArrayList()
+        while (left < right) {
+            val mid = left + (right - left) / 2
+            if (x - arr[mid] > arr[mid + k] - x) {
+                left = mid + 1
+            } else {
+                right = mid
+            }
+        }
+        for (i in left until left + k) {
+            answer.add(arr[i])
+        }
+        return answer
+    }
+}

src/main/kotlin/g0601_0700/s0658_find_k_closest_elements/readme.md

@@ -0,0 +1,29 @@
+658\. Find K Closest Elements
+
+Medium
+
+Given a **sorted** integer array `arr`, two integers `k` and `x`, return the `k` closest integers to `x` in the array. The result should also be sorted in ascending order.
+
+An integer `a` is closer to `x` than an integer `b` if:
+
+*   `|a - x| < |b - x|`, or
+*   `|a - x| == |b - x|` and `a < b`
+
+**Example 1:**
+
+**Input:** arr = [1,2,3,4,5], k = 4, x = 3
+
+**Output:** [1,2,3,4]
+
+**Example 2:**
+
+**Input:** arr = [1,2,3,4,5], k = 4, x = -1
+
+**Output:** [1,2,3,4]
+
+**Constraints:**
+
+*   `1 <= k <= arr.length`
+*   <code>1 <= arr.length <= 10<sup>4</sup></code>
+*   `arr` is sorted in **ascending** order.
+*   <code>-10<sup>4</sup> <= arr[i], x <= 10<sup>4</sup></code>

src/test/kotlin/g0601_0700/s0654_maximum_binary_tree/SolutionTest.kt

@@ -0,0 +1,26 @@
+package g0601_0700.s0654_maximum_binary_tree
+
+import com_github_leetcode.TreeNode
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun constructMaximumBinaryTree() {
+        val expected = TreeNode.create(listOf(6, 3, 5, null, 2, 0, null, null, 1))
+        assertThat(
+            Solution().constructMaximumBinaryTree(intArrayOf(3, 2, 1, 6, 0, 5)).toString(),
+            equalTo(expected.toString())
+        )
+    }
+
+    @Test
+    fun constructMaximumBinaryTree2() {
+        val expected = TreeNode.create(listOf(3, null, 2, null, 1))
+        assertThat(
+            Solution().constructMaximumBinaryTree(intArrayOf(3, 2, 1)).toString(),
+            equalTo(expected.toString())
+        )
+    }
+}