Added tasks 2619-2623

Author: ThanhNIT

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

@@ -0,0 +1,27 @@
+2619\. Array Prototype Last
+
+Easy
+
+Write code that enhances all arrays such that you can call the `array.last()` method on any array and it will return the last element. If there are no elements in the array, it should return `-1`.
+
+You may assume the array is the output of `JSON.parse`.
+
+**Example 1:**
+
+**Input:** nums = [null, {}, 3]
+
+**Output:** 3
+
+**Explanation:** Calling nums.last() should return the last element: 3.
+
+**Example 2:**
+
+**Input:** nums = []
+
+**Output:** -1
+
+**Explanation:** Because there are no elements, return -1.
+
+**Constraints:**
+
+*   `0 <= arr.length <= 1000`

src/main/java/g2601_2700/s2619_array_prototype_last/solution.ts

@@ -0,0 +1,18 @@
+// #Easy #2023_08_31_Time_41_ms_(98.99%)_Space_42_MB_(96.92%)
+
+declare global {
+    interface Array<T> {
+        last(): T | -1;
+    }
+}
+
+Array.prototype.last = function () {//NOSONAR
+    return this.length !== 0 ? this[this.length - 1] : -1
+}
+
+/*
+ * const arr = [1, 2, 3];
+ * arr.last(); // 3
+ */
+
+export { }

src/main/java/g2601_2700/s2620_counter/readme.md

@@ -0,0 +1,32 @@
+2620\. Counter
+
+Easy
+
+Given an integer `n`, return a `counter` function. This `counter` function initially returns `n` and then returns 1 more than the previous value every subsequent time it is called (`n`, `n + 1`, `n + 2`, etc).
+
+**Example 1:**
+
+**Input:** n = 10 ["call","call","call"]
+
+**Output:** [10,11,12]
+
+**Explanation:** 
+
+counter() = 10 // The first time counter() is called, it returns n. 
+
+counter() = 11 // Returns 1 more than the previous time. 
+
+counter() = 12 // Returns 1 more than the previous time.
+
+**Example 2:**
+
+**Input:** n = -2 ["call","call","call","call","call"]
+
+**Output:** [-2,-1,0,1,2]
+
+**Explanation:** counter() initially returns -2. Then increases after each sebsequent call.
+
+**Constraints:**
+
+*   `-1000<= n <= 1000`
+*   `At most 1000 calls to counter() will be made`

src/main/java/g2601_2700/s2620_counter/solution.ts

@@ -0,0 +1,18 @@
+// #Easy #2023_08_31_Time_43_ms_(98.60%)_Space_42.2_MB_(91.27%)
+
+function createCounter(n: number): () => number {
+    const fun = function () {
+        n++
+        return n - 1
+    }
+    return fun
+}
+
+/*
+ * const counter = createCounter(10)
+ * counter() // 10
+ * counter() // 11
+ * counter() // 12
+ */
+
+export { createCounter }

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

