Added tasks 2667-2673

Author: ThanhNIT

src/main/kotlin/g2601_2700/s2667_create_hello_world_function/readme.md

@@ -0,0 +1,35 @@
+2667\. Create Hello World Function
+
+Easy
+
+Write a function `createHelloWorld`. It should return a new function that always returns `"Hello World"`.
+
+**Example 1:**
+
+**Input:** args = []
+
+**Output:** "Hello World"
+
+**Explanation:** 
+
+    const f = createHelloWorld(); 
+    f(); // "Hello World" 
+
+The function returned by createHelloWorld should always return "Hello World".
+
+**Example 2:**
+
+**Input:** args = [{},null,42]
+
+**Output:** "Hello World"
+
+**Explanation:** 
+
+    const f = createHelloWorld(); 
+    f({}, null, 42); // "Hello World" 
+
+Any arguments could be passed to the function but it should still always return "Hello World".
+
+**Constraints:**
+
+*   `0 <= args.length <= 10`

src/main/kotlin/g2601_2700/s2667_create_hello_world_function/solution.ts

@@ -0,0 +1,14 @@
+// #Easy #2023_07_26_Time_52_ms_(92.72%)_Space_43.1_MB_(21.30%)
+
+function createHelloWorld() {
+    return function (...args): string {
+        return 'Hello World'
+    }
+}
+
+/*
+ * const f = createHelloWorld();
+ * f(); // "Hello World"
+ */
+
+ export { createHelloWorld }

src/main/kotlin/g2601_2700/s2670_find_the_distinct_difference_array/Solution.kt

@@ -0,0 +1,28 @@
+package g2601_2700.s2670_find_the_distinct_difference_array
+
+// #Easy #Array #Hash_Table #2023_07_26_Time_320_ms_(94.74%)_Space_47.3_MB_(15.79%)
+
+class Solution {
+    fun distinctDifferenceArray(nums: IntArray): IntArray {
+        val n = nums.size
+        val prefixSet = HashSet<Int>()
+        val suffixSet = HashSet<Int>()
+        val preList = IntArray(n)
+        val sufList = IntArray(n)
+        val ans = IntArray(n)
+        for (i in 0..nums.lastIndex) {
+            prefixSet.add(nums[i])
+            suffixSet.add(nums[n - 1 - i])
+            preList[i] = prefixSet.size
+            sufList[n - 1 - i] = suffixSet.size
+        }
+        for (i in 0..nums.lastIndex) {
+            if (i == nums.lastIndex) {
+                ans[i] = preList[i]
+            } else {
+                ans[i] = preList[i] - sufList[i + 1]
+            }
+        }
+        return ans
+    }
+}

src/main/kotlin/g2601_2700/s2670_find_the_distinct_difference_array/readme.md

