add js examples

Author: Barklim

2666-allow-one-function-call.js

@@ -17,3 +17,20 @@
 var once = function(fn) {
   return (...args) => fn && [fn(...args), fn = undefined][0];
 };
+
+// var once = function(fn) {
+    
+//   let hasBeenCalled = false;
+//   let result;
+
+//   return function(...args) {
+//     if (!hasBeenCalled) {
+//       result = fn(...args);
+//       hasBeenCalled = true;
+//       return result;
+//     } else {
+//       return undefined;
+//     }
+//   }
+
+// };

2722-join-two-arrays-by-id.js

@@ -30,3 +30,19 @@ var join = function(arr1, arr2) {
   [...arr1, ...arr2].forEach(obj => map.set(obj.id, { ...map.get(obj.id), ...obj }));
   return Array.from(map.values()).sort((a, b) => a.id - b.id);
 };
+
+// var join = function(arr1, arr2) {
+//   const result = {};
+//   for (let i = 0; i < arr1.length; i++) {
+//       result[arr1[i].id] = arr1[i];
+//   } 
+//   for (let i = 0; i < arr2.length; i++) {
+//       if (result[arr2[i].id]) {
+//           for (const key in arr2[i]) result[arr2[i].id][key] = arr2[i][key];  
+//       } else {
+//           result[arr2[i].id] = arr2[i];
+//       }
+//   } 
+
+//   return Object.values(result);
+// };

example/README.md

@@ -280,6 +280,15 @@ Better order to solve problems
 2634. Filter Elements from Array
 2626. Array Reduce Transformation
 2629. Function Composition
+2666. Allow One Function Call
+2623. Memoize
+
+2677. Chunk Array
+2631. Group By
+2724. Sort By
+2722. Join Two Arrays by ID
+2625. Flatten Deeply Nested Array
+2705. Compact Object
 
 ### [Strong List](structy.net)
 

example/js/2623.js

@@ -0,0 +1,43 @@
+/**
+ * 2623. Memoize
+ * https://leetcode.com/problems/memoize/
+ * Difficulty: 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. Assume that
+ *   if a value has already been cached for the arguments (b, a) where
+ *   a != b, it cannot be used for the arguments (a, b). For example,
+ *   if the arguments are (3, 2) and (2, 3), two separate calls should
+ *   be made.
+ * - `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.
+ */
+
+/**
+ * @param {Function} fn
+ * @return {Function}
+ */
+function memoize(fn) {
+    
+    return function(...args) {
+        
+    }
+}
+
+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

example/js/2625.js

@@ -0,0 +1,27 @@
+/**
+ * 2625. Flatten Deeply Nested Array
+ * https://leetcode.com/problems/flatten-deeply-nested-array/
+ * Difficulty: Medium
+ *
+ * Given a multi-dimensional array arr and a depth n, return a flattened version of that array.
+ *
+ * A multi-dimensional array is a recursive data structure that contains integers or other
+ * multi-dimensional arrays.
+ *
+ * A flattened array is a version of that array with some or all of the sub-arrays removed and
+ * replaced with the actual elements in that sub-array. This flattening operation should only
+ * be done if the current depth of nesting is less than n. The depth of the elements in the
+ * first array are considered to be 0.
+ *
+ * Please solve it without the built-in Array.flat method.
+ */
+
+/**
+ * @param {Array} arr
+ * @param {number} depth
+ * @return {Array}
+ */
+var flat = function(arr, n) {
+
+};
+  

example/js/2631.js

@@ -0,0 +1,56 @@
+/**
+ * 2631. Group By
+ * https://leetcode.com/problems/group-by/
+ * Difficulty: 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 which generate 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.
+ */
+
+/**
+ * @param {Function} fn
+ * @return {Object}
+ */
+Array.prototype.groupBy = function(fn) {
+
+};
+
+const array1 = [
+    {id: 1},
+    {id: 1},
+    {id: 2}
+]
+
+const fn = (item) => item.id
+
+console.log(array1.groupBy(fn))
+// {
+//     1: [{id: 1}, {id: 1}],
+//     2: [{id: 2}]
+// }
+
+// Ex2
+const array2 = [1, 2, 3]
+console.log(array2.groupBy(String))
+// {
+//     "1": [1],
+//     "2": [2],
+//     "3": [3],
+// }
+
+// Ex3
+const array3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+const fn3 = function (n) { 
+    return String(n > 5);
+}
+console.log(array3.groupBy(fn3))

example/js/2666.js

@@ -0,0 +1,27 @@
+/**
+ * 2666. Allow One Function Call
+ * https://leetcode.com/problems/allow-one-function-call/
+ * Difficulty: Easy
+ *
+ * Given a function fn, return a new function that is identical to the original function except
+ * that it ensures fn is called at most once.
+ *
+ * - The first time the returned function is called, it should return the same result as fn.
+ * - Every subsequent time it is called, it should return undefined.
+ */
+var once = function(fn) {
+    
+    return function(...args){
+        
+    }
+};
+
+let fn = (a,b,c) => (a + b + c)
+let onceFn = once(fn)
+
+ex1 = onceFn(1,2,3); // 6
+ex2 = onceFn(2,3,6); // returns undefined without calling fn
+
+console.log(ex1)
+console.log(ex2)
+

