Added tasks 450, 451, 452, 453.

Author: ThanhNIT

README.md

@@ -1166,6 +1166,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 |-|-|-|-|-|-
 | 0199 |[Binary Tree Right Side View](src.save/main/kotlin/g0101_0200/s0199_binary_tree_right_side_view/Solution.kt)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 194 | 92.89
 | 0113 |[Path Sum II](src.save/main/kotlin/g0101_0200/s0113_path_sum_ii/Solution.kt)| Medium | Depth_First_Search, Tree, Binary_Tree, Backtracking | 364 | 78.67
+| 0450 |[Delete Node in a BST](src/main/kotlin/g0401_0500/s0450_delete_node_in_a_bst/Solution.kt)| Medium | Tree, Binary_Tree, Binary_Search_Tree | 257 | 84.62
 
 #### Day 17 Tree
 
@@ -1197,6 +1198,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0451 |[Sort Characters By Frequency](src/main/kotlin/g0401_0500/s0451_sort_characters_by_frequency/Solution.kt)| Medium | String, Hash_Table, Sorting, Heap_Priority_Queue, Counting, Bucket_Sort | 288 | 81.72
 
 ### Algorithm I
 
@@ -1635,6 +1637,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0560 |[Subarray Sum Equals K](src/main/kotlin/g0501_0600/s0560_subarray_sum_equals_k/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Hash_Table, Prefix_Sum, Data_Structure_II_Day_5_Array | 692 | 53.27
 | 0543 |[Diameter of Binary Tree](src/main/kotlin/g0501_0600/s0543_diameter_of_binary_tree/Solution.kt)| Easy | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree, Udemy_Tree_Stack_Queue | 307 | 43.93
 | 0494 |[Target Sum](src/main/kotlin/g0401_0500/s0494_target_sum/Solution.kt)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Backtracking | 308 | 89.61
+| 0453 |[Minimum Moves to Equal Array Elements](src/main/kotlin/g0401_0500/s0453_minimum_moves_to_equal_array_elements/Solution.kt)| Medium | Array, Math | 282 | 100.00
+| 0452 |[Minimum Number of Arrows to Burst Balloons](src/main/kotlin/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/Solution.kt)| Medium | Array, Sorting, Greedy | 934 | 100.00
+| 0451 |[Sort Characters By Frequency](src/main/kotlin/g0401_0500/s0451_sort_characters_by_frequency/Solution.kt)| Medium | String, Hash_Table, Sorting, Heap_Priority_Queue, Counting, Bucket_Sort, Data_Structure_II_Day_21_Heap_Priority_Queue | 288 | 81.72
+| 0450 |[Delete Node in a BST](src/main/kotlin/g0401_0500/s0450_delete_node_in_a_bst/Solution.kt)| Medium | Tree, Binary_Tree, Binary_Search_Tree, Data_Structure_II_Day_16_Tree | 257 | 84.62
 | 0449 |[Serialize and Deserialize BST](src/main/kotlin/g0401_0500/s0449_serialize_and_deserialize_bst/Codec.kt)| Medium | String, Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Design, Binary_Search_Tree | 233 | 100.00
 | 0448 |[Find All Numbers Disappeared in an Array](src/main/kotlin/g0401_0500/s0448_find_all_numbers_disappeared_in_an_array/Solution.kt)| Easy | Array, Hash_Table, Udemy_Arrays | 394 | 100.00
 | 0447 |[Number of Boomerangs](src/main/kotlin/g0401_0500/s0447_number_of_boomerangs/Solution.kt)| Medium | Array, Hash_Table, Math | 308 | 100.00

src/main/kotlin/g0401_0500/s0450_delete_node_in_a_bst/Solution.kt

@@ -0,0 +1,48 @@
+package g0401_0500.s0450_delete_node_in_a_bst
+
+// #Medium #Tree #Binary_Tree #Binary_Search_Tree #Data_Structure_II_Day_16_Tree
+// #2022_12_25_Time_257_ms_(84.62%)_Space_38.6_MB_(92.31%)
+
+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 deleteNode(root: TreeNode?, key: Int): TreeNode? {
+        if (root == null) return root
+        // find the correct node
+        if (key < root.`val`) {
+            root.left = deleteNode(root.left, key)
+        } else if (key > root.`val`) {
+            root.right = deleteNode(root.right, key)
+        } else {
+            // case 1 - both children are null
+            if (root.left == null && root.right == null) {
+                return null
+            } else if (root.left != null && root.right != null) { // case 2 - both children are NOT null
+                val successor = minimum(root.right!!) // inorder successor
+                root.right = deleteNode(root.right, successor)
+                root.`val` = successor
+            } else { // case 3 - only one of the child is null
+                return root.left ?: root.right
+            }
+        }
+        return root
+    }
+
+    private fun minimum(root: TreeNode): Int {
+        var node = root
+        while (node.left != null) {
+            node = node.left!!
+        }
+        return node.`val`
+    }
+}

src/main/kotlin/g0401_0500/s0450_delete_node_in_a_bst/readme.md