@@ -0,0 +1,52 @@
+2670\. Find the Distinct Difference Array
+
+Easy
+
+You are given a **0-indexed** array `nums` of length `n`.
+
+The **distinct difference** array of `nums` is an array `diff` of length `n` such that `diff[i]` is equal to the number of distinct elements in the suffix `nums[i + 1, ..., n - 1]` **subtracted from** the number of distinct elements in the prefix `nums[0, ..., i]`.
+
+Return _the **distinct difference** array of_ `nums`.
+
+Note that `nums[i, ..., j]` denotes the subarray of `nums` starting at index `i` and ending at index `j` inclusive. Particularly, if `i > j` then `nums[i, ..., j]` denotes an empty subarray.
+
+**Example 1:**
+
+**Input:** nums = [1,2,3,4,5]
+
+**Output:** [-3,-1,1,3,5]
+
+**Explanation:** 
+
+For index i = 0, there is 1 element in the prefix and 4 distinct elements in the suffix. Thus, diff[0] = 1 - 4 = -3. 
+
+For index i = 1, there are 2 distinct elements in the prefix and 3 distinct elements in the suffix. Thus, diff[1] = 2 - 3 = -1. 
+
+For index i = 2, there are 3 distinct elements in the prefix and 2 distinct elements in the suffix. Thus, diff[2] = 3 - 2 = 1. 
+
+For index i = 3, there are 4 distinct elements in the prefix and 1 distinct element in the suffix. Thus, diff[3] = 4 - 1 = 3.
+
+For index i = 4, there are 5 distinct elements in the prefix and no elements in the suffix. Thus, diff[4] = 5 - 0 = 5.
+
+**Example 2:**
+
+**Input:** nums = [3,2,3,4,2]
+
+**Output:** [-2,-1,0,2,3]
+
+**Explanation:** 
+
+For index i = 0, there is 1 element in the prefix and 3 distinct elements in the suffix. Thus, diff[0] = 1 - 3 = -2. 
+
+For index i = 1, there are 2 distinct elements in the prefix and 3 distinct elements in the suffix. Thus, diff[1] = 2 - 3 = -1. 
+
+For index i = 2, there are 2 distinct elements in the prefix and 2 distinct elements in the suffix. Thus, diff[2] = 2 - 2 = 0. 
+
+For index i = 3, there are 3 distinct elements in the prefix and 1 distinct element in the suffix. Thus, diff[3] = 3 - 1 = 2. 
+
+For index i = 4, there are 3 distinct elements in the prefix and no elements in the suffix. Thus, diff[4] = 3 - 0 = 3.
+
+**Constraints:**
+
+*   `1 <= n == nums.length <= 50`
+*   `1 <= nums[i] <= 50`

src/main/kotlin/g2601_2700/s2671_frequency_tracker/FrequencyTracker.kt

@@ -0,0 +1,32 @@
+package g2601_2700.s2671_frequency_tracker
+
+// #Medium #Hash_Table #Design #2023_07_26_Time_1109_ms_(80.00%)_Space_134.7_MB_(60.00%)
+
+class FrequencyTracker() {
+    private val count = IntArray(100001)
+    private val freq = IntArray(100001)
+
+    fun add(number: Int) {
+        val curFreq = ++count[number]
+        freq[curFreq - 1]--
+        freq[curFreq]++
+    }
+
+    fun deleteOne(number: Int) {
+        if (count[number] > 0) {
+            val curFreq = --count[number]
+            freq[curFreq + 1]--
+            freq[curFreq]++
+        }
+    }
+
+    fun hasFrequency(frequency: Int) = freq[frequency] > 0
+}
+
+/*
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * var obj = FrequencyTracker()
+ * obj.add(number)
+ * obj.deleteOne(number)
+ * var param_3 = obj.hasFrequency(frequency)
+ */

src/main/kotlin/g2601_2700/s2671_frequency_tracker/readme.md