@@ -0,0 +1,25 @@
+2621\. Sleep
+
+Easy
+
+Given a positive integer `millis`, write an asynchronous function that sleeps for `millis` milliseconds. It can resolve any value.
+
+**Example 1:**
+
+**Input:** millis = 100
+
+**Output:** 100
+
+**Explanation:** It should return a promise that resolves after 100ms. let t = Date.now(); sleep(100).then(() => { console.log(Date.now() - t); // 100 });
+
+**Example 2:**
+
+**Input:** millis = 200
+
+**Output:** 200
+
+**Explanation:** It should return a promise that resolves after 200ms.
+
+**Constraints:**
+
+*   `1 <= millis <= 1000`

src/main/java/g2601_2700/s2621_sleep/solution.ts

@@ -0,0 +1,12 @@
+// #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));
+}
+
+/*
+ * let t = Date.now()
+ * sleep(100).then(() => console.log(Date.now() - t)) // 100
+ */
+
+export { sleep }

src/main/java/g2601_2700/s2622_cache_with_time_limit/readme.md

@@ -0,0 +1,60 @@
+2622\. Cache With Time Limit
+
+Medium
+
+Write a class that allows getting and setting key-value pairs, however a **time until expiration** is associated with each key.
+
+The class has three public methods:
+
+`set(key, value, duration)`: accepts an integer `key`, an integer `value`, and a `duration` in milliseconds. Once the `duration` has elapsed, the key should be inaccessible. The method should return `true` if the same un-expired key already exists and `false` otherwise. Both the value and duration should be overwritten if the key already exists.
+
+`get(key)`: if an un-expired key exists, it should return the associated value. Otherwise it should return `-1`.
+
+`count()`: returns the count of un-expired keys.
+
+**Example 1:**
+
+**Input:** ["TimeLimitedCache", "set", "get", "count", "get"] [[], [1, 42, 100], [1], [], [1]] [0, 0, 50, 50, 150]
+
+**Output:** [null, false, 42, 1, -1]
+
+**Explanation:** 
+
+At t=0, the cache is constructed. 
+
+At t=0, a key-value pair (1: 42) is added with a time limit of 100ms. The value doesn't exist so false is returned. 
+
+At t=50, key=1 is requested and the value of 42 is returned. 
+
+At t=50, count() is called and there is one active key in the cache. 
+
+At t=100, key=1 expires. 
+
+At t=150, get(1) is called but -1 is returned because the cache is empty.
+
+**Example 2:**
+
+**Input:** ["TimeLimitedCache", "set", "set", "get", "get", "get", "count"] [[], [1, 42, 50], [1, 50, 100], [1], [1], [1], []] [0, 0, 40, 50, 120, 200, 250]
+
+**Output:** [null, false, true, 50, 50, -1]
+
+**Explanation:** 
+
+At t=0, the cache is constructed. 
+
+At t=0, a key-value pair (1: 42) is added with a time limit of 50ms. The value doesn't exist so false is returned. 
+
+At t=40, a key-value pair (1: 50) is added with a time limit of 100ms. A non-expired value already existed so true is returned and the old value was overwritten. 
+
+At t=50, get(1) is called which returned 50. At t=120, get(1) is called which returned 50. 
+
+At t=140, key=1 expires. At t=200, get(1) is called but the cache is empty so -1 is returned. 
+
+At t=250, count() returns 0 because the cache is empty.
+
+**Constraints:**
+
+*   <code>0 <= key <= 10<sup>9</sup></code>
+*   <code>0 <= value <= 10<sup>9</sup></code>
+*   `0 <= duration <= 1000`
+*   `total method calls will not exceed 100`

src/main/java/g2601_2700/s2622_cache_with_time_limit/solution.ts

@@ -0,0 +1,39 @@
+// #Medium #2023_08_31_Time_51_ms_(94.82%)_Space_42.2_MB_(94.26%)
+
+class TimeLimitedCache {
+    private keyMap: Map<number, any>
+    constructor() {
+        this.keyMap = new Map<number, any>()
+    }
+
+    set(key: number, value: number, duration: number): boolean {
+        let existed: boolean = this.keyMap.has(key)
+        if (existed) clearTimeout(this.keyMap.get(key).clearRef)
+
+        this.keyMap.set(key, {
+            value,
+            clearRef: setTimeout(() => {
+                this.keyMap.delete(key)
+            }, duration),
+        })
+        return existed
+    }
+
+    get(key: number): number {
+        return this.keyMap.has(key) ? this.keyMap.get(key).value : -1
+    }
+
+    count(): number {
+        return this.keyMap.size
+    }
+}
+
+/*
+ * Your TimeLimitedCache object will be instantiated and called as such:
+ * var obj = new TimeLimitedCache()
+ * obj.set(1, 42, 1000); // false
+ * obj.get(1) // 42
+ * obj.count() // 1
+ */
+
+export { TimeLimitedCache }

src/main/java/g2601_2700/s2623_memoize/readme.md

@@ -0,0 +1,75 @@
+2623\. Memoize
+
+Medium
+
+Given a function `fn`, return a **memoized** version of that function.
+
+A **memoized **function is a function that will never be called twice with the same inputs. Instead it will return a cached value.
+
+You can assume there are **3 **possible input functions: `sum`**,** `fib`**, **and `factorial`**.**
+
+*   `sum`accepts two integers `a` and `b` and returns `a + b`.
+*   `fib`accepts a single integer `n` and returns `1` if `n <= 1` or `fib(n - 1) + fib(n - 2)` otherwise.
+*   `factorial` accepts a single integer `n` and returns `1` if `n <= 1` or `factorial(n - 1) * n` otherwise.
+
+**Example 1:**
+
+**Input** "sum" ["call","call","getCallCount","call","getCallCount"] [[2,2],[2,2],[],[1,2],[]]
+
+**Output:** [4,4,1,3,2]
+
+**Explanation:** 
+
+const sum = (a, b) => a + b; 
+
+const memoizedSum = memoize(sum); 
+
+memoizedSum(2, 2); // Returns 4. sum() was called as (2, 2) was not seen before. 
+
+memoizedSum(2, 2); // Returns 4. However sum() was not called because the same inputs were seen before. 
+
+// Total call count: 1 
+
+memoizedSum(1, 2); // Returns 3. sum() was called as (1, 2) was not seen before. 
+
+// Total call count: 2
+
+**Example 2:**
+
+**Input** "factorial" ["call","call","call","getCallCount","call","getCallCount"] [[2],[3],[2],[],[3],[]]
+
+**Output:** [2,6,2,2,6,2]
+
+**Explanation:** 
+
+const factorial = (n) => (n <= 1) ? 1 : (n \* factorial(n - 1)); 
+
+const memoFactorial = memoize(factorial); 
+
+memoFactorial(2); // Returns 2. 
+
+memoFactorial(3); // Returns 6. 
+
+memoFactorial(2); // Returns 2. However factorial was not called because 2 was seen before.
+
+// Total call count: 2 
+
+memoFactorial(3); // Returns 6. However factorial was not called because 3 was seen before. 
+
+// Total call count: 2
+
+**Example 3:**
+
+**Input** "fib" ["call","getCallCount"] [[5],[]]
+
+**Output:** [8,1]
+
+**Explanation:** fib(5) = 8 // Total call count: 1
+
+**Constraints:**
+
+*   <code>0 <= a, b <= 10<sup>5</sup></code>
+*   `1 <= n <= 10`
+*   <code>at most 10<sup>5</sup> function calls</code>
+*   <code>at most 10<sup>5</sup> attempts to access callCount</code>
+*   `input function is sum, fib, or factorial`

src/main/java/g2601_2700/s2623_memoize/solution.ts

@@ -0,0 +1,30 @@
+// #Medium #2023_08_31_Time_264_ms_(97.20%)_Space_109.2_MB_(32.97%)
+
+type Fn = (...params: any) => any
+
+function memoize(fn: Fn): Fn {
+    const mem_args: Map<string, any> = new Map<string, any>()
+    return function (...args) {
+        const args_str = args.toString()
+        if (mem_args.has(args_str)) {
+            return mem_args.get(args_str)
+        }
+
+        const result = fn(...args)
+        mem_args.set(args_str, result)
+        return result
+    }
+}
+
+/*
+ * let callCount = 0;
+ * const memoizedFn = memoize(function (a, b) {
+ *	 callCount += 1;
+ *   return a + b;
+ * })
+ * memoizedFn(2, 3) // 5
+ * memoizedFn(2, 3) // 5
+ * console.log(callCount) // 1
+ */
+
+export { memoize }