final submit of the 30 days challenges

Author: ashish8513

CompactObject.js

@@ -0,0 +1,24 @@
+// 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.
+
+ 
+var compactObject = function(obj) {
+    if (Array.isArray(obj)) {
+      return obj.filter(Boolean).map(compactObject);
+    }
+    if (obj === null || typeof obj !== 'object') {
+      return obj;
+    }
+  
+    const result = {};
+    for (const key in obj) {
+      const value = compactObject(obj[key]);
+      if (Boolean(value)) {
+        result[key] = value;
+      }
+    }
+    return result;   
+  };

EventEmitter.js

@@ -0,0 +1,55 @@
+// 2694. Event Emitter
+// Medium
+// Companies
+// Design an EventEmitter class. This interface is similar (but with some differences) to the one found in Node.js or the Event Target interface of the DOM. The EventEmitter should allow for subscribing to events and emitting them.
+
+// Your EventEmitter class should have the following two methods:
+
+// subscribe - This method takes in two arguments: the name of an event as a string and a callback function. This callback function will later be called when the event is emitted.
+// An event should be able to have multiple listeners for the same event. When emitting an event with multiple callbacks, each should be called in the order in which they were subscribed. An array of results should be returned. You can assume no callbacks passed to subscribe are referentially identical.
+// The subscribe method should also return an object with an unsubscribe method that enables the user to unsubscribe. When it is called, the callback should be removed from the list of subscriptions and undefined should be returned.
+// emit - This method takes in two arguments: the name of an event as a string and an optional array of arguments that will be passed to the callback(s). If there are no callbacks subscribed to the given event, return an empty array. Otherwise, return an array of the results of all callback calls in the order they were subscribed.
+
+class EventEmitter {
+    events={};
+    /**
+     * @param {string} eventName
+     * @param {Function} callback
+     * @return {Object}
+     */
+    subscribe(eventName, callback) {
+        this.events[eventName]=this.events[eventName]||[];
+        return {
+            unsubscribe: () => {
+                this.events[eventName]=this.events[eventName].filter(fn=>fn!==callback)
+            }
+        };
+    }
+    
+    /**
+     * @param {string} eventName
+     * @param {Array} args
+     * @return {Array}
+     */
+    emit(eventName, args = []) {
+        const result=[];
+        if(this.events[eventName]){
+            for(let fn of this.events[eventName]){
+                result.push(fn(...args))
+            }
+        }
+        return result;
+    }
+}
+
+/**
+ * const emitter = new EventEmitter();
+ *
+ * // Subscribe to the onClick event with onClickCallback
+ * function onClickCallback() { return 99 }
+ * const sub = emitter.subscribe('onClick', onClickCallback);
+ *
+ * emitter.emit('onClick'); // [99]
+ * sub.unsubscribe(); // undefined
+ * emitter.emit('onClick'); // []
+ */

FlattenArrayDepplyNestedArray.js

@@ -0,0 +1,30 @@
+// 2625. Flatten Deeply Nested Array
+// Medium
+// Companies
+// Hint
+// 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) {
+    if(n==0)return arr;
+    let arrnew=[];
+    for(let i=0;i<arr.length;i++){
+
+        if(Array.isArray(arr[i])){
+          let temparr=flat(arr[i],n-1);
+          for(let j=0;j<temparr.length;j++)arrnew.push(temparr[j]);
+        }
+        else arrnew.push(arr[i]);
+    }
+    return arrnew;
+};

GroupBy.js

@@ -0,0 +1,30 @@
+// 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) {
+    let l={};
+   for(let i of this){
+      l[fn(i)]=[];
+     
+   }
+   
+   for(let i of this){
+      l[fn(i)].push(i);
+      
+   }
+   return l;
+};
+
+/**
+ * [1,2,3].groupBy(String) // {"1":[1],"2":[2],"3":[3]}
+ */

JoinTwoArrayByID.js

@@ -0,0 +1,28 @@
+// 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) {
+    const map = arr1.reduce((acc, item) => {
+      acc.set(item.id, item);
+      return acc;
+    }, new Map());
+  
+    arr2.forEach(item => {
+      const existingItem = map.get(item.id) || {};
+      map.set(item.id, { ...existingItem, ...item });
+    });
+  
+    return Array.from(map.values()).sort((a, b) => (a.id < b.id ? -1 : 1)); 
+  };