Improved tasks 2623-2637

Author: javadev

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

@@ -1,4 +1,4 @@
-// #Hard #2023_07_17_Time_314_ms_(99.39%)_Space_115.7_MB_(62.42%)
+// #Hard #2023_08_31_Time_264_ms_(98.86%)_Space_115.9_MB_(61.71%)
 
 type Fn = (...params: any) => any
 
@@ -13,22 +13,29 @@ function memoize(fn: Fn): Fn {
             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
+
             if (currentCache.has(arg)) {
                 if (isEnd) {
                     return currentCache.get(arg)
                 } else {
                     currentCache = currentCache.get(arg)
                 }
-            } else if (!isEnd) {
+            } else if (isEnd) {
+                break
+            } else {
                 const newSubCache = new Map()
+
                 currentCache.set(arg, newSubCache)
                 currentCache = newSubCache
             }
         }
-        let value = fn.apply( ...args)
+
+        let value = fn(...args)
+
         currentCache.set(args[args.length - 1], value)
         return value
     }

src/test/kotlin/g2601_2700/s2623_memoize/solution.test.ts

@@ -3,5 +3,29 @@ import { memoize } from 'src/main/kotlin/g2601_2700/s2623_memoize/solution'
 import { expect, test } from 'vitest'
 
 test('memoize', () => {
-    expect(1).toEqual(1)
+    const sum = (a, b) => a + b
+    const memoizedSum = memoize(sum)
+    expect(memoizedSum(2, 2)).toEqual(4)
+    // Returns 4. sum() was called as (2, 2) was not seen before.
+    expect(memoizedSum(2, 2)).toEqual(4)
+    // Returns 4. However sum() was not called because the same inputs were seen before.
+    // Total call count: 1
+    expect(memoizedSum(1, 2)).toEqual(3)
+    // Returns 3. sum() was called as (1, 2) was not seen before.
+    // Total call count: 2
+})
+
+test('memoize2', () => {
+    const factorial = (n) => (n <= 1 ? 1 : n * factorial(n - 1))
+    const memoFactorial = memoize(factorial)
+    expect(memoFactorial(2)).toEqual(2)
+    // Returns 2.
+    expect(memoFactorial(3)).toEqual(6)
+    // Returns 6.
+    expect(memoFactorial(2)).toEqual(2)
+    // Returns 2. However factorial was not called because 2 was seen before.
+    // Total call count: 2
+    expect(memoFactorial(3)).toEqual(6)
+    // Returns 6. However factorial was not called because 3 was seen before.
+    // Total call count: 2
 })

src/test/kotlin/g2601_2700/s2624_snail_traversal/solution.test.ts

@@ -3,5 +3,25 @@ import 'src/main/kotlin/g2601_2700/s2624_snail_traversal/solution'
 import { expect, test } from 'vitest'
 
 test('snail', () => {
-    expect(1).toEqual(1)
+    let nums = [19, 10, 3, 7, 9, 8, 5, 2, 1, 17, 16, 14, 12, 18, 6, 13, 11, 20, 4, 15].snail(5, 4)
+    let result = [
+        [19, 17, 16, 15],
+        [10, 1, 14, 4],
+        [3, 2, 12, 20],
+        [7, 5, 18, 11],
+        [9, 8, 6, 13],
+    ]
+    expect(nums).toEqual(result)
+})
+
+test('snail2', () => {
+    let nums = [1, 2, 3, 4].snail(1, 4)
+    let result = [[1, 2, 3, 4]]
+    expect(nums).toEqual(result)
+})
+
+test('snail3', () => {
+    let nums = [1, 3].snail(2, 2)
+    let result = []
+    expect(nums).toEqual(result)
 })

src/test/kotlin/g2601_2700/s2625_flatten_deeply_nested_array/solution.test.ts

@@ -3,5 +3,27 @@ import { flat } from 'src/main/kotlin/g2601_2700/s2625_flatten_deeply_nested_arr
 import { expect, test } from 'vitest'
 
 test('flat', () => {
-    expect(1).toEqual(1)
+    let arr = [1, 2, 3, [4, 5, 6], [7, 8, [9, 10, 11], 12], [13, 14, 15]]
+    let n = 0
+    let result = [1, 2, 3, [4, 5, 6], [7, 8, [9, 10, 11], 12], [13, 14, 15]]
+    expect(flat(arr, n)).toEqual(result)
+})
+
+test('flat2', () => {
+    let arr = [1, 2, 3, [4, 5, 6], [7, 8, [9, 10, 11], 12], [13, 14, 15]]
+    let n = 1
+    let result = [1, 2, 3, 4, 5, 6, 7, 8, [9, 10, 11], 12, 13, 14, 15]
+    expect(flat(arr, n)).toEqual(result)
+})
+
+test('flat3', () => {
+    let arr = [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, [9, 10, 11], 12],
+        [13, 14, 15],
+    ]
+    let n = 2
+    let result = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+    expect(flat(arr, n)).toEqual(result)
 })

