Improved tasks 2630-2637

Author: javadev

Diff for: src/main/java/g2601_2700/s2619_array_prototype_last/solution.ts

@@ -2,11 +2,11 @@
 
 declare global {
     interface Array<T> {
-        last(): T | -1;
+        last(): T | -1
     }
 }
 
-Array.prototype.last = function () {//NOSONAR
+Array.prototype.last = function () { //NOSONAR
     return this.length !== 0 ? this[this.length - 1] : -1
 }
 
@@ -15,4 +15,4 @@ Array.prototype.last = function () {//NOSONAR
  * arr.last(); // 3
  */
 
-export { }
+export {}

Diff for: src/main/java/g2601_2700/s2621_sleep/solution.ts

@@ -1,7 +1,7 @@
 // #Easy #2023_08_31_Time_40_ms_(99.59%)_Space_42.3_MB_(77.98%)
 
 async function sleep(millis: number): Promise<void> {
-    await new Promise(resolve => setTimeout(resolve, millis));
+    await new Promise((resolve) => setTimeout(resolve, millis))
 }
 
 /*

Diff for: src/main/java/g2601_2700/s2630_memoize_ii/solution.ts

@@ -3,44 +3,41 @@
 type Fn = (...params: any) => any
 
 function memoize(fn: Fn): Fn {
-    const cache = new Map();
+    const cache = new Map()
 
-    return function(...args) {
-        let currentCache;
+    return function (...args) {
+        let currentCache
         if (cache.has(args.length)) {
-            currentCache = cache.get(args.length);
-        }
-        else {
-            currentCache = new Map();
-            cache.set(args.length, currentCache);
+            currentCache = cache.get(args.length)
+        } else {
+            currentCache = new Map()
+            cache.set(args.length, currentCache)
         }
 
-        for (let i=0, len=args.length; i<=len; i++){
-            const arg = args[i];
-            const isEnd = i >= len - 1;
+        for (let i = 0, len = args.length; i <= len; i++) {
+            const arg = args[i]
+            const isEnd = i >= len - 1
 
             if (currentCache.has(arg)) {
                 if (isEnd) {
-                    return currentCache.get(arg);
-                }
-                else {
-                    currentCache = currentCache.get(arg);
+                    return currentCache.get(arg)
+                } else {
+                    currentCache = currentCache.get(arg)
                 }
-            }
-            else if (isEnd) {
-                 break;
+            } else if (isEnd) {
+                break
             } else {
-                 const newSubCache = new Map();
+                const newSubCache = new Map()
 
-                 currentCache.set(arg, newSubCache);
-                 currentCache = newSubCache;
+                currentCache.set(arg, newSubCache)
+                currentCache = newSubCache
             }
         }
 
-        let value = fn(...args);
+        let value = fn(...args)
 
-        currentCache.set(args[args.length - 1], value);
-        return value;
+        currentCache.set(args[args.length - 1], value)
+        return value
     }
 }
 
@@ -52,7 +49,7 @@ function memoize(fn: Fn): Fn {
  * })
  * memoizedFn(2, 3) // 5
  * memoizedFn(2, 3) // 5
- * console.log(callCount) // 1 
+ * console.log(callCount) // 1
  */
 
- export { memoize }
+export { memoize }

Diff for: src/main/java/g2601_2700/s2631_group_by/solution.ts

@@ -6,21 +6,21 @@ declare global {
     }
 }
 
-Array.prototype.groupBy = function<T>(fn: (item: T) => string) { //NOSONAR
-  const returnObject: Record<string, T[]> = {};
-  for (const item of this) {
-    const key = fn(item);
-    if (key in returnObject) {
-      returnObject[key].push(item);
-    } else {
-      returnObject[key] = [item];
+Array.prototype.groupBy = function <T>(fn: (item: T) => string) { //NOSONAR
+    const returnObject: Record<string, T[]> = {}
+    for (const item of this) {
+        const key = fn(item)
+        if (key in returnObject) {
+            returnObject[key].push(item)
+        } else {
+            returnObject[key] = [item]
+        }
     }
-  }
-  return returnObject;
-};
+    return returnObject
+}
 
 /*
  * [1,2,3].groupBy(String) // {"1":[1],"2":[2],"3":[3]}
  */
 
- export { }
+export {}

Diff for: src/main/java/g2601_2700/s2637_promise_time_limit/solution.ts

@@ -1,18 +1,17 @@
 // #Easy #Medium #2023_08_31_Time_53_ms_(93.41%)_Space_42.7_MB_(62.71%)
 
-type Fn = (...params: any[]) => Promise<any>;
+type Fn = (...params: any[]) => Promise<any>
 
 function timeLimit(fn: Fn, t: number): Fn {
-  return async function (...args: any[]): Promise<any> {
-    const fns = fn(...args);
-    const timeLimitPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error('Time Limit Exceeded'));
-      }, t);
-    });
-
-    return Promise.race([fns, timeLimitPromise]);
-  };
+    return async function (...args: any[]): Promise<any> {
+        const fns = fn(...args)
+        const timeLimitPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error('Time Limit Exceeded'))
+            }, t)
+        })
+        return Promise.race([fns, timeLimitPromise])
+    }
 }
 
 /*

Diff for: src/test/java/g2601_2700/s2630_memoize_ii/solution.test.ts

@@ -3,34 +3,55 @@ import { memoize } from 'src/main/java/g2601_2700/s2630_memoize_ii/solution'
 import { expect, test } from 'vitest'
 
 test('memoize', () => {
-    let getInputs = () => [[2,2],[2,2],[1,2]]
-    let results = [4,4,3]
-    let fn = function (a, b) { return a + b; }
+    let getInputs = () => [
+        [2, 2],
+        [2, 2],
+        [1, 2],
+    ]
+    let results = [4, 4, 3]
+    let fn = function (a, b) {
+        return a + b
+    }
     let memorized = memoize(fn)
     let inputs = getInputs()
-    for (let i = 0; i < inputs.length; i++ ) {
-          expect(memorized(...inputs[i])).toEqual(results[i])
+    for (let i = 0; i < inputs.length; i++) {
+        expect(memorized(...inputs[i])).toEqual(results[i])
     }
 })
 
 test('memoize2', () => {
-    let getInputs = () => [[{},{}],[{},{}],[{},{}]]
-    let results = [{},{},{}]
-    let fn = function (a, b) { return ({...a, ...b}); }
+    let getInputs = () => [
+        [{}, {}],
+        [{}, {}],
+        [{}, {}],
+    ]
+    let results = [{}, {}, {}]
+    let fn = function (a, b) {
+        return { ...a, ...b }
+    }
     let memorized = memoize(fn)
     let inputs = getInputs()
-    for (let i = 0; i < inputs.length; i++ ) {
-          expect(memorized(...inputs[i])).toEqual(results[i])
+    for (let i = 0; i < inputs.length; i++) {
+        expect(memorized(...inputs[i])).toEqual(results[i])
     }
 })
 
 test('memoize3', () => {
-    let getInputs = () => { const o = {}; return [[o,o],[o,o],[o,o]]; }
-    let results = [{},{},{}]
-    let fn = function (a, b) { return ({...a, ...b}); }
+    let getInputs = () => {
+        const o = {}
+        return [
+            [o, o],
+            [o, o],
+            [o, o],
+        ]
+    }
+    let results = [{}, {}, {}]
+    let fn = function (a, b) {
+        return { ...a, ...b }
+    }
     let memorized = memoize(fn)
     let inputs = getInputs()
-    for (let i = 0; i < inputs.length; i++ ) {
-          expect(memorized(...inputs[i])).toEqual(results[i])
+    for (let i = 0; i < inputs.length; i++) {
+        expect(memorized(...inputs[i])).toEqual(results[i])
     }
 })

Diff for: src/test/java/g2601_2700/s2631_group_by/solution.test.ts

@@ -4,43 +4,43 @@ import { expect, test } from 'vitest'
 
 test('groupBy', () => {
     let fn = function (item) {
-              return item.id;
-            }
-    let array = [
-      {"id":"1"},
-      {"id":"1"},
-      {"id":"2"}
-    ].groupBy(fn)
+        return item.id
+    }
+    let array = [{ id: '1' }, { id: '1' }, { id: '2' }].groupBy(fn)
     let result = {
-                   "1": [{"id": "1"}, {"id": "1"}],
-                   "2": [{"id": "2"}]
-                 }
+        '1': [{ id: '1' }, { id: '1' }],
+        '2': [{ id: '2' }],
+    }
     expect(array).toEqual(result)
 })
 
 test('groupBy2', () => {
     let fn = function (list) {
-          return String(list[0]);
-        }
+        return String(list[0])
+    }
     let array = [
-          [1, 2, 3],
-          [1, 3, 5],
-          [1, 5, 9]
-        ].groupBy(fn)
+        [1, 2, 3],
+        [1, 3, 5],
+        [1, 5, 9],
+    ].groupBy(fn)
     let result = {
-                   "1": [[1, 2, 3], [1, 3, 5], [1, 5, 9]]
-                 }
+        '1': [
+            [1, 2, 3],
+            [1, 3, 5],
+            [1, 5, 9],
+        ],
+    }
     expect(array).toEqual(result)
 })
 
 test('groupBy3', () => {
     let fn = function (n) {
-          return String(n > 5);
-        }
+        return String(n > 5)
+    }
     let array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].groupBy(fn)
     let result = {
-                   "true": [6, 7, 8, 9, 10],
-                   "false": [1, 2, 3, 4, 5]
-                 }
+        true: [6, 7, 8, 9, 10],
+        false: [1, 2, 3, 4, 5],
+    }
     expect(array).toEqual(result)
 })

Diff for: src/test/java/g2601_2700/s2634_filter_elements_from_array/solution.test.ts

@@ -3,19 +3,25 @@ import { filter } from 'src/main/java/g2601_2700/s2634_filter_elements_from_arra
 import { expect, test } from 'vitest'
 
 test('filter', () => {
-    let arr = [0,10,20,30]
-    let fn = function greaterThan10(n) { return n > 10; }
-    expect(filter(arr,fn)).toEqual([20, 30])
+    let arr = [0, 10, 20, 30]
+    let fn = function greaterThan10(n) {
+        return n > 10
+    }
+    expect(filter(arr, fn)).toEqual([20, 30])
 })
 
 test('filter2', () => {
-    let arr = [-2,-1,0,1,2]
-    let fn = function plusOne(n) { return n + 1 }
-    expect(filter(arr,fn)).toEqual([-2,0,1,2])
+    let arr = [-2, -1, 0, 1, 2]
+    let fn = function plusOne(n) {
+        return n + 1
+    }
+    expect(filter(arr, fn)).toEqual([-2, 0, 1, 2])
 })
 
 test('filter3', () => {
-    let arr = [1,2,3]
-    let fn = function firstIndex(n, i) { return i === 0; }
-    expect(filter(arr,fn)).toEqual([1])
+    let arr = [1, 2, 3]
+    let fn = function firstIndex(n, i) {
+        return i === 0
+    }
+    expect(filter(arr, fn)).toEqual([1])
 })

Diff for: src/test/java/g2601_2700/s2635_apply_transform_over_each_element_in_array/solution.test.ts

@@ -3,19 +3,25 @@ import { map } from 'src/main/java/g2601_2700/s2635_apply_transform_over_each_el
 import { expect, test } from 'vitest'
 
 test('map', () => {
-    let arr = [1,2,3]
-    let fn = function plusone(n) { return n + 1; }
-    expect(map(arr,fn)).toEqual([2,3,4])
+    let arr = [1, 2, 3]
+    let fn = function plusone(n) {
+        return n + 1
+    }
+    expect(map(arr, fn)).toEqual([2, 3, 4])
 })
 
 test('map2', () => {
-    let arr = [1,2,3]
-    let fn = function plusI(n, i) { return n + i; }
-    expect(map(arr,fn)).toEqual([1,3,5])
+    let arr = [1, 2, 3]
+    let fn = function plusI(n, i) {
+        return n + i
+    }
+    expect(map(arr, fn)).toEqual([1, 3, 5])
 })
 
 test('map3', () => {
-    let arr = [10,20,30]
-    let fn = function constant() { return 42; }
-    expect(map(arr,fn)).toEqual([42,42,42])
+    let arr = [10, 20, 30]
+    let fn = function constant() {
+        return 42
+    }
+    expect(map(arr, fn)).toEqual([42, 42, 42])
 })