Added tasks 2630-2637

Author: ThanhNIT

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

@@ -0,0 +1,63 @@
+2630\. Memoize II
+
+Hard
+
+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.
+
+`fn` can be any function and there are no constraints on what type of values it accepts. Inputs are considered identical if they are `===` to each other.
+
+**Example 1:**
+
+**Input:** 
+
+getInputs = () => [[2,2],[2,2],[1,2]] 
+
+fn = function (a, b) { return a + b; }
+
+**Output:** [{"val":4,"calls":1},{"val":4,"calls":1},{"val":3,"calls":2}]
+
+**Explanation:** 
+
+    const inputs = getInputs(); 
+    const memoized = memoize(fn); 
+    for (const arr of inputs) { 
+        memoized(...arr); 
+    } 
+
+For the inputs of (2, 2): 2 + 2 = 4, and it required a call to fn(). 
+
+For the inputs of (2, 2): 2 + 2 = 4, but those inputs were seen before so no call to fn() was required. 
+
+For the inputs of (1, 2): 1 + 2 = 3, and it required another call to fn() for a total of 2.
+
+**Example 2:**
+
+**Input:** 
+
+getInputs = () => [[{},{}],[{},{}],[{},{}]] 
+
+fn = function (a, b) { return ({...a, ...b}); }
+
+**Output:** [{"val":{},"calls":1},{"val":{},"calls":2},{"val":{},"calls":3}]
+
+**Explanation:** Merging two empty objects will always result in an empty object. It may seem like there should only be 1 call to fn() because of cache-hits, however none of those objects are === to each other.
+
+**Example 3:**
+
+**Input:** 
+
+getInputs = () => { const o = {}; return [[o,o],[o,o],[o,o]]; } 
+
+fn = function (a, b) { return ({...a, ...b}); }
+
+**Output:** [{"val":{},"calls":1},{"val":{},"calls":1},{"val":{},"calls":1}]
+
+**Explanation:** Merging two empty objects will always result in an empty object. The 2nd and 3rd third function calls result in a cache-hit. This is because every object passed in is identical.
+
+**Constraints:**
+
+*   <code>1 <= inputs.length <= 10<sup>5</sup></code>
+*   <code>0 <= inputs.flat().length <= 10<sup>5</sup></code>
+*   `inputs[i][j] != NaN`

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

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

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

@@ -0,0 +1,92 @@
+2631\. Group By
+
+Medium
+
+Write code that enhances all arrays such that you can call the `array.groupBy(fn)` method on any array and it will return a **grouped** version of the array.
+
+A **grouped** array is an object where each key is the output of `fn(arr[i])` and each value is an array containing all items in the original array with that key.
+
+The provided callback `fn` will accept an item in the array and return a string key.
+
+The order of each value list should be the order the items appear in the array. Any order of keys is acceptable.
+
+Please solve it without lodash's `_.groupBy` function.
+
+**Example 1:**
+
+**Input:** 
+
+    array = [ 
+        {"id":"1"}, 
+        {"id":"1"}, 
+        {"id":"2"} 
+    ], 
+    fn = function (item) { 
+        return item.id; 
+    }
+
+**Output:** 
+
+    { 
+        "1": [{"id": "1"}, {"id": "1"}], 
+        "2": [{"id": "2"}] 
+    }
+
+**Explanation:** 
+
+    Output is from array.groupBy(fn). 
+    The selector function gets the "id" out of each item in the array. 
+    There are two objects with an "id" of 1. Both of those objects are put in the first array. 
+    There is one object with an "id" of 2. That object is put in the second array.
+
+**Example 2:**
+
+**Input:** 
+
+    array = [ 
+        [1, 2, 3], 
+        [1, 3, 5], 
+        [1, 5, 9] 
+    ] 
+    fn = function (list) { 
+        return String(list[0]); 
+    }
+
+**Output:** 
+
+    { 
+        "1": [[1, 2, 3], [1, 3, 5], [1, 5, 9]] 
+    }
+
+**Explanation:** 
+
+The array can be of any type. In this case, the selector function defines the key as being the first element in the array. 
+
+All the arrays have 1 as their first element so they are grouped together. 
+
+    { 
+        "1": [[1, 2, 3], [1, 3, 5], [1, 5, 9]] 
+    }
+
+**Example 3:**
+
+**Input:** 
+
+    array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    fn = function (n) { 
+        return String(n > 5); 
+    }
+
+**Output:** 
+
+    { 
+        "true": [6, 7, 8, 9, 10], 
+        "false": [1, 2, 3, 4, 5] 
+    }
+
+**Explanation:** The selector function splits the array by whether each number is greater than 5.
+
+**Constraints:**
+
+*   <code>0 <= array.length <= 10<sup>5</sup></code>
+*   `fn returns a string`

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