src/test/kotlin/g2601_2700/s2626_array_reduce_transformation/solution.test.ts

@@ -3,5 +3,28 @@ import { reduce } from 'src/main/kotlin/g2601_2700/s2626_array_reduce_transforma
 import { expect, test } from 'vitest'
 
 test('reduce', () => {
-    expect(1).toEqual(1)
+    let nums = [1, 2, 3, 4]
+    let fn = function sum(accum, curr) {
+        return accum + curr
+    }
+    let init = 0
+    expect(reduce(nums, fn, init)).toEqual(10)
+})
+
+test('reduce2', () => {
+    let nums = [1, 2, 3, 4]
+    let fn = function sum(accum, curr) {
+        return accum + curr * curr
+    }
+    let init = 100
+    expect(reduce(nums, fn, init)).toEqual(130)
+})
+
+test('reduce3', () => {
+    let nums = []
+    let fn = function sum(accum, curr) {
+        return 0
+    }
+    let init = 25
+    expect(reduce(nums, fn, init)).toEqual(25)
 })

src/test/kotlin/g2601_2700/s2627_debounce/solution.test.ts

@@ -3,5 +3,12 @@ import { debounce } from 'src/main/kotlin/g2601_2700/s2627_debounce/solution'
 import { expect, test } from 'vitest'
 
 test('debounce', () => {
+    const log = debounce(console.log, 100)
+    log('Hello')
+    // cancelled
+    log('Hello')
+    // cancelled
+    log('Hello')
+    // Logged at t=100ms
     expect(1).toEqual(1)
 })

src/test/kotlin/g2601_2700/s2629_function_composition/solution.test.ts

@@ -3,5 +3,22 @@ import { compose } from 'src/main/kotlin/g2601_2700/s2629_function_composition/s
 import { expect, test } from 'vitest'
 
 test('compose', () => {
-    expect(1).toEqual(1)
+    let functions = [(x) => x + 1, (x) => x * x, (x) => 2 * x]
+    let x = 4
+    const fn = compose(functions)
+    expect(fn(x)).toEqual(65)
+})
+
+test('compose2', () => {
+    let functions = [(x) => 10 * x, (x) => 10 * x, (x) => 10 * x]
+    let x = 1
+    const fn = compose(functions)
+    expect(fn(x)).toEqual(1000)
+})
+
+test('compose3', () => {
+    let functions = []
+    let x = 42
+    const fn = compose(functions)
+    expect(fn(x)).toEqual(42)
 })

src/test/kotlin/g2601_2700/s2630_memoize_ii/solution.test.ts

@@ -3,5 +3,55 @@ import { memoize } from 'src/main/kotlin/g2601_2700/s2630_memoize_ii/solution'
 import { expect, test } from 'vitest'
 
 test('memoize', () => {
-    expect(1).toEqual(1)
+    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])
+    }
+})
+
+test('memoize2', () => {
+    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])
+    }
+})
+
+test('memoize3', () => {
+    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])
+    }
 })

src/test/kotlin/g2601_2700/s2631_group_by/solution.test.ts

@@ -3,5 +3,44 @@ import 'src/main/kotlin/g2601_2700/s2631_group_by/solution'
 import { expect, test } from 'vitest'
 
 test('groupBy', () => {
-    expect(1).toEqual(1)
+    let fn = function (item) {
+        return item.id
+    }
+    let array = [{ id: '1' }, { id: '1' }, { id: '2' }].groupBy(fn)
+    let result = {
+        '1': [{ id: '1' }, { id: '1' }],
+        '2': [{ id: '2' }],
+    }
+    expect(array).toEqual(result)
+})
+
+test('groupBy2', () => {
+    let fn = function (list) {
+        return String(list[0])
+    }
+    let array = [
+        [1, 2, 3],
+        [1, 3, 5],
+        [1, 5, 9],
+    ].groupBy(fn)
+    let result = {
+        '1': [
+            [1, 2, 3],
+            [1, 3, 5],
+            [1, 5, 9],
+        ],
+    }
+    expect(array).toEqual(result)
+})
+
+test('groupBy3', () => {
+    let fn = function (n) {
+        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],
+    }
+    expect(array).toEqual(result)
 })

src/test/kotlin/g2601_2700/s2634_filter_elements_from_array/solution.test.ts

@@ -3,5 +3,25 @@ import { filter } from 'src/main/kotlin/g2601_2700/s2634_filter_elements_from_ar
 import { expect, test } from 'vitest'
 
 test('filter', () => {
-    expect(1).toEqual(1)
+    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])
+})
+
+test('filter3', () => {
+    let arr = [1, 2, 3]
+    let fn = function firstIndex(n, i) {
+        return i === 0
+    }
+    expect(filter(arr, fn)).toEqual([1])
 })