@@ -0,0 +1,57 @@
+2671\. Frequency Tracker
+
+Medium
+
+Design a data structure that keeps track of the values in it and answers some queries regarding their frequencies.
+
+Implement the `FrequencyTracker` class.
+
+*   `FrequencyTracker()`: Initializes the `FrequencyTracker` object with an empty array initially.
+*   `void add(int number)`: Adds `number` to the data structure.
+*   `void deleteOne(int number)`: Deletes **one** occurrence of `number` from the data structure. The data structure **may not contain** `number`, and in this case nothing is deleted.
+*   `bool hasFrequency(int frequency)`: Returns `true` if there is a number in the data structure that occurs `frequency` number of times, otherwise, it returns `false`.
+
+**Example 1:**
+
+**Input** ["FrequencyTracker", "add", "add", "hasFrequency"] [[], [3], [3], [2]]
+
+**Output:** [null, null, null, true]
+
+**Explanation:** 
+
+    FrequencyTracker frequencyTracker = new FrequencyTracker(); 
+    frequencyTracker.add(3); // The data structure now contains [3] 
+    frequencyTracker.add(3); // The data structure now contains [3, 3] 
+    frequencyTracker.hasFrequency(2); // Returns true, because 3 occurs twice
+
+**Example 2:**
+
+**Input** ["FrequencyTracker", "add", "deleteOne", "hasFrequency"] [[], [1], [1], [1]]
+
+**Output:** [null, null, null, false]
+
+**Explanation:** 
+
+    FrequencyTracker frequencyTracker = new FrequencyTracker(); 
+    frequencyTracker.add(1); // The data structure now contains [1]
+    frequencyTracker.deleteOne(1); // The data structure becomes empty [] 
+    frequencyTracker.hasFrequency(1); // Returns false, because the data structure is empty
+
+**Example 3:**
+
+**Input** ["FrequencyTracker", "hasFrequency", "add", "hasFrequency"] [[], [2], [3], [1]]
+
+**Output:** [null, false, null, true]
+
+**Explanation:** 
+
+    FrequencyTracker frequencyTracker = new FrequencyTracker(); 
+    frequencyTracker.hasFrequency(2); // Returns false, because the data structure is empty 
+    frequencyTracker.add(3); // The data structure now contains [3] 
+    frequencyTracker.hasFrequency(1); // Returns true, because 3 occurs once
+
+**Constraints:**
+
+*   <code>1 <= number <= 10<sup>5</sup></code>
+*   <code>1 <= frequency <= 10<sup>5</sup></code>
+*   At most, <code>2 * 10<sup>5</sup></code> calls will be made to `add`, `deleteOne`, and `hasFrequency` in **total**.

src/main/kotlin/g2601_2700/s2672_number_of_adjacent_elements_with_the_same_color/Solution.kt

@@ -0,0 +1,21 @@
+package g2601_2700.s2672_number_of_adjacent_elements_with_the_same_color
+
+// #Medium #Array #2023_07_26_Time_1208_ms_(100.00%)_Space_116_MB_(25.00%)
+
+class Solution {
+    fun colorTheArray(n: Int, queries: Array<IntArray>): IntArray {
+        val nums = IntArray(n)
+        val res = IntArray(queries.size)
+        var count = 0
+        for ((i, q) in queries.withIndex()) {
+            val (e, c) = q
+            if (e > 0 && nums[e] != 0 && nums[e - 1] == nums[e]) count--
+            if (e < n - 1 && nums[e] != 0 && nums[e + 1] == nums[e]) count--
+            nums[e] = c
+            if (e > 0 && nums[e] != 0 && nums[e - 1] == nums[e]) count++
+            if (e < n - 1 && nums[e] != 0 && nums[e + 1] == nums[e]) count++
+            res[i] = count
+        }
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2672_number_of_adjacent_elements_with_the_same_color/readme.md

@@ -0,0 +1,43 @@
+2672\. Number of Adjacent Elements With the Same Color
+
+Medium
+
+There is a **0-indexed** array `nums` of length `n`. Initially, all elements are **uncolored** (has a value of `0`).
+
+You are given a 2D integer array `queries` where <code>queries[i] = [index<sub>i</sub>, color<sub>i</sub>]</code>.
+
+For each query, you color the index <code>index<sub>i</sub></code> with the color <code>color<sub>i</sub></code> in the array `nums`.
+
+Return _an array_ `answer` _of the same length as_ `queries` _where_ `answer[i]` _is the number of adjacent elements with the same color **after** the_ <code>i<sup>th</sup></code> _query_.
+
+More formally, `answer[i]` is the number of indices `j`, such that `0 <= j < n - 1` and `nums[j] == nums[j + 1]` and `nums[j] != 0` after the <code>i<sup>th</sup></code> query.
+
+**Example 1:**
+
+**Input:** n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]]
+
+**Output:** [0,1,1,0,2]
+
+**Explanation:** Initially array nums = [0,0,0,0], where 0 denotes uncolored elements of the array.
+- After the 1<sup>st</sup> query nums = [2,0,0,0]. The count of adjacent elements with the same color is 0. 
+- After the 2<sup>nd</sup> query nums = [2,2,0,0]. The count of adjacent elements with the same color is 1.
+- After the 3<sup>rd</sup> query nums = [2,2,0,1]. The count of adjacent elements with the same color is 1. 
+- After the 4<sup>th</sup> query nums = [2,1,0,1]. The count of adjacent elements with the same color is 0. 
+- After the 5<sup>th</sup> query nums = [2,1,1,1]. The count of adjacent elements with the same color is 2.
+
+**Example 2:**
+
+**Input:** n = 1, queries = [[0,100000]]
+
+**Output:** [0]
+
+**Explanation:** Initially array nums = [0], where 0 denotes uncolored elements of the array. 
+- After the 1<sup>st</sup> query nums = [100000]. The count of adjacent elements with the same color is 0.
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>1 <= queries.length <= 10<sup>5</sup></code>
+*   `queries[i].length == 2`
+*   <code>0 <= index<sub>i</sub> <= n - 1</code>
+*   <code>1 <= color<sub>i</sub> <= 10<sup>5</sup></code>

