Improved tasks

Author: javadev

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

@@ -1,12 +1,12 @@
 // #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;
+    let cancelled: boolean = false
     setTimeout(() => {
         if (!cancelled) {
             fn(...args)
         }
-    }, t);
+    }, t)
     return () => {
         cancelled = true
     }
@@ -18,17 +18,17 @@ function cancellable(fn: Function, args: any[], t: number): Function {
  *  const fn = (x) => x * 5
  *  const args = [2], t = 20, cancelT = 50
  *
- *  const start = performance.now() 
+ *  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)
@@ -38,4 +38,4 @@ function cancellable(fn: Function, args: any[], t: number): Function {
  *  }, maxT + 15)
  */
 
- export { cancellable }
+export { cancellable }

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

@@ -1,28 +1,30 @@
 // #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
+    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)
+    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)
+                })
         }
-      }).catch((err) => {
-        reject(err)
-      })
-    }
-  })
+    })
 }
 
 /*
  * const promise = promiseAll([() => new Promise(res => res(42))])
  * promise.then(console.log); // [42]
  */
 
- export { promiseAll }
+export { promiseAll }

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

@@ -2,19 +2,19 @@
 
 function join(arr1: any[], arr2: any[]): any[] {
     const result: any = {}
-    for(let obj of arr1) {
+    for (let obj of arr1) {
         result[obj.id] = obj
     }
-    for(let obj of arr2) {
-        if(result[obj.id]) {
-            for(let key in 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)
+    return Object.values(result)
 }
 
 export { join }

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

@@ -1,12 +1,12 @@
 // #Easy #2023_08_02_Time_56_ms_(97.63%)_Space_43.1_MB_(45.64%)
 
 async function addTwoPromises(promise1: Promise<number>, promise2: Promise<number>): Promise<number> {
-    return await promise1 + await promise2
-};
+    return (await promise1) + (await promise2)
+}
 
 /*
  * addTwoPromises(Promise.resolve(2), Promise.resolve(2))
  *   .then(console.log); // 4
  */
 
- export { addTwoPromises }
+export { addTwoPromises }

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

@@ -3,25 +3,23 @@ import { promiseAll } from 'src/main/kotlin/g2701_2800/s2721_execute_asynchronou
 import { expect, test } from 'vitest'
 
 test('promiseAll', () => {
-    const functions = [
-                        () => new Promise(resolve => setTimeout(() => resolve(5), 200))
-          ]
-    promiseAll(functions).then((e)=> expect(e).toEqual({"t": 200, "resolved": [5]}))
+    const functions = [() => new Promise((resolve) => setTimeout(() => resolve(5), 200))]
+    promiseAll(functions).then((e) => expect(e).toEqual({ t: 200, resolved: [5] }))
 })
 
 test('promiseAll2', () => {
     const functions = [
-              () => new Promise(resolve => setTimeout(() => resolve(1), 200)),
-              () => new Promise((resolve, reject) => setTimeout(() => reject("Error"), 100))
-          ]
-    promiseAll(functions).then((e)=> expect(e).toEqual({"t": 100, "rejected": "Error"}))
+        () => new Promise((resolve) => setTimeout(() => resolve(1), 200)),
+        () => new Promise((resolve, reject) => setTimeout(() => reject('Error'), 100)),
+    ]
+    promiseAll(functions).then((e) => expect(e).toEqual({ t: 100, rejected: 'Error' }))
 })
 
 test('promiseAll3', () => {
     const functions = [
-              () => new Promise(resolve => setTimeout(() => resolve(4), 50)),
-              () => new Promise(resolve => setTimeout(() => resolve(10), 150)),
-              () => new Promise(resolve => setTimeout(() => resolve(16), 100))
-          ]
-    promiseAll(functions).then((e)=> expect(e).toEqual({"t": 150, "resolved": [4, 10, 16]}))
+        () => new Promise((resolve) => setTimeout(() => resolve(4), 50)),
+        () => new Promise((resolve) => setTimeout(() => resolve(10), 150)),
+        () => new Promise((resolve) => setTimeout(() => resolve(16), 100)),
+    ]
+    promiseAll(functions).then((e) => expect(e).toEqual({ t: 150, resolved: [4, 10, 16] }))
 })

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

