Added tasks 2715-2723

Author: ThanhNIT

src/main/kotlin/g2701_2800/s2715_execute_cancellable_function_with_delay/readme.md

@@ -0,0 +1,54 @@
+2715\. Timeout Cancellation
+
+Easy
+
+Given a function `fn`, an array of arguments `args`, and a timeout `t` in milliseconds, return a cancel function `cancelFn`.
+
+After a delay of `t`, `fn` should be called with `args` passed as parameters **unless** `cancelFn` was invoked before the delay of `t` milliseconds elapses, specifically at `cancelT` ms. In that case, `fn` should never be called.
+
+**Example 1:**
+
+**Input:** fn = (x) => x \* 5, args = [2], t = 20, cancelT = 50
+
+**Output:** [{"time": 20, "returned": 10}]
+
+**Explanation:** 
+
+    const cancel = cancellable((x) => x \* 5, [2], 20); // fn(2) called at t=20ms 
+    setTimeout(cancel, 50); 
+
+The cancellation was scheduled to occur after a delay of cancelT (50ms), which happened after the execution of fn(2) at 20ms.
+
+**Example 2:**
+
+**Input:** fn = (x) => x\*\*2, args = [2], t = 100, cancelT = 50
+
+**Output:** []
+
+**Explanation:**
+
+    const cancel = cancellable((x) => x\*\*2, [2], 100); // fn(2) not called
+    setTimeout(cancel, 50); 
+
+The cancellation was scheduled to occur after a delay of cancelT (50ms), which happened before the execution of fn(2) at 100ms, resulting in fn(2) never being called.
+
+**Example 3:**
+
+**Input:** fn = (x1, x2) => x1 \* x2, args = [2,4], t = 30, cancelT = 100
+
+**Output:** [{"time": 30, "returned": 8}]
+
+**Explanation:** 
+
+    const cancel = cancellable((x1, x2) => x1 \* x2, [2,4], 30); // fn(2,4) called at t=30ms 
+    setTimeout(cancel, 100); 
+
+The cancellation was scheduled to occur after a delay of cancelT (100ms), which happened after the execution of fn(2,4) at 30ms.
+
+**Constraints:**
+
+*   `fn is a function`
+*   `args is a valid JSON array`
+*   `1 <= args.length <= 10`
+*   `20 <= t <= 1000`
+*   `10 <= cancelT <= 1000`

src/main/kotlin/g2701_2800/s2715_execute_cancellable_function_with_delay/solution.ts

@@ -0,0 +1,41 @@
+// #Easy #2023_08_02_Time_64_ms_(91.95%)_Space_42.3_MB_(96.51%)
+
+function cancellable(fn: Function, args: any[], t: number): Function {
+    let cancelled: boolean = false;
+    setTimeout(() => {
+        if (!cancelled) {
+            fn(...args)
+        }
+    }, t);
+    return () => {
+        cancelled = true
+    }
+}
+
+/*
+ *  const result = []
+ *
+ *  const fn = (x) => x * 5
+ *  const args = [2], t = 20, cancelT = 50
+ *
+ *  const start = performance.now() 
+ *
+ *  const log = (...argsArr) => {
+ *      const diff = Math.floor(performance.now() - start);
+ *      result.push({"time": diff, "returned": fn(...argsArr))
+ *  }
+ *       
+ *  const cancel = cancellable(log, args, t);
+ *
+ *  const maxT = Math.max(t, cancelT)
+ *           
+ *  setTimeout(() => {
+ *     cancel()
+ *  }, cancelT)
+ *
+ *  setTimeout(() => {
+ *     console.log(result) // [{"time":20,"returned":10}]
+ *  }, maxT + 15)
+ */
+
+ export { cancellable }

src/main/kotlin/g2701_2800/s2719_count_of_integers/Solution.kt

