Updated tasks

Author: javadev

README.md

@@ -63,9 +63,5 @@ function checkIfInstanceOf(obj: any, classFunction: any): boolean {
     return false
 }
 
-/*
- * checkIfInstanceOf(new Date(), Date); // true
- */
-
 export { checkIfInstanceOf }
 ```

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

@@ -38,8 +38,8 @@ declare global {
     }
 }
 
-Array.prototype.last = function <T>(): T | -1 { //NOSONAR
-    return this.length ? this.at(-1) : -1
+Array.prototype.last = function () { //NOSONAR
+    return this.length !== 0 ? this[this.length - 1] : -1
 }
 
 /*

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

@@ -31,9 +31,7 @@ Given a positive integer `millis`, write an asynchronous function that sleeps fo
 
 ```typescript
 async function sleep(millis: number): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-        setTimeout(resolve, millis)
-    })
+    await new Promise((resolve) => setTimeout(resolve, millis))
 }
 
 /*

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

@@ -73,7 +73,6 @@ function reduce(nums: number[], fn: Fn, init: number): number {
     nums.forEach((num) => {
         accumulator = fn(accumulator, num)
     })
-
     return accumulator
 }
 

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

@@ -67,14 +67,11 @@ Evaluating from right to left ...
 type F = (x: number) => number
 
 function compose(functions: F[]): F {
-    const n = functions.length
-
     return function (x) {
-        for (let i = n - 1; i >= 0; i--) {
-            const fn = functions[i]
-            x = fn(x)
+        if (functions.length == 0) return x
+        for (let ind = functions.length - 1; ind >= 0; ind--) {
+            x = functions[ind](x)
         }
-
         return x
     }
 }

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

@@ -104,15 +104,13 @@ t = 1000
 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) => {
+    return async function (...args) {
+        const timeout = new Promise<any>((_, reject) => {
             setTimeout(() => {
-                reject(new Error('Time Limit Exceeded'))
+                reject('Time Limit Exceeded') //NOSONAR
             }, t)
         })
-
-        return Promise.race([fns, timeLimitPromise])
+        return Promise.race([fn(...args), timeout])
     }
 }
 

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

@@ -47,14 +47,9 @@ A **multi-dimensional array** is a recursive data structure that contains both i
 type MultidimensionalArray = (MultidimensionalArray | number)[]
 
 function* inorderTraversal(arr: MultidimensionalArray): Generator<number, void, unknown> {
-    if (!Array.isArray(arr)) {
-        yield arr
-        return
-    }
-
-    for (let value of arr) {
-        yield* inorderTraversal(value as MultidimensionalArray)
-    }
+    for (const item of arr)
+        if (Array.isArray(item)) yield* inorderTraversal(item)
+        else yield item
 }
 
 /*

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

@@ -13,7 +13,7 @@ Return _the smallest index_ `i` _at which either a row or a column will be compl
 
 **Example 1:**
 
-![](image explanation for example 1)![image explanation for example 1](https://assets.leetcode.com/uploads/2023/01/18/grid1.jpg)
+![image explanation for example 1](https://assets.leetcode.com/uploads/2023/01/18/grid1.jpg)
 
 **Input:** arr = [1,3,4,2], mat = \[\[1,4],[2,3]]
 

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

@@ -44,25 +44,17 @@ Given a function `fn`, return a new function that is identical to the original f
 ## Solution
 
 ```typescript
-function once<T extends (...args: T[]) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T> | undefined {
-    let hasRun: boolean
-    return function (...args: T[]): ReturnType<T> | undefined {
-        if (!hasRun) {
-            hasRun = true
+type Fn = (...args: any[]) => any
+
+function once(fn: Fn): Fn {
+    let wasCalled = false
+    return function (...args) {
+        if (!wasCalled) {
+            wasCalled = true
             return fn(...args)
-        } else {
-            return undefined
         }
     }
 }
 
-/*
- * let fn = (a,b,c) => (a + b + c)
- * let onceFn = once(fn)
- *
- * onceFn(1,2,3); // 6
- * onceFn(2,3,6); // returns undefined without calling fn
- */
-
 export { once }
 ```