Added tasks 421, 423, 424, 427.

Author: ThanhNIT

README.md

@@ -595,6 +595,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window | 561 | 54.68
+| 0424 |[Longest Repeating Character Replacement](src/main/kotlin/g0401_0500/s0424_longest_repeating_character_replacement/Solution.kt)| Medium | String, Hash_Table, Sliding_Window | 288 | 84.38
 
 #### Day 13 Hashmap
 
@@ -1627,6 +1628,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 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
 | 0438 |[Find All Anagrams in a String](src/main/kotlin/g0401_0500/s0438_find_all_anagrams_in_a_string/Solution.kt)| Medium | Top_100_Liked_Questions, String, Hash_Table, Sliding_Window, Algorithm_II_Day_5_Sliding_Window, Programming_Skills_II_Day_12, Level_1_Day_12_Sliding_Window/Two_Pointer | 561 | 54.68
 | 0437 |[Path Sum III](src/main/kotlin/g0401_0500/s0437_path_sum_iii/Solution.kt)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Level_2_Day_7_Tree | 403 | 54.12
+| 0427 |[Construct Quad Tree](src/main/kotlin/g0401_0500/s0427_construct_quad_tree/Solution.kt)| Medium | Array, Tree, Matrix, Divide_and_Conquer | 221 | 94.74
+| 0424 |[Longest Repeating Character Replacement](src/main/kotlin/g0401_0500/s0424_longest_repeating_character_replacement/Solution.kt)| Medium | String, Hash_Table, Sliding_Window, Level_1_Day_12_Sliding_Window/Two_Pointer | 288 | 84.38
+| 0423 |[Reconstruct Original Digits from English](src/main/kotlin/g0401_0500/s0423_reconstruct_original_digits_from_english/Solution.kt)| Medium | String, Hash_Table, Math | 349 | 100.00
+| 0421 |[Maximum XOR of Two Numbers in an Array](src/main/kotlin/g0401_0500/s0421_maximum_xor_of_two_numbers_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Bit_Manipulation, Trie | 710 | 100.00
 | 0420 |[Strong Password Checker](src/main/kotlin/g0401_0500/s0420_strong_password_checker/Solution.kt)| Hard | String, Greedy, Heap_Priority_Queue | 157 | 80.00
 | 0419 |[Battleships in a Board](src/main/kotlin/g0401_0500/s0419_battleships_in_a_board/Solution.kt)| Medium | Array, Depth_First_Search, Matrix | 273 | 76.92
 | 0417 |[Pacific Atlantic Water Flow](src/main/kotlin/g0401_0500/s0417_pacific_atlantic_water_flow/Solution.kt)| Medium | Array, Depth_First_Search, Breadth_First_Search, Matrix, Graph_Theory_I_Day_4_Matrix_Related_Problems, Level_2_Day_10_Graph/BFS/DFS, Udemy_Graph | 319 | 100.00

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

@@ -0,0 +1,30 @@
+package g0401_0500.s0421_maximum_xor_of_two_numbers_in_an_array
+
+// #Medium #Array #Hash_Table #Bit_Manipulation #Trie
+// #2022_12_08_Time_710_ms_(100.00%)_Space_68_MB_(100.00%)
+
+class Solution {
+    fun findMaximumXOR(nums: IntArray): Int {
+        var max = 0
+        var mask = 0
+        val set: MutableSet<Int> = HashSet()
+        var maxNum = 0
+        for (i in nums) {
+            maxNum = Math.max(maxNum, i)
+        }
+        for (i in 31 - Integer.numberOfLeadingZeros(maxNum) downTo 0) {
+            set.clear()
+            val bit = 1 shl i
+            mask = mask or bit
+            val temp = max or bit
+            for (prefix in nums) {
+                if (set.contains(prefix and mask xor temp)) {
+                    max = temp
+                    break
+                }
+                set.add(prefix and mask)
+            }
+        }
+        return max
+    }
+}

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

@@ -0,0 +1,24 @@
+421\. Maximum XOR of Two Numbers in an Array
+
+Medium
+
+Given an integer array `nums`, return _the maximum result of_ `nums[i] XOR nums[j]`, where `0 <= i <= j < n`.
+
+**Example 1:**
+
+**Input:** nums = [3,10,5,25,2,8]
+
+**Output:** 28
+
+**Explanation:** The maximum result is 5 XOR 25 = 28.
+
+**Example 2:**
+
+**Input:** nums = [14,70,53,83,49,91,36,80,92,51,66,70]
+
+**Output:** 127
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 2 * 10<sup>5</sup></code>
+*   <code>0 <= nums[i] <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,30 @@
+package g0401_0500.s0423_reconstruct_original_digits_from_english
+
+// #Medium #String #Hash_Table #Math #2022_12_08_Time_349_ms_(100.00%)_Space_47.5_MB_(100.00%)
+
+class Solution {
+    fun originalDigits(s: String): String {
+        val count = IntArray(26)
+        val digits = IntArray(10)
+        val str = StringBuilder()
+        for (c in s.toCharArray()) {
+            ++count[c.code - 'a'.code]
+        }
+        digits[0] = count[25]
+        digits[2] = count[22]
+        digits[4] = count[20]
+        digits[6] = count[23]
+        digits[8] = count[6]
+        digits[1] = count[14] - digits[0] - digits[2] - digits[4]
+        digits[3] = count[7] - digits[8]
+        digits[5] = count[5] - digits[4]
+        digits[7] = count[18] - digits[6]
+        digits[9] = count[8] - digits[5] - digits[6] - digits[8]
+        for (i in 0..9) {
+            while (digits[i]-- != 0) {
+                str.append((i + 48).toChar())
+            }
+        }
+        return str.toString()
+    }
+}

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

@@ -0,0 +1,23 @@
+423\. Reconstruct Original Digits from English
+
+Medium
+
+Given a string `s` containing an out-of-order English representation of digits `0-9`, return _the digits in **ascending** order_.
+
+**Example 1:**
+
+**Input:** s = "owoztneoer"
+
+**Output:** "012"
+
+**Example 2:**
+
+**Input:** s = "fviefuro"
+
+**Output:** "45"
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s[i]` is one of the characters `["e","g","f","i","h","o","n","s","r","u","t","w","v","x","z"]`.
+*   `s` is **guaranteed** to be valid.

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

@@ -0,0 +1,32 @@
+package g0401_0500.s0424_longest_repeating_character_replacement
+
+// #Medium #String #Hash_Table #Sliding_Window #Level_1_Day_12_Sliding_Window/Two_Pointer
+// #2022_12_08_Time_288_ms_(84.38%)_Space_38.2_MB_(65.18%)
+
+class Solution {
+    fun characterReplacement(s: String, k: Int): Int {
+        var left = 0
+        var right = 0
+        val len = s.length
+        val count = IntArray(256)
+        val sArr = s.toCharArray()
+        var currMax = 0
+        var maxLen = 0
+        var curr: Char
+        while (right < len) {
+            curr = sArr[right]
+            count[curr.code]++
+            currMax = Math.max(currMax, count[curr.code])
+            if (right - left + 1 <= currMax + k) {
+                maxLen = Math.max(maxLen, right - left + 1)
+            }
+            while (right - left + 1 > currMax + k) {
+                curr = sArr[left]
+                count[curr.code]--
+                left++
+            }
+            right++
+        }
+        return maxLen
+    }
+}

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

@@ -0,0 +1,29 @@
+424\. Longest Repeating Character Replacement
+
+Medium
+
+You are given a string `s` and an integer `k`. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most `k` times.
+
+Return _the length of the longest substring containing the same letter you can get after performing the above operations_.
+
+**Example 1:**
+
+**Input:** s = "ABAB", k = 2
+
+**Output:** 4
+
+**Explanation:** Replace the two 'A's with two 'B's or vice versa.
+
+**Example 2:**
+
+**Input:** s = "AABABBA", k = 1
+
+**Output:** 4
+
+**Explanation:** Replace the one 'A' in the middle with 'B' and form "AABBBBA". The substring "BBBB" has the longest repeating letters, which is 4.
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>5</sup></code>
+*   `s` consists of only uppercase English letters.
+*   `0 <= k <= s.length`

src/main/kotlin/g0401_0500/s0427_construct_quad_tree/Node.kt

@@ -0,0 +1,29 @@
+package g0401_0500.s0427_construct_quad_tree
+
+class Node(var `val`: Boolean, var isLeaf: Boolean) {
+    var topLeft: Node?
+    var topRight: Node?
+    var bottomLeft: Node?
+    var bottomRight: Node?
+
+    init {
+        topLeft = null
+        topRight = null
+        bottomLeft = null
+        bottomRight = null
+    }
+
+    override fun toString(): String {
+        return (
+            getNode(this) +
+                getNode(topLeft) +
+                getNode(topRight) +
+                getNode(bottomLeft) +
+                getNode(bottomRight)
+            )
+    }
+
+    private fun getNode(node: Node?): String {
+        return "[" + (if (node!!.isLeaf) "1" else "0") + "," + (if (node.`val`) "1" else "0") + "]"
+    }
+}

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

@@ -0,0 +1,43 @@
+package g0401_0500.s0427_construct_quad_tree
+
+// #Medium #Array #Tree #Matrix #Divide_and_Conquer
+// #2022_12_08_Time_221_ms_(94.74%)_Space_36.9_MB_(94.74%)
+
+/*
+ * Definition for a QuadTree node.
+ * class Node(var `val`: Boolean, var isLeaf: Boolean) {
+ *     var topLeft: Node? = null
+ *     var topRight: Node? = null
+ *     var bottomLeft: Node? = null
+ *     var bottomRight: Node? = null
+ * }
+ */
+
+class Solution {
+    fun construct(grid: Array<IntArray>): Node? {
+        return construct(grid, 0, 0, grid.size)
+    }
+
+    fun construct(grid: Array<IntArray>, x: Int, y: Int, len: Int): Node? {
+        val value: Int = grid[x][y]
+        if (len == 1) { return Node(value == 1, true) }
+
+        var isLeaf = true
+        for (i in 0 until len) {
+            for (p in 0 until len) {
+                if (grid[x + i][y + p] != value) {
+                    isLeaf = false
+                }
+            }
+        }
+        if (isLeaf) { return Node(value == 1, true) }
+
+        return Node(true, false).apply {
+            val halfLength: Int = len / 2
+            topLeft = construct(grid, x, y, halfLength)
+            topRight = construct(grid, x, y + halfLength, halfLength)
+            bottomLeft = construct(grid, x + halfLength, y, halfLength)
+            bottomRight = construct(grid, x + halfLength, y + halfLength, halfLength)
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+427\. Construct Quad Tree
+
+Medium
+
+Given a `n * n` matrix `grid` of `0's` and `1's` only. We want to represent the `grid` with a Quad-Tree.
+
+Return _the root of the Quad-Tree_ representing the `grid`.
+
+Notice that you can assign the value of a node to **True** or **False** when `isLeaf` is **False**, and both are **accepted** in the answer.
+
+A Quad-Tree is a tree data structure in which each internal node has exactly four children. Besides, each node has two attributes:
+
+*   `val`: True if the node represents a grid of 1's or False if the node represents a grid of 0's.
+*   `isLeaf`: True if the node is leaf node on the tree or False if the node has the four children.
+
+class Node { public boolean val; public boolean isLeaf; public Node topLeft; public Node topRight; public Node bottomLeft; public Node bottomRight; }
+
+We can construct a Quad-Tree from a two-dimensional area using the following steps:
+
+1.  If the current grid has the same value (i.e all `1's` or all `0's`) set `isLeaf` True and set `val` to the value of the grid and set the four children to Null and stop.
+2.  If the current grid has different values, set `isLeaf` to False and set `val` to any value and divide the current grid into four sub-grids as shown in the photo.
+3.  Recurse for each of the children with the proper sub-grid.
+
+![](https://assets.leetcode.com/uploads/2020/02/11/new_top.png)
+
+If you want to know more about the Quad-Tree, you can refer to the [wiki](https://en.wikipedia.org/wiki/Quadtree).
+
+**Quad-Tree format:**
+
+The output represents the serialized format of a Quad-Tree using level order traversal, where `null` signifies a path terminator where no node exists below.
+
+It is very similar to the serialization of the binary tree. The only difference is that the node is represented as a list `[isLeaf, val]`.
+
+If the value of `isLeaf` or `val` is True we represent it as **1** in the list `[isLeaf, val]` and if the value of `isLeaf` or `val` is False we represent it as **0**.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/02/11/grid1.png)
+
+**Input:** grid = [[0,1],[1,0]]
+
+**Output:** [[0,1],[1,0],[1,1],[1,1],[1,0]]
+
+**Explanation:** The explanation of this example is shown below: Notice that 0 represnts False and 1 represents True in the photo representing the Quad-Tree. ![](https://assets.leetcode.com/uploads/2020/02/12/e1tree.png)
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/02/12/e2mat.png)
+
+**Input:** grid =
+    
+    [[1,1,1,1,0,0,0,0],
+    [1,1,1,1,0,0,0,0],
+    [1,1,1,1,1,1,1,1],
+    [1,1,1,1,1,1,1,1],
+    [1,1,1,1,0,0,0,0],
+    [1,1,1,1,0,0,0,0],
+    [1,1,1,1,0,0,0,0],
+    [1,1,1,1,0,0,0,0]]
+
+**Output:** [[0,1],[1,1],[0,1],[1,1],[1,0],null,null,null,null,[1,0],[1,0],[1,1],[1,1]]
+
+**Explanation:** All values in the grid are not the same. We divide the grid into four sub-grids. The topLeft, bottomLeft and bottomRight each has the same value. The topRight have different values so we divide it into 4 sub-grids where each has the same value. Explanation is shown in the photo below: ![](https://assets.leetcode.com/uploads/2020/02/12/e2tree.png)
+
+**Constraints:**
+
+*   `n == grid.length == grid[i].length`
+*   <code>n == 2<sup>x</sup></code> where `0 <= x <= 6`