@@ -0,0 +1,60 @@
+package g2701_2800.s2719_count_of_integers
+
+// #Hard #String #Dynamic_Programming #Math #2023_08_02_Time_208_ms_(100.00%)_Space_38_MB_(68.42%)
+
+import java.util.Arrays
+
+class Solution {
+    private lateinit var dp: Array<Array<Array<IntArray>>>
+    private fun countStrings(i: Int, tight1: Boolean, tight2: Boolean, sum: Int, num1: String, num2: String): Int {
+        if (sum < 0) return 0
+        if (i == num2.length) return 1
+        if (dp[i][if (tight1) 1 else 0][if (tight2) 1 else 0][sum] != -1)
+            return dp[i][if (tight1) 1 else 0][if (tight2) 1 else 0][sum]
+        val lo = if (tight1) num1[i].code - '0'.code else 0
+        val hi = if (tight2) num2[i].code - '0'.code else 9
+        var count = 0
+        for (idx in lo..hi) {
+            count = (
+                count % MOD + countStrings(
+                    i + 1,
+                    tight1 and (idx == lo), tight2 and (idx == hi),
+                    sum - idx, num1, num2
+                ) % MOD
+                ) % MOD
+        }
+        return count.also { dp[i][if (tight1) 1 else 0][if (tight2) 1 else 0][sum] = it }
+    }
+
+    fun count(num1: String, num2: String, minSum: Int, maxSum: Int): Int {
+        val maxLength = num2.length
+        val minLength = num1.length
+        val leadingZeroes = maxLength - minLength
+        val num1extended: String = "0".repeat(leadingZeroes) + num1
+        dp = Array(maxLength) {
+            Array(2) {
+                Array(2) {
+                    IntArray(401)
+                }
+            }
+        }
+        for (dim1 in dp) {
+            for (dim2 in dim1) {
+                for (dim3 in dim2) {
+                    Arrays.fill(dim3, -1)
+                }
+            }
+        }
+        val total = countStrings(0, true, true, maxSum, num1extended, num2)
+        val unnecessary = countStrings(0, true, true, minSum - 1, num1extended, num2)
+        var ans = (total - unnecessary) % MOD
+        if (ans < 0) {
+            ans += MOD
+        }
+        return ans
+    }
+
+    companion object {
+        private const val MOD = 1e9.toInt() + 7
+    }
+}

src/main/kotlin/g2701_2800/s2719_count_of_integers/readme.md

@@ -0,0 +1,33 @@
+2719\. Count of Integers
+
+Hard
+
+You are given two numeric strings `num1` and `num2` and two integers `max_sum` and `min_sum`. We denote an integer `x` to be _good_ if:
+
+*   `num1 <= x <= num2`
+*   `min_sum <= digit_sum(x) <= max_sum`.
+
+Return _the number of good integers_. Since the answer may be large, return it modulo <code>10<sup>9</sup> + 7</code>.
+
+Note that `digit_sum(x)` denotes the sum of the digits of `x`.
+
+**Example 1:**
+
+**Input:** num1 = "1", num2 = "12", `min_sum` = 1, max\_sum = 8
+
+**Output:** 11
+
+**Explanation:** There are 11 integers whose sum of digits lies between 1 and 8 are 1,2,3,4,5,6,7,8,10,11, and 12. Thus, we return 11.
+
+**Example 2:**
+
+**Input:** num1 = "1", num2 = "5", `min_sum` = 1, max\_sum = 5
+
+**Output:** 5
+
+**Explanation:** The 5 integers whose sum of digits lies between 1 and 5 are 1,2,3,4, and 5. Thus, we return 5.
+
+**Constraints:**
+
+*   <code>1 <= num1 <= num2 <= 10<sup>22</sup></code>
+*   `1 <= min_sum <= max_sum <= 400`

src/main/kotlin/g2701_2800/s2721_execute_asynchronous_functions_in_parallel/readme.md

@@ -0,0 +1,59 @@
+2721\. Execute Asynchronous Functions in Parallel
+
+Medium
+
+Given an array of asynchronous functions `functions`, return a new promise `promise`. Each function in the array accepts no arguments and returns a promise.
+
+`promise` resolves:
+
+*   When all the promises returned from `functions` were resolved successfully. The resolved value of `promise` should be an array of all the resolved values of promises in the same order as they were in the `functions`.
+
+`promise` rejects:
+
+*   When any of the promises returned from `functions` were rejected. `promise` should also reject with the reason of the first rejection.
+
+Please solve it without using the built-in `Promise.all` function.
+
+**Example 1:**
+
+**Input:** 
+
+    functions = [ 
+        () => new Promise(resolve => setTimeout(() => resolve(5), 200)) 
+    ]
+
+**Output:** {"t": 200, "resolved": [5]}
+
+**Explanation:** promiseAll(functions).then(console.log); // [5] The single function was resolved at 200ms with a value of 5.
+
+**Example 2:**
+
+**Input:** 
+    
+    functions = [ 
+        () => new Promise(resolve => setTimeout(() => resolve(1), 200)), 
+        () => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100)) 
+    ]
+
+**Output:** {"t": 100, "rejected": "Error"}
+
+**Explanation:** Since one of the promises rejected, the returned promise also rejected with the same error at the same time.
+
+**Example 3:**
+
+**Input:** 
+    
+    functions = [ 
+        () => new Promise(resolve => setTimeout(() => resolve(4), 50)), 
+        () => new Promise(resolve => setTimeout(() => resolve(10), 150)), 
+        () => new Promise(resolve => setTimeout(() => resolve(16), 100)) 
+    ]
+
+**Output:** {"t": 150, "resolved": [4, 10, 16]}
+
+**Explanation:** All the promises resolved with a value. The returned promise resolved when the last promise resolved.
+
+**Constraints:**
+
+*   `functions is an array of functions that returns promises`
+*   `1 <= functions.length <= 10`

src/main/kotlin/g2701_2800/s2721_execute_asynchronous_functions_in_parallel/solution.ts

@@ -0,0 +1,28 @@
+// #Medium #2023_08_02_Time_63_ms_(99.09%)_Space_43_MB_(82.94%)
+
+async function promiseAll<T>(functions: (() => Promise<T>)[]): Promise<T[]> {
+  const resolved = []
+  let counter = 0
+
+  return new Promise((resolve, reject) => {
+    for (let i = 0; i < functions.length; i++) {
+      functions[i]().then((res) => {
+        // must specify index of array 
+        resolved[i] = res
+        counter++
+        if (counter === functions.length) {
+          resolve(resolved)
+        }
+      }).catch((err) => {
+        reject(err)
+      })
+    }
+  })
+}
+
+/*
+ * const promise = promiseAll([() => new Promise(res => res(42))])
+ * promise.then(console.log); // [42]
+ */
+
+ export { promiseAll }

src/main/kotlin/g2701_2800/s2722_join_two_arrays_by_id/readme.md

@@ -0,0 +1,83 @@
+2722\. Join Two Arrays by ID
+
+Medium
+
+Given two arrays `arr1` and `arr2`, return a new array `joinedArray`. All the objects in each of the two inputs arrays will contain an `id` field that has an integer value. `joinedArray` is an array formed by merging `arr1` and `arr2` based on their `id` key. The length of `joinedArray` should be the length of unique values of `id`. The returned array should be sorted in **ascending** order based on the `id` key.
+
+If a given `id` exists in one array but not the other, the single object with that `id` should be included in the result array without modification.
+
+If two objects share an `id`, their properties should be merged into a single object:
+
+*   If a key only exists in one object, that single key-value pair should be included in the object.
+*   If a key is included in both objects, the value in the object from `arr2` should override the value from `arr1`.
+
+**Example 1:**
+
+**Input:** 
+
+    arr1 = [ 
+        {"id": 1, "x": 1}, 
+        {"id": 2, "x": 9} 
+    ], 
+    arr2 = [ 
+        {"id": 3, "x": 5} 
+    ]
+
+**Output:** 
+
+    [ 
+        {"id": 1, "x": 1}, 
+        {"id": 2, "x": 9}, 
+        {"id": 3, "x": 5} 
+    ]
+
+**Explanation:** There are no duplicate ids so arr1 is simply concatenated with arr2.
+
+**Example 2:**
+
+**Input:** 
+
+    arr1 = [ 
+        {"id": 1, "x": 2, "y": 3}, 
+        {"id": 2, "x": 3, "y": 6} 
+    ], 
+    arr2 = [ 
+        {"id": 2, "x": 10, "y": 20}, 
+        {"id": 3, "x": 0, "y": 0} 
+    ]
+
+**Output:** 
+
+    [ 
+        {"id": 1, "x": 2, "y": 3}, 
+        {"id": 2, "x": 10, "y": 20}, 
+        {"id": 3, "x": 0, "y": 0} 
+    ]
+
+**Explanation:** The two objects with id=1 and id=3 are included in the result array without modifiction. The two objects with id=2 are merged together. The keys from arr2 override the values in arr1.
+
+**Example 3:**
+
+**Input:** 
+
+    arr1 = [ 
+        {"id": 1, "b": {"b": 94},"v": [4, 3], "y": 48} 
+    ] 
+    arr2 = [ 
+        {"id": 1, "b": {"c": 84}, "v": [1, 3]} 
+    ]
+
+**Output:** 
+
+    [ 
+        {"id": 1, "b": {"c": 84}, "v": [1, 3], "y": 48} 
+    ]
+
+**Explanation:** The two objects with id=1 are merged together. For the keys "b" and "v" the values from arr2 are used. Since the key "y" only exists in arr1, that value is taken form arr1.
+
+**Constraints:**
+
+*   `arr1 and arr2 are valid JSON arrays`
+*   `Each object in arr1 and arr2 has a unique integer id key`
+*   <code>2 <= JSON.stringify(arr1).length <= 10<sup>6</sup></code>
+*   <code>2 <= JSON.stringify(arr2).length <= 10<sup>6</sup></code>

src/main/kotlin/g2701_2800/s2722_join_two_arrays_by_id/solution.ts

@@ -0,0 +1,20 @@
+// #Medium #2023_08_02_Time_280_ms_(98.29%)_Space_99.7_MB_(97.43%)
+
+function join(arr1: any[], arr2: any[]): any[] {
+    const result: any = {}
+    for(let obj of arr1) {
+        result[obj.id] = obj
+    }
+    for(let obj of arr2) {
+        if(result[obj.id]) {
+            for(let key in obj) {
+                result[obj.id][key] = obj[key]
+            }
+        } else {
+            result[obj.id] = obj
+        }
+    }
+  return Object.values(result)
+}
+
+export { join }