@@ -0,0 +1,50 @@
+450\. Delete Node in a BST
+
+Medium
+
+Given a root node reference of a BST and a key, delete the node with the given key in the BST. Return _the **root node reference** (possibly updated) of the BST_.
+
+Basically, the deletion can be divided into two stages:
+
+1.  Search for a node to remove.
+2.  If the node is found, delete the node.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/09/04/del_node_1.jpg)
+
+**Input:** root = [5,3,6,2,4,null,7], key = 3
+
+**Output:** [5,4,6,2,null,null,7]
+
+**Explanation:** Given key to delete is 3. So we find the node with value 3 and delete it.
+
+One valid answer is [5,4,6,2,null,null,7], shown in the above BST.
+
+Please notice that another valid answer is [5,2,6,null,4,null,7] and it's also accepted.
+
+![](https://assets.leetcode.com/uploads/2020/09/04/del_node_supp.jpg)
+
+**Example 2:**
+
+**Input:** root = [5,3,6,2,4,null,7], key = 0
+
+**Output:** [5,3,6,2,4,null,7]
+
+**Explanation:** The tree does not contain a node with value = 0.
+
+**Example 3:**
+
+**Input:** root = [], key = 0
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>-10<sup>5</sup> <= Node.val <= 10<sup>5</sup></code>
+*   Each node has a **unique** value.
+*   `root` is a valid binary search tree.
+*   <code>-10<sup>5</sup> <= key <= 10<sup>5</sup></code>
+
+**Follow up:** Could you solve it with time complexity `O(height of tree)`?

src/main/kotlin/g0401_0500/s0451_sort_characters_by_frequency/Solution.kt

@@ -0,0 +1,12 @@
+package g0401_0500.s0451_sort_characters_by_frequency
+
+// #Medium #String #Hash_Table #Sorting #Heap_Priority_Queue #Counting #Bucket_Sort
+// #Data_Structure_II_Day_21_Heap_Priority_Queue
+// #2022_12_25_Time_288_ms_(81.72%)_Space_39.4_MB_(83.06%)
+
+class Solution {
+    fun frequencySort(s: String) = s.groupingBy { it }.eachCount().entries.sortedByDescending { it.value }
+        .joinToString("") {
+            StringBuilder().apply { for (i in 1..it.value) append(it.key) }.toString()
+        }
+}

src/main/kotlin/g0401_0500/s0451_sort_characters_by_frequency/readme.md

@@ -0,0 +1,36 @@
+451\. Sort Characters By Frequency
+
+Medium
+
+Given a string `s`, sort it in **decreasing order** based on the **frequency** of the characters. The **frequency** of a character is the number of times it appears in the string.
+
+Return _the sorted string_. If there are multiple answers, return _any of them_.
+
+**Example 1:**
+
+**Input:** s = "tree"
+
+**Output:** "eert"
+
+**Explanation:** 'e' appears twice while 'r' and 't' both appear once. So 'e' must appear before both 'r' and 't'. Therefore "eetr" is also a valid answer.
+
+**Example 2:**
+
+**Input:** s = "cccaaa"
+
+**Output:** "aaaccc"
+
+**Explanation:** Both 'c' and 'a' appear three times, so both "cccaaa" and "aaaccc" are valid answers. Note that "cacaca" is incorrect, as the same characters must be together.
+
+**Example 3:**
+
+**Input:** s = "Aabb"
+
+**Output:** "bbAa"
+
+**Explanation:** "bbaA" is also a valid answer, but "Aabb" is incorrect. Note that 'A' and 'a' are treated as two different characters.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>5</sup></code>
+*   `s` consists of uppercase and lowercase English letters and digits.

src/main/kotlin/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/Solution.kt

@@ -0,0 +1,38 @@
+package g0401_0500.s0452_minimum_number_of_arrows_to_burst_balloons
+
+// #Medium #Array #Sorting #Greedy #2022_12_25_Time_934_ms_(100.00%)_Space_87_MB_(100.00%)
+
+import java.util.Arrays
+
+class Solution {
+    /*
+     * I'm glad to have come up with this solution on my own on 10/13/2021:
+     * we'll have to sort the
+     * balloons by its ending points, a counter case to this is below:
+     * {{0, 6}, {0, 9}, {7, 8}}
+     * if we sort by starting points, then it becomes:
+     * {0, 6}, {0, 9}, {7, 8}
+     * this way, if we shoot 9,
+     * {0, 6} won't be burst however, if we sort by ending points, then it becomes:
+     * {0, 6}, {7, 8}, {0, 9}, then we shoot at 6, then at 8, this gives us the result of bursting all balloons.
+     */
+    fun findMinArrowShots(points: Array<IntArray>): Int {
+        Arrays.sort(
+            points
+        ) { a: IntArray, b: IntArray ->
+            Integer.compare(
+                a[1],
+                b[1]
+            )
+        }
+        var minArrows = 1
+        var end = points[0][1].toLong()
+        for (i in 1 until points.size) {
+            if (points[i][0] > end) {
+                minArrows++
+                end = points[i][1].toLong()
+            }
+        }
+        return minArrows
+    }
+}

src/main/kotlin/g0401_0500/s0452_minimum_number_of_arrows_to_burst_balloons/readme.md

@@ -0,0 +1,47 @@
+452\. Minimum Number of Arrows to Burst Balloons
+
+Medium
+
+There are some spherical balloons taped onto a flat wall that represents the XY-plane. The balloons are represented as a 2D integer array `points` where <code>points[i] = [x<sub>start</sub>, x<sub>end</sub>]</code> denotes a balloon whose **horizontal diameter** stretches between <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code>. You do not know the exact y-coordinates of the balloons.
+
+Arrows can be shot up **directly vertically** (in the positive y-direction) from different points along the x-axis. A balloon with <code>x<sub>start</sub></code> and <code>x<sub>end</sub></code> is **burst** by an arrow shot at `x` if <code>x<sub>start</sub> <= x <= x<sub>end</sub></code>. There is **no limit** to the number of arrows that can be shot. A shot arrow keeps traveling up infinitely, bursting any balloons in its path.
+
+Given the array `points`, return _the **minimum** number of arrows that must be shot to burst all balloons_.
+
+**Example 1:**
+
+**Input:** points = [[10,16],[2,8],[1,6],[7,12]]
+
+**Output:** 2
+
+**Explanation:** The balloons can be burst by 2 arrows:
+
+- Shoot an arrow at x = 6, bursting the balloons [2,8] and [1,6].
+
+- Shoot an arrow at x = 11, bursting the balloons [10,16] and [7,12].
+
+**Example 2:**
+
+**Input:** points = [[1,2],[3,4],[5,6],[7,8]]
+
+**Output:** 4
+
+**Explanation:** One arrow needs to be shot for each balloon for a total of 4 arrows.
+
+**Example 3:**
+
+**Input:** points = [[1,2],[2,3],[3,4],[4,5]]
+
+**Output:** 2
+
+**Explanation:** The balloons can be burst by 2 arrows:
+
+- Shoot an arrow at x = 2, bursting the balloons [1,2] and [2,3].
+
+- Shoot an arrow at x = 4, bursting the balloons [3,4] and [4,5].
+
+**Constraints:**
+
+*   <code>1 <= points.length <= 10<sup>5</sup></code>
+*   `points[i].length == 2`
+*   <code>-2<sup>31</sup> <= x<sub>start</sub> < x<sub>end</sub> <= 2<sup>31</sup> - 1</code>

src/main/kotlin/g0401_0500/s0453_minimum_moves_to_equal_array_elements/Solution.kt

@@ -0,0 +1,16 @@
+package g0401_0500.s0453_minimum_moves_to_equal_array_elements
+
+// #Medium #Array #Math #2022_12_25_Time_282_ms_(100.00%)_Space_38.7_MB_(88.89%)
+
+class Solution {
+    fun minMoves(nums: IntArray): Int {
+        var min = nums[0]
+        var sum = nums[0]
+        // determining the total sum and smallest element of the input array
+        for (i in 1..nums.size - 1) {
+            sum += nums[i]
+            min = Math.min(min, nums[i])
+        }
+        return sum - min * nums.size
+    }
+}

src/main/kotlin/g0401_0500/s0453_minimum_moves_to_equal_array_elements/readme.md

@@ -0,0 +1,28 @@
+453\. Minimum Moves to Equal Array Elements
+
+Medium
+
+Given an integer array `nums` of size `n`, return _the minimum number of moves required to make all array elements equal_.
+
+In one move, you can increment `n - 1` elements of the array by `1`.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3]
+
+**Output:** 3
+
+**Explanation:** Only three moves are needed (remember each move increments two elements): [1,2,3] => [2,3,3] => [3,4,3] => [4,4,4]
+
+**Example 2:**
+
+**Input:** nums = [1,1,1]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= nums.length <= 10<sup>5</sup></code>
+*   <code>-10<sup>9</sup> <= nums[i] <= 10<sup>9</sup></code>
+*   The answer is guaranteed to fit in a **32-bit** integer.

src/test/kotlin/g0401_0500/s0450_delete_node_in_a_bst/SolutionTest.kt

@@ -0,0 +1,27 @@
+package g0401_0500.s0450_delete_node_in_a_bst
+
+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 deleteNode() {
+        val input: TreeNode? = TreeNode.create(listOf(5, 3, 6, 2, 4, null, 7))
+        val expected: TreeNode? = TreeNode.create(listOf(5, 4, 6, 2, null, null, 7))
+        assertThat(Solution().deleteNode(input, 3).toString(), equalTo(expected.toString()))
+    }
+
+    @Test
+    fun deleteNode2() {
+        val input: TreeNode? = TreeNode.create(listOf(5, 3, 6, 2, 4, null, 7))
+        val expected: TreeNode? = TreeNode.create(listOf(5, 3, 6, 2, 4, null, 7))
+        assertThat(Solution().deleteNode(input, 0).toString(), equalTo(expected.toString()))
+    }
+
+    @Test
+    fun deleteNode3() {
+        assertThat(Solution().deleteNode(null, 0), equalTo(null))
+    }
+}