example/js/2677.js

@@ -0,0 +1,37 @@
+/**
+ * 2677. Chunk Array
+ * https://leetcode.com/problems/chunk-array/
+ * Difficulty: Easy
+ *
+ * Given an array arr and a chunk size size, return a chunked array.
+ *
+ * A chunked array contains the original elements in arr, but consists of subarrays each of
+ * length size. The length of the last subarray may be less than size if arr.length is not
+ * evenly divisible by size.
+ *
+ * You may assume the array is the output of JSON.parse. In other words, it is valid JSON.
+ *
+ * Please solve it without using lodash's _.chunk function.
+ */
+
+/**
+ * @param {Array} arr
+ * @param {number} size
+ * @return {Array}
+ */
+var chunk = function(arr, size) {
+
+};
+
+ex1 = chunk([1,2,3,4,5], 1)
+console.log(ex1) // [[1],[2],[3],[4],[5]]
+
+ex2 = chunk([1,9,6,3,2], 3)
+console.log(ex2) // [[1,9,6],[3,2]]
+
+ex3 = chunk([8,5,3,2,6], 6)
+console.log(ex3) // [[8,5,3,2,6]]
+
+ex4 = chunk([], 1)
+console.log(ex4) // []
+  

example/js/2705.js

@@ -0,0 +1,31 @@
+/**
+ * 2705. Compact Object
+ * https://leetcode.com/problems/compact-object/
+ * Difficulty: Medium
+ *
+ * Given an object or array obj, return a compact object.
+ *
+ * A compact object is the same as the original object, except with keys containing falsy
+ * values removed. This operation applies to the object and any nested objects. Arrays are
+ * considered objects where the indices are keys. A value is considered falsy when
+ * Boolean(value) returns false.
+ *
+ * You may assume the obj is the output of JSON.parse. In other words, it is valid JSON.
+ */
+
+/**
+ * @param {Object|Array} obj
+ * @return {Object|Array}
+ */
+var compactObject = function(obj) {
+
+};
+
+ex1 = compactObject([null, 0, false, 1])
+console.log(ex1) // [1]
+
+ex2 = compactObject({"a": null, "b": [false, 1]})
+console.log(ex2) // {"b": [1]}
+
+ex3 = compactObject([null, 0, 5, [0], [false, 16]])
+console.log(ex3) // [5, [], [16]]

example/js/2722.js

@@ -0,0 +1,78 @@
+/**
+ * 2722. Join Two Arrays by ID
+ * https://leetcode.com/problems/join-two-arrays-by-id/
+ * Difficulty: Medium
+ *
+ * Given two arrays arr1 and arr2, return a new array joinedArray. All the objects in each
+ * of the two inputs arrays will contain an id field that has an integer value.
+ *
+ * joinedArray is an array formed by merging arr1 and arr2 based on their id key. The length
+ * of joinedArray should be the length of unique values of id. The returned array should be
+ * sorted in ascending order based on the id key.
+ *
+ * If a given id exists in one array but not the other, the single object with that id should
+ * be included in the result array without modification.
+ *
+ * If two objects share an id, their properties should be merged into a single object:
+ * - If a key only exists in one object, that single key-value pair should be included in
+ *   the object.
+ * - If a key is included in both objects, the value in the object from arr2 should override
+ *   the value from arr1.
+ */
+
+/**
+ * @param {Array} arr1
+ * @param {Array} arr2
+ * @return {Array}
+ */
+var join = function(arr1, arr2) {
+
+};
+
+
+arr1 = [
+    {"id": 1, "x": 1},
+    {"id": 2, "x": 9}
+], 
+arr2 = [
+    {"id": 3, "x": 5}
+]
+
+ex1 = join(arr1, arr2)
+console.log(ex1)
+// [
+//     {"id": 1, "x": 1},
+//     {"id": 2, "x": 9},
+//     {"id": 3, "x": 5}
+// ]
+
+
+arr1 = [
+    {"id": 1, "x": 2, "y": 3},
+    {"id": 2, "x": 3, "y": 6}
+], 
+arr2 = [
+    {"id": 2, "x": 10, "y": 20},
+    {"id": 3, "x": 0, "y": 0}
+]
+
+ex2 = join(arr1, arr2)
+console.log(ex2)
+// [
+//     {"id": 1, "x": 2, "y": 3},
+//     {"id": 2, "x": 10, "y": 20},
+//     {"id": 3, "x": 0, "y": 0}
+// ]
+
+arr1 = [
+    {"id": 1, "b": {"b": 94}, "v": [4, 3], "y": 48}
+], 
+arr2 = [
+    {"id": 1, "b": {"c": 84}, "v": [1, 3]}
+]
+
+ex3 = join(arr1, arr2)
+console.log(ex3)
+// [
+//     {"id": 1, "b": {"c": 84}, "v": [1, 3], "y": 48}
+// ]