Added tasks 446, 447, 448, 449.

Author: ThanhNIT

README.md

@@ -810,6 +810,7 @@ implementation 'com.github.javadev:leetcode-in-kotlin:1.7'
 | 0075 |[Sort Colors](src.save/main/kotlin/g0001_0100/s0075_sort_colors/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Sorting, Two_Pointers | 198 | 85.66
 | 0066 |[Plus One](src.save/main/kotlin/g0001_0100/s0066_plus_one/Solution.kt)| Easy | Top_Interview_Questions, Array, Math | 303 | 35.18
 | 0238 |[Product of Array Except Self](src.save/main/kotlin/g0201_0300/s0238_product_of_array_except_self/Solution.kt)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Prefix_Sum | 669 | 48.96
+| 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 | 394 | 100.00
 | 0442 |[Find All Duplicates in an Array](src/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table | 480 | 73.81
 | 0041 |[First Missing Positive](src.save/main/kotlin/g0001_0100/s0041_first_missing_positive/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table | 345 | 100.00
 | 0239 |[Sliding Window Maximum](src.save/main/kotlin/g0201_0300/s0239_sliding_window_maximum/Solution.kt)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Heap_Priority_Queue, Sliding_Window, Queue, Monotonic_Queue | 1059 | 86.14
@@ -1634,6 +1635,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
+| 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
+| 0446 |[Arithmetic Slices II - Subsequence](src/main/kotlin/g0401_0500/s0446_arithmetic_slices_ii_subsequence/Solution.kt)| Hard | Array, Dynamic_Programming | 312 | 100.00
 | 0445 |[Add Two Numbers II](src/main/kotlin/g0401_0500/s0445_add_two_numbers_ii/Solution.kt)| Medium | Math, Stack, Linked_List, Programming_Skills_II_Day_15, Udemy_Linked_List | 240 | 82.61
 | 0443 |[String Compression](src/main/kotlin/g0401_0500/s0443_string_compression/Solution.kt)| Medium | String, Two_Pointers | 198 | 92.68
 | 0442 |[Find All Duplicates in an Array](src/main/kotlin/g0401_0500/s0442_find_all_duplicates_in_an_array/Solution.kt)| Medium | Array, Hash_Table, Udemy_Arrays | 480 | 73.81

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

@@ -0,0 +1,24 @@
+package g0401_0500.s0446_arithmetic_slices_ii_subsequence
+
+// #Hard #Array #Dynamic_Programming #2022_12_24_Time_312_ms_(100.00%)_Space_45.3_MB_(98.59%)
+
+class Solution {
+    fun numberOfArithmeticSlices(arr: IntArray): Int {
+        val indexes: MutableMap<Long, MutableList<Int>> = HashMap()
+        val length = Array(arr.size) { IntArray(arr.size) }
+        var count = 0
+        for (i in arr.indices) {
+            for (j in i + 1 until arr.size) {
+                val ix = indexes[arr[i] - (arr[j] - arr[i].toLong())] ?: continue
+                for (k in ix) {
+                    length[i][j] += length[k][i] + 1
+                }
+                count += length[i][j]
+            }
+            indexes.computeIfAbsent(
+                arr[i].toLong()
+            ) { _: Long? -> ArrayList() }.add(i)
+        }
+        return count
+    }
+}

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

@@ -0,0 +1,51 @@
+446\. Arithmetic Slices II - Subsequence
+
+Hard
+
+Given an integer array `nums`, return _the number of all the **arithmetic subsequences** of_ `nums`.
+
+A sequence of numbers is called arithmetic if it consists of **at least three elements** and if the difference between any two consecutive elements is the same.
+
+*   For example, `[1, 3, 5, 7, 9]`, `[7, 7, 7, 7]`, and `[3, -1, -5, -9]` are arithmetic sequences.
+*   For example, `[1, 1, 2, 5, 7]` is not an arithmetic sequence.
+
+A **subsequence** of an array is a sequence that can be formed by removing some elements (possibly none) of the array.
+
+*   For example, `[2,5,10]` is a subsequence of `[1,2,1,**2**,4,1,**5**,**10**]`.
+
+The test cases are generated so that the answer fits in **32-bit** integer.
+
+**Example 1:**
+
+**Input:** nums = [2,4,6,8,10]
+
+**Output:** 7
+
+**Explanation:** All arithmetic subsequence slices are:
+
+[2,4,6]
+
+[4,6,8]
+
+[6,8,10]
+
+[2,4,6,8]
+
+[4,6,8,10]
+
+[2,4,6,8,10]
+
+[2,6,10]
+
+**Example 2:**
+
+**Input:** nums = [7,7,7,7,7]
+
+**Output:** 16
+
+**Explanation:** Any subsequence of this array is arithmetic.
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>

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

@@ -0,0 +1,29 @@
+package g0401_0500.s0447_number_of_boomerangs
+
+// #Medium #Array #Hash_Table #Math #2022_12_24_Time_308_ms_(100.00%)_Space_41.1_MB_(100.00%)
+
+class Solution {
+    fun numberOfBoomerangs(points: Array<IntArray>): Int {
+        val m: HashMap<Int, Int> = HashMap()
+        var ans = 0
+        for (i in points.indices) {
+            for (j in points.indices) {
+                if (i == j) {
+                    continue
+                }
+                val dis = dist(points[i], points[j])
+                val prev = m.getOrDefault(dis, 0)
+                if (prev >= 1) {
+                    ans += prev * 2
+                }
+                m[dis] = prev + 1
+            }
+            m.clear()
+        }
+        return ans
+    }
+
+    private fun dist(d1: IntArray, d2: IntArray): Int {
+        return (d1[0] - d2[0]) * (d1[0] - d2[0]) + (d1[1] - d2[1]) * (d1[1] - d2[1])
+    }
+}

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

@@ -0,0 +1,35 @@
+447\. Number of Boomerangs
+
+Medium
+
+You are given `n` `points` in the plane that are all **distinct**, where <code>points[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>. A **boomerang** is a tuple of points `(i, j, k)` such that the distance between `i` and `j` equals the distance between `i` and `k` **(the order of the tuple matters)**.
+
+Return _the number of boomerangs_.
+
+**Example 1:**
+
+**Input:** points = [[0,0],[1,0],[2,0]]
+
+**Output:** 2
+
+**Explanation:** The two boomerangs are [[1,0],[0,0],[2,0]] and [[1,0],[2,0],[0,0]].
+
+**Example 2:**
+
+**Input:** points = [[1,1],[2,2],[3,3]]
+
+**Output:** 2
+
+**Example 3:**
+
+**Input:** points = [[1,1]]
+
+**Output:** 0
+
+**Constraints:**
+
+*   `n == points.length`
+*   `1 <= n <= 500`
+*   `points[i].length == 2`
+*   <code>-10<sup>4</sup> <= x<sub>i</sub>, y<sub>i</sub> <= 10<sup>4</sup></code>
+*   All the points are **unique**.

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

@@ -0,0 +1,21 @@
+package g0401_0500.s0448_find_all_numbers_disappeared_in_an_array
+
+// #Easy #Array #Hash_Table #Udemy_Arrays #2022_12_24_Time_394_ms_(100.00%)_Space_46_MB_(94.74%)
+
+class Solution {
+    fun findDisappearedNumbers(nums: IntArray): List<Int> {
+        val arr = IntArray(nums.size)
+        var counter = 0
+        for (i in nums.indices) {
+            arr[nums[counter] - 1] = 1
+            counter++
+        }
+        val res: MutableList<Int> = ArrayList()
+        for (i in arr.indices) {
+            if (arr[i] == 0) {
+                res.add(i + 1)
+            }
+        }
+        return res
+    }
+}

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

@@ -0,0 +1,25 @@
+448\. Find All Numbers Disappeared in an Array
+
+Easy
+
+Given an array `nums` of `n` integers where `nums[i]` is in the range `[1, n]`, return _an array of all the integers in the range_ `[1, n]` _that do not appear in_ `nums`.
+
+**Example 1:**
+
+**Input:** nums = [4,3,2,7,8,2,3,1]
+
+**Output:** [5,6]
+
+**Example 2:**
+
+**Input:** nums = [1,1]
+
+**Output:** [2]
+
+**Constraints:**
+
+*   `n == nums.length`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   `1 <= nums[i] <= n`
+
+**Follow up:** Could you do it without extra space and in `O(n)` runtime? You may assume the returned list does not count as extra space.

src/main/kotlin/g0401_0500/s0449_serialize_and_deserialize_bst/Codec.kt

@@ -0,0 +1,66 @@
+package g0401_0500.s0449_serialize_and_deserialize_bst
+
+// #Medium #String #Depth_First_Search #Breadth_First_Search #Tree #Binary_Tree #Design
+// #Binary_Search_Tree #2022_12_24_Time_233_ms_(100.00%)_Space_36.3_MB_(100.00%)
+
+import com_github_leetcode.TreeNode
+
+/*
+ * Definition for a binary tree node.
+ * class TreeNode(var `val`: Int) {
+ *     var left: TreeNode? = null
+ *     var right: TreeNode? = null
+ * }
+ */
+
+class Codec {
+    private var cur = 0
+
+    // Encodes a tree to a single string.
+    fun serialize(root: TreeNode?): String {
+        val sb = StringBuilder()
+        serializeDfs(root, sb)
+        return sb.toString()
+    }
+
+    private fun serializeDfs(root: TreeNode?, sb: StringBuilder) {
+        if (root == null) {
+            sb.append(SPLIT)
+            return
+        }
+        sb.append((root.`val` + MIN).toChar())
+        serializeDfs(root.left, sb)
+        serializeDfs(root.right, sb)
+    }
+
+    // Decodes your encoded data to tree.
+    fun deserialize(data: String): TreeNode? {
+        cur = 0
+        return deserializeDFS(data.toCharArray())
+    }
+
+    private fun deserializeDFS(data: CharArray): TreeNode? {
+        if (data[cur] == SPLIT) {
+            cur++
+            return null
+        }
+        val node = TreeNode(data[cur++].code - MIN)
+        node.left = deserializeDFS(data)
+        node.right = deserializeDFS(data)
+        return node
+    }
+
+    companion object {
+        private const val SPLIT = 0.toChar()
+        private const val MIN = 1
+    }
+}
+
+/*
+ * Your Codec object will be instantiated and called as such:
+ * val ser = Codec()
+ * val deser = Codec()
+ * val tree: String = ser.serialize(root)
+ * val ans = deser.deserialize(tree)
+ * return ans
+ */

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

@@ -0,0 +1,27 @@
+449\. Serialize and Deserialize BST
+
+Medium
+
+Serialization is converting a data structure or object into a sequence of bits so that it can be stored in a file or memory buffer, or transmitted across a network connection link to be reconstructed later in the same or another computer environment.
+
+Design an algorithm to serialize and deserialize a **binary search tree**. There is no restriction on how your serialization/deserialization algorithm should work. You need to ensure that a binary search tree can be serialized to a string, and this string can be deserialized to the original tree structure.
+
+**The encoded string should be as compact as possible.**
+
+**Example 1:**
+
+**Input:** root = [2,1,3]
+
+**Output:** [2,1,3]
+
+**Example 2:**
+
+**Input:** root = []
+
+**Output:** []
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range <code>[0, 10<sup>4</sup>]</code>.
+*   <code>0 <= Node.val <= 10<sup>4</sup></code>
+*   The input tree is **guaranteed** to be a binary search tree.

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

@@ -0,0 +1,17 @@
+package g0401_0500.s0446_arithmetic_slices_ii_subsequence
+
+import org.hamcrest.CoreMatchers.equalTo
+import org.hamcrest.MatcherAssert.assertThat
+import org.junit.jupiter.api.Test
+
+internal class SolutionTest {
+    @Test
+    fun numberOfArithmeticSlices() {
+        assertThat(Solution().numberOfArithmeticSlices(intArrayOf(2, 4, 6, 8, 10)), equalTo(7))
+    }
+
+    @Test
+    fun numberOfArithmeticSlices2() {
+        assertThat(Solution().numberOfArithmeticSlices(intArrayOf(7, 7, 7, 7, 7)), equalTo(16))
+    }
+}