Added tasks 632, 633, 636, 637

Author: ThanhNIT

README.md

@@ -1316,6 +1316,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
 | 0350 |[Intersection of Two Arrays II](src.save/main/kotlin/g0301_0400/s0350_intersection_of_two_arrays_ii/Solution.kt)| Easy | Top_Interview_Questions, Array, Hash_Table, Sorting, Binary_Search, Two_Pointers | 321 | 73.37
+| 0633 |[Sum of Square Numbers](src/main/kotlin/g0601_0700/s0633_sum_of_square_numbers/Solution.kt)| Medium | Math, Binary_Search, Two_Pointers | 126 | 100.00
 
 #### Day 11
 
@@ -1673,6 +1674,10 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.9'
 | 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
 | 0647 |[Palindromic Substrings](src/main/kotlin/g0601_0700/s0647_palindromic_substrings/Solution.kt)| Medium | Top_100_Liked_Questions, String, Dynamic_Programming | 266 | 67.83
+| 0637 |[Average of Levels in Binary Tree](src/main/kotlin/g0601_0700/s0637_average_of_levels_in_binary_tree/Solution.kt)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 249 | 100.00
+| 0636 |[Exclusive Time of Functions](src/main/kotlin/g0601_0700/s0636_exclusive_time_of_functions/Solution.kt)| Medium | Array, Stack | 270 | 80.00
+| 0633 |[Sum of Square Numbers](src/main/kotlin/g0601_0700/s0633_sum_of_square_numbers/Solution.kt)| Medium | Math, Binary_Search, Two_Pointers, Binary_Search_I_Day_10 | 126 | 100.00
+| 0632 |[Smallest Range Covering Elements from K Lists](src/main/kotlin/g0601_0700/s0632_smallest_range_covering_elements_from_k_lists/Solution.kt)| Hard | Array, Hash_Table, Sorting, Greedy, Heap_Priority_Queue, Sliding_Window | 399 | 83.33
 | 0630 |[Course Schedule III](src/main/kotlin/g0601_0700/s0630_course_schedule_iii/Solution.kt)| Hard | Array, Greedy, Heap_Priority_Queue | 536 | 100.00
 | 0629 |[K Inverse Pairs Array](src/main/kotlin/g0601_0700/s0629_k_inverse_pairs_array/Solution.kt)| Hard | Dynamic_Programming | 155 | 100.00
 | 0628 |[Maximum Product of Three Numbers](src/main/kotlin/g0601_0700/s0628_maximum_product_of_three_numbers/Solution.kt)| Easy | Array, Math, Sorting | 276 | 97.30

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

@@ -0,0 +1,50 @@
+package g0601_0700.s0632_smallest_range_covering_elements_from_k_lists
+
+// #Hard #Array #Hash_Table #Sorting #Greedy #Heap_Priority_Queue #Sliding_Window
+// #2023_02_09_Time_399_ms_(83.33%)_Space_59.2_MB_(66.67%)
+
+import java.util.Objects
+import java.util.PriorityQueue
+
+class Solution {
+    internal class Triplet(var value: Int, var row: Int, var idx: Int) : Comparable<Triplet?> {
+        override operator fun compareTo(other: Triplet?): Int {
+            return value - other!!.value
+        }
+    }
+
+    fun smallestRange(nums: List<List<Int>>): IntArray {
+        val pq = PriorityQueue<Triplet>()
+        var maxInPq = Int.MIN_VALUE
+        for (i in nums.indices) {
+            pq.add(Triplet(nums[i][0], i, 0))
+            if (maxInPq < nums[i][0]) {
+                maxInPq = nums[i][0]
+            }
+        }
+        var rangeSize = maxInPq - Objects.requireNonNull(pq.peek()).value + 1
+        var rangeLeft = Objects.requireNonNull(pq.peek()).value
+        var rangeRight = maxInPq
+        while (true) {
+            val nextNumber = pq.remove()
+            if (nextNumber.idx + 1 < nums[nextNumber.row].size) {
+                val `val` = nums[nextNumber.row][nextNumber.idx + 1]
+                if (`val` > maxInPq) {
+                    maxInPq = `val`
+                }
+                pq.add(Triplet(`val`, nextNumber.row, nextNumber.idx + 1))
+                if (maxInPq - Objects.requireNonNull(pq.peek()).value + 1 < rangeSize) {
+                    rangeSize = maxInPq - pq.peek().value + 1
+                    rangeLeft = maxInPq
+                    rangeRight = pq.peek().value
+                }
+            } else {
+                break
+            }
+        }
+        val answer = IntArray(2)
+        answer[0] = rangeLeft
+        answer[1] = rangeRight
+        return answer
+    }
+}

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