@@ -0,0 +1,26 @@
+// #Medium #2023_08_31_Time_101_ms_(99.50%)_Space_63.8_MB_(87.11%)
+
+declare global {
+    interface Array<T> {
+        groupBy(fn: (item: T) => string): Record<string, T[]>
+    }
+}
+
+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;
+};
+
+/*
+ * [1,2,3].groupBy(String) // {"1":[1],"2":[2],"3":[3]}
+ */
+
+ export { }

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

@@ -0,0 +1,51 @@
+2634\. Filter Elements from Array
+
+Easy
+
+Given an integer array `arr` and a filtering function `fn`, return a filtered array `filteredArr`.
+
+The `fn` function takes one or two arguments:
+
+*   `arr[i]` - number from the `arr`
+*   `i` - index of `arr[i]`
+
+`filteredArr` should only contain the elements from the `arr` for which the expression `fn(arr[i], i)` evaluates to a **truthy** value. A **truthy** value is a value where `Boolean(value)` returns `true`.
+
+Please solve it without the built-in Array.filter method.
+
+**Example 1:**
+
+**Input:** arr = [0,10,20,30], fn = function greaterThan10(n) { return n > 10; }
+
+**Output:** [20,30]
+
+**Explanation:** 
+
+const newArray = filter(arr, fn); // [20, 30] 
+
+The function filters out values that are not greater than 10
+
+**Example 2:**
+
+**Input:** arr = [1,2,3], fn = function firstIndex(n, i) { return i === 0; }
+
+**Output:** [1]
+
+**Explanation:** 
+
+fn can also accept the index of each element 
+
+In this case, the function removes elements not at index 0
+
+**Example 3:**
+
+**Input:** arr = [-2,-1,0,1,2], fn = function plusOne(n) { return n + 1 }
+
+**Output:** [-2,0,1,2]
+
+**Explanation:** Falsey values such as 0 should be filtered out
+
+**Constraints:**
+
+*   `0 <= arr.length <= 1000`
+*   <code>-10<sup>9</sup> <= arr[i] <= 10<sup>9</sup></code>

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

@@ -0,0 +1,13 @@
+// #Easy #2023_08_31_Time_44_ms_(98.04%)_Space_42.7_MB_(69.67%)
+
+function filter(arr: number[], fn: (n: number, i: number) => boolean): number[] {
+    const filteredArr: number[] = []
+
+    for (let i = 0; i < arr.length; i++) {
+        if (fn(arr[i], i)) filteredArr.push(arr[i])
+    }
+
+    return filteredArr
+}
+
+export { filter }

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

@@ -0,0 +1,43 @@
+2635\. Apply Transform Over Each Element in Array
+
+Easy
+
+Given an integer array `arr` and a mapping function `fn`, return a new array with a transformation applied to each element.
+
+The returned array should be created such that `returnedArray[i] = fn(arr[i], i)`.
+
+Please solve it without the built-in `Array.map` method.
+
+**Example 1:**
+
+**Input:** arr = [1,2,3], fn = function plusone(n) { return n + 1; }
+
+**Output:** [2,3,4]
+
+**Explanation:** 
+
+const newArray = map(arr, plusone); // [2,3,4] 
+
+The function increases each value in the array by one.
+
+**Example 2:**
+
+**Input:** arr = [1,2,3], fn = function plusI(n, i) { return n + i; }
+
+**Output:** [1,3,5]
+
+**Explanation:** The function increases each value by the index it resides in.
+
+**Example 3:**
+
+**Input:** arr = [10,20,30], fn = function constant() { return 42; }
+
+**Output:** [42,42,42]
+
+**Explanation:** The function always returns 42.
+
+**Constraints:**
+
+*   `0 <= arr.length <= 1000`
+*   <code>-10<sup>9</sup> <= arr[i] <= 10<sup>9</sup></code>
+*   `fn returns a number`

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

@@ -0,0 +1,11 @@
+// #Easy #2023_08_31_Time_43_ms_(98.46%)_Space_42.2_MB_(92.83%)
+
+function map(arr: number[], fn: (n: number, i: number) => number): number[] {
+    const res: number[] = []
+    for (let i = 0; i < arr.length; i++) {
+        res.push(fn(arr[i], i))
+    }
+    return res
+}
+
+export { map }