src/main/kotlin/g2601_2700/s2673_make_costs_of_paths_equal_in_a_binary_tree/Solution.kt

@@ -0,0 +1,18 @@
+package g2601_2700.s2673_make_costs_of_paths_equal_in_a_binary_tree
+
+// #Medium #Array #Dynamic_Programming #Greedy #Tree #Binary_Tree
+// #2023_07_26_Time_645_ms_(75.00%)_Space_57.8_MB_(75.00%)
+
+class Solution {
+    fun minIncrements(n: Int, cost: IntArray): Int {
+        val last = n / 2 - 1
+        var res = 0
+        for (i in last downTo 0) {
+            var abs = cost[2 * i + 1] - cost[2 * i + 2]
+            if (abs < 0) abs *= -1
+            cost[i] += maxOf(cost[2 * i + 1], cost[2 * i + 2])
+            res += abs
+        }
+        return res
+    }
+}

src/main/kotlin/g2601_2700/s2673_make_costs_of_paths_equal_in_a_binary_tree/readme.md

@@ -0,0 +1,49 @@
+2673\. Make Costs of Paths Equal in a Binary Tree
+
+Medium
+
+You are given an integer `n` representing the number of nodes in a **perfect binary tree** consisting of nodes numbered from `1` to `n`. The root of the tree is node `1` and each node `i` in the tree has two children where the left child is the node `2 * i` and the right child is `2 * i + 1`.
+
+Each node in the tree also has a **cost** represented by a given **0-indexed** integer array `cost` of size `n` where `cost[i]` is the cost of node `i + 1`. You are allowed to **increment** the cost of **any** node by `1` **any** number of times.
+
+Return _the **minimum** number of increments you need to make the cost of paths from the root to each **leaf** node equal_.
+
+**Note**:
+
+*   A **perfect binary tree** is a tree where each node, except the leaf nodes, has exactly 2 children.
+*   The **cost of a path** is the sum of costs of nodes in the path.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2023/04/04/binaryytreeedrawio-4.png)
+
+**Input:** n = 7, cost = [1,5,2,2,3,3,1]
+
+**Output:** 6
+
+**Explanation:** We can do the following increments: 
+- Increase the cost of node 4 one time. 
+- Increase the cost of node 3 three times. 
+- Increase the cost of node 7 two times. 
+
+Each path from the root to a leaf will have a total cost of 9. 
+
+The total increments we did is 1 + 3 + 2 = 6. 
+It can be shown that this is the minimum answer we can achieve.
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2023/04/04/binaryytreee2drawio.png)
+
+**Input:** n = 3, cost = [5,3,3]
+
+**Output:** 0
+
+**Explanation:** The two paths already have equal total costs, so no increments are needed.
+
+**Constraints:**
+
+*   <code>3 <= n <= 10<sup>5</sup></code>
+*   `n + 1` is a power of `2`
+*   `cost.length == n`
+*   <code>1 <= cost[i] <= 10<sup>4</sup></code>