@@ -0,0 +1,35 @@
+632\. Smallest Range Covering Elements from K Lists
+
+Hard
+
+You have `k` lists of sorted integers in **non-decreasing order**. Find the **smallest** range that includes at least one number from each of the `k` lists.
+
+We define the range `[a, b]` is smaller than range `[c, d]` if `b - a < d - c` **or** `a < c` if `b - a == d - c`.
+
+**Example 1:**
+
+**Input:** nums = [[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]
+
+**Output:** [20,24]
+
+**Explanation:**  
+
+List 1: [4, 10, 15, 24,26], 24 is in range [20,24]. 
+
+List 2: [0, 9, 12, 20], 20 is in range [20,24]. 
+
+List 3: [5, 18, 22, 30], 22 is in range [20,24].
+
+**Example 2:**
+
+**Input:** nums = [[1,2,3],[1,2,3],[1,2,3]]
+
+**Output:** [1,1]
+
+**Constraints:**
+
+*   `nums.length == k`
+*   `1 <= k <= 3500`
+*   `1 <= nums[i].length <= 50`
+*   <code>-10<sup>5</sup> <= nums[i][j] <= 10<sup>5</sup></code>
+*   `nums[i]` is sorted in **non-decreasing** order.

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

@@ -0,0 +1,20 @@
+package g0601_0700.s0633_sum_of_square_numbers
+
+// #Medium #Math #Binary_Search #Two_Pointers #Binary_Search_I_Day_10
+// #2023_02_09_Time_126_ms_(100.00%)_Space_33_MB_(90.00%)
+
+import kotlin.math.sqrt
+
+class Solution {
+    fun judgeSquareSum(c: Int): Boolean {
+        val right = sqrt(c.toDouble()).toInt()
+        val left = sqrt(c.toDouble() / 2).toInt()
+        for (i in left..right) {
+            val j = sqrt(c - (i * i).toDouble()).toInt()
+            if (i * i + j * j == c) {
+                return true
+            }
+        }
+        return false
+    }
+}

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

@@ -0,0 +1,23 @@
+633\. Sum of Square Numbers
+
+Medium
+
+Given a non-negative integer `c`, decide whether there're two integers `a` and `b` such that <code>a<sup>2</sup> + b<sup>2</sup> = c</code>.
+
+**Example 1:**
+
+**Input:** c = 5
+
+**Output:** true
+
+**Explanation:** 1 \* 1 + 2 \* 2 = 5
+
+**Example 2:**
+
+**Input:** c = 3
+
+**Output:** false
+
+**Constraints:**
+
+*   <code>0 <= c <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,41 @@
+package g0601_0700.s0636_exclusive_time_of_functions
+
+// #Medium #Array #Stack #2023_02_10_Time_270_ms_(80.00%)_Space_37.3_MB_(20.00%)
+
+import java.util.ArrayDeque
+import java.util.Deque
+
+class Solution {
+    fun exclusiveTime(n: Int, logs: List<String>): IntArray {
+        val stack: Deque<Log> = ArrayDeque()
+        val result = IntArray(n)
+        for (content in logs) {
+            val log = Log(content)
+            if (log.isStart) {
+                stack.push(log)
+            } else {
+                val top = stack.pop()
+                val executionTime = log.time - top.time + 1
+                result[top.id] += executionTime - top.waitingTime
+                if (!stack.isEmpty()) {
+                    stack.peek().waitingTime += executionTime
+                }
+            }
+        }
+        return result
+    }
+
+    private class Log internal constructor(content: String) {
+        var id: Int
+        var isStart: Boolean
+        var time: Int
+        var waitingTime: Int
+        init {
+            val tokens = content.split(":".toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
+            id = tokens[0].toInt()
+            isStart = tokens[1] == "start"
+            time = tokens[2].toInt()
+            waitingTime = 0
+        }
+    }
+}

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

@@ -0,0 +1,81 @@
+636\. Exclusive Time of Functions
+
+Medium
+
+On a **single-threaded** CPU, we execute a program containing `n` functions. Each function has a unique ID between `0` and `n-1`.
+
+Function calls are **stored in a [call stack](https://en.wikipedia.org/wiki/Call_stack)**: when a function call starts, its ID is pushed onto the stack, and when a function call ends, its ID is popped off the stack. The function whose ID is at the top of the stack is **the current function being executed**. Each time a function starts or ends, we write a log with the ID, whether it started or ended, and the timestamp.
+
+You are given a list `logs`, where `logs[i]` represents the <code>i<sup>th</sup></code> log message formatted as a string `"{function_id}:{"start" | "end"}:{timestamp}"`. For example, `"0:start:3"` means a function call with function ID `0` **started at the beginning** of timestamp `3`, and `"1:end:2"` means a function call with function ID `1` **ended at the end** of timestamp `2`. Note that a function can be called **multiple times, possibly recursively**.
+
+A function's **exclusive time** is the sum of execution times for all function calls in the program. For example, if a function is called twice, one call executing for `2` time units and another call executing for `1` time unit, the **exclusive time** is `2 + 1 = 3`.
+
+Return _the **exclusive time** of each function in an array, where the value at the_ <code>i<sup>th</sup></code> _index represents the exclusive time for the function with ID_ `i`.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2019/04/05/diag1b.png)
+
+**Input:** n = 2, logs = ["0:start:0","1:start:2","1:end:5","0:end:6"]
+
+**Output:** [3,4]
+
+**Explanation:**
+
+Function 0 starts at the beginning of time 0, then it executes 2 for units of time and reaches the end of time 1.
+
+Function 1 starts at the beginning of time 2, executes for 4 units of time, and ends at the end of time 5.
+
+Function 0 resumes execution at the beginning of time 6 and executes for 1 unit of time.
+
+So function 0 spends 2 + 1 = 3 units of total time executing, and function 1 spends 4 units of total time executing.
+
+**Example 2:**
+
+**Input:** n = 1, logs = ["0:start:0","0:start:2","0:end:5","0:start:6","0:end:6","0:end:7"]
+
+**Output:** [8]
+
+**Explanation:**
+
+Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
+
+Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
+
+Function 0 (initial call) resumes execution then immediately calls itself again.
+
+Function 0 (2nd recursive call) starts at the beginning of time 6 and executes for 1 unit of time.
+
+Function 0 (initial call) resumes execution at the beginning of time 7 and executes for 1 unit of time.
+
+So function 0 spends 2 + 4 + 1 + 1 = 8 units of total time executing.
+
+**Example 3:**
+
+**Input:** n = 2, logs = ["0:start:0","0:start:2","0:end:5","1:start:6","1:end:6","0:end:7"]
+
+**Output:** [7,1]
+
+**Explanation:**
+
+Function 0 starts at the beginning of time 0, executes for 2 units of time, and recursively calls itself.
+
+Function 0 (recursive call) starts at the beginning of time 2 and executes for 4 units of time.
+
+Function 0 (initial call) resumes execution then immediately calls function 1.
+
+Function 1 starts at the beginning of time 6, executes 1 unit of time, and ends at the end of time 6.
+
+Function 0 resumes execution at the beginning of time 6 and executes for 2 units of time.
+
+So function 0 spends 2 + 4 + 1 = 7 units of total time executing, and function 1 spends 1 unit of total time executing.
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   `1 <= logs.length <= 500`
+*   `0 <= function_id < n`
+*   <code>0 <= timestamp <= 10<sup>9</sup></code>
+*   No two start events will happen at the same timestamp.
+*   No two end events will happen at the same timestamp.
+*   Each function has an `"end"` log for each `"start"` log.

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

@@ -0,0 +1,41 @@
+package g0601_0700.s0637_average_of_levels_in_binary_tree
+
+// #Easy #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree
+// #2023_02_10_Time_249_ms_(100.00%)_Space_39.5_MB_(72.73%)
+
+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 averageOfLevels(root: TreeNode?): List<Double> {
+        val map: MutableMap<Int, Array<Double>> = HashMap()
+        helper(root, map, 0)
+        val result: MutableList<Double> = ArrayList()
+        for (pair in map.values) {
+            val avg = pair[1] / pair[0]
+            result.add(avg)
+        }
+        return result
+    }
+
+    private fun helper(root: TreeNode?, map: MutableMap<Int, Array<Double>>, level: Int) {
+        if (root == null) {
+            return
+        }
+        val pair = if (map.containsKey(level)) map[level]!! else arrayOf(0.0, 0.0)
+        pair[0] += 1.0
+        pair[1] = pair[1] + root.`val`
+        map[level] = pair
+        helper(root.left, map, level + 1)
+        helper(root.right, map, level + 1)
+    }
+}

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

@@ -0,0 +1,26 @@
+637\. Average of Levels in Binary Tree
+
+Easy
+
+Given the `root` of a binary tree, return _the average value of the nodes on each level in the form of an array_. Answers within <code>10<sup>-5</sup></code> of the actual answer will be accepted.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg1-tree.jpg)
+
+**Input:** root = [3,9,20,null,null,15,7]
+
+**Output:** [3.00000,14.50000,11.00000] Explanation: The average value of nodes on level 0 is 3, on level 1 is 14.5, and on level 2 is 11. Hence return [3, 14.5, 11].
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/03/09/avg2-tree.jpg)
+
+**Input:** root = [3,9,20,15,7]
+
+**Output:** [3.00000,14.50000,11.00000]
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[1, 10<sup>4</sup>]</code>.
+*   <code>-2<sup>31</sup> <= Node.val <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,37 @@
+package g0601_0700.s0632_smallest_range_covering_elements_from_k_lists
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun smallestRange() {
+        assertThat(
+            Solution()
+                .smallestRange(
+                    listOf(
+                        listOf(4, 10, 15, 24, 26),
+                        listOf(0, 9, 12, 20),
+                        listOf(5, 18, 22, 30)
+                    )
+                ),
+            equalTo(intArrayOf(24, 20))
+        )
+    }
+
+    @Test
+    fun smallestRange2() {
+        assertThat(
+            Solution()
+                .smallestRange(
+                    listOf(
+                        listOf(1, 2, 3),
+                        listOf(1, 2, 3),
+                        listOf(1, 2, 3)
+                    )
+                ),
+            equalTo(intArrayOf(1, 1))
+        )
+    }
+}