@@ -4,49 +4,41 @@ import { expect, test } from 'vitest'
 
 test('join', () => {
     const arr1 = [
-        {"id": 1, "x": 1},
-        {"id": 2, "x": 9}
-    ]
-    const arr2 = [
-        {"id": 3, "x": 5}
+        { id: 1, x: 1 },
+        { id: 2, x: 9 },
     ]
+    const arr2 = [{ id: 3, x: 5 }]
 
     const result = [
-                       {"id": 1, "x": 1},
-                       {"id": 2, "x": 9},
-                       {"id": 3, "x": 5}
-   ]
+        { id: 1, x: 1 },
+        { id: 2, x: 9 },
+        { id: 3, x: 5 },
+    ]
     expect(join(arr1, arr2)).toEqual(result)
 })
 
 test('join2', () => {
-    const arr1 =  [
-                     {"id": 1, "x": 2, "y": 3},
-                     {"id": 2, "x": 3, "y": 6}
+    const arr1 = [
+        { id: 1, x: 2, y: 3 },
+        { id: 2, x: 3, y: 6 },
     ]
     const arr2 = [
-                     {"id": 2, "x": 10, "y": 20},
-                     {"id": 3, "x": 0, "y": 0}
+        { id: 2, x: 10, y: 20 },
+        { id: 3, x: 0, y: 0 },
     ]
 
     const result = [
-                       {"id": 1, "x": 2, "y": 3},
-                       {"id": 2, "x": 10, "y": 20},
-                       {"id": 3, "x": 0, "y": 0}
-   ]
+        { id: 1, x: 2, y: 3 },
+        { id: 2, x: 10, y: 20 },
+        { id: 3, x: 0, y: 0 },
+    ]
     expect(join(arr1, arr2)).toEqual(result)
 })
 
 test('join3', () => {
-    const arr1 =  [
-                     {"id": 1, "b": {"b": 94},"v": [4, 3], "y": 48}
-    ]
-    const arr2 = [
-                     {"id": 1, "b": {"c": 84}, "v": [1, 3]}
-    ]
+    const arr1 = [{ id: 1, b: { b: 94 }, v: [4, 3], y: 48 }]
+    const arr2 = [{ id: 1, b: { c: 84 }, v: [1, 3] }]
 
-    const result = [
-                       {"id": 1, "b": {"c": 84}, "v": [1, 3], "y": 48}
-    ]
+    const result = [{ id: 1, b: { c: 84 }, v: [1, 3], y: 48 }]
     expect(join(arr1, arr2)).toEqual(result)
 })

src/test/kotlin/g2701_2800/s2723_add_two_promises/solution.test.ts

@@ -3,13 +3,13 @@ import { addTwoPromises } from 'src/main/kotlin/g2701_2800/s2723_add_two_promise
 import { expect, test } from 'vitest'
 
 test('addTwoPromises', () => {
-    const promise1 = new Promise(resolve => setTimeout(() => resolve(2), 20))
-    const promise2 = new Promise(resolve => setTimeout(() => resolve(5), 60))
-    addTwoPromises(promise1, promise2).then(e => expect(e).toEqual(7))
+    const promise1 = new Promise((resolve) => setTimeout(() => resolve(2), 20))
+    const promise2 = new Promise((resolve) => setTimeout(() => resolve(5), 60))
+    addTwoPromises(promise1, promise2).then((e) => expect(e).toEqual(7))
 })
 
 test('addTwoPromises2', () => {
-    const promise1 = new Promise(resolve => setTimeout(() => resolve(10), 50))
-    const promise2 = new Promise(resolve => setTimeout(() => resolve(-12), 30))
-    addTwoPromises(promise1, promise2).then(e => expect(e).toEqual(-2))
+    const promise1 = new Promise((resolve) => setTimeout(() => resolve(10), 50))
+    const promise2 = new Promise((resolve) => setTimeout(() => resolve(-12), 30))
+    addTwoPromises(promise1, promise2).then((e) => expect(e).toEqual(-2))
 })