updating large collection of popular problems with solutions

Author: rohan-paul

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-complements.js

@@ -0,0 +1,15 @@
+// returns things in array 'a' that are not in array 'b'
+// ['a','b','c','1', '2', '3'].complement(['b', 'c', 'd', 'e']);
+// ['a', '1', '2', '3']
+
+complements = (arr1, arr2) => {
+
+	return (Array.isArray(arr1) && Array.isArray(arr2))
+	? arr1.filter((elem) => arr2.indexOf(elem) === - 1)
+	: undefined
+}
+
+let arr1 = ['a','b','c','1', '2', '3'];
+let arr2 = ['b', 'c', 'd', 'e'];
+
+console.log(complements(arr1, arr2));  // => [ 'a', '1', '2', '3' ]

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-left-rotation-by-steps.js

@@ -0,0 +1,37 @@
+/* The problem here gives, by how many steps the array will be rotated, and NOT by how many positions the Array will be rotated.
+
+A left rotation operation on an array of size shifts each of the array’s elements unit to the left. For example, if 2 left rotations are performed on array [1, 2, 3, 4, 5], then the array would become [3, 4, 5, 1, 2].
+
+The tests expe
+
+This solution, where a positive n rotates the array to the left, and a negative n to the right  */
+
+function leftRotateArray (array, rotationSteps) {
+    // check if the array is long enough to rotate
+    if (array.length < 2) {
+        return array.slice(0);
+    }
+    // calculate the number of rotation to do.
+    // But still we do this extra step, just to check if there's any need to rotate the array at all, with the code in the next line. Because, if I need to to rotate the array, 5000 times, it would take a while (code's O(n)). And in the end, the rotated array might be back where it started, making all those rotation pointless. So that seems like there are optimizations that can be made.
+    var n = rotationSteps % array.length;
+
+    // Id n is 0, then no need to rotate at all, we can just return a copy of the array. And in this case of no rotation, the reason I am returning a copy instead of the original array (which could the code more optimized ) is because, the function should always return a copy in order to be consistent. If it sometimes doesn't, we don't know what you're getting.
+
+    if (n === 0) {
+        return array.slice(0);
+    }
+
+    /* A> n can be negative only when "rotationNumber" (i.e. the dividend) is negative. For example, if rotationNumber is -1, (i.e. the purpose is to pass a negative rotation-count to rotate right) then the n will be -1 and so array.slice will return offset from the end of the sequence. That is, array.slice(-1) extracts the last elements in the sequence  OR array.slice(-4) extracts the last 4 elements of the array (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)
+
+    B> Now, rotating an array is the same as chopping it into two pieces and putting them together "backwards".
+
+   C> So, when rotaionNumber is -4 and do n = -4 % 5 (i.e. -4), in the below , first we extract the last 4 elements of the array, then to that concat the first element (i.e. array.slice(0, array.length + (-4)) which is array.slice(0, 1) which is the first element)
+    */
+    if (n < 0) {
+        return array.slice(n).concat(array.slice(0, array.length+n));
+    } else {
+        return array.slice(n).concat(array.slice(0, n));
+    }
+}
+
+console.log(leftRotateArray([1, 2, 3, 4, 5], 19));

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-of-Objects-mutate-formatting-Mongo-date-Performance.js

@@ -0,0 +1,52 @@
+const { data } = require("./mongo-json-data-TEST");
+const moment = require("moment");
+
+/* Problem Statement - From call to Mongo, I am getting the date field formatted according to Mongo's own formatting syntax. But after getting the raw data from Mongo, I shall format each of the date field to whatever formatting I need
+
+The Performance test here, implements the problem from file - array-of-Objects-mutate-formatting-Mongo-date
+
+
+*/
+
+/*
+The basic idea is to create a new empty object for each item in the array and assign the properties from old objects to them, respectively. This means we get an object with a new reference, so we are not going to modify the Original One.
+ */
+const doNotMutateOriginalArr = (arr) => {
+    let mutatedArr = arr.map(e => {
+  if (e.imported_date) {
+    e = {
+      ...e,
+      imported_date:
+        moment(e.imported_date).format("MMM D, YYYY 12:00:00 ") + `AM`
+    };
+  }
+   return e;
+});
+return mutatedArr
+}
+
+// In this function, I am mutating the original array itself.
+
+const mutateOriginalArr = (arr) => {
+    arr.map(e => {
+        if (e.imported_date) {
+            e.date = moment(e.imported_date).format("MMM D, YYYY 12:00:00 ") + `AM`
+        }
+        return e;
+    })
+    return arr;
+}
+
+// console.log(doNotMutateOriginalArr(data));
+// console.log(mutateOriginalArr(data));
+
+
+console.time("1st");
+doNotMutateOriginalArr(data)
+console.timeEnd("1st");
+
+console.log("*******************************");
+
+console.time("2nd");
+mutateOriginalArr(data)
+console.timeEnd("2nd");

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-of-Objects-mutate-formatting-Mongo-date.js

@@ -0,0 +1,89 @@
+/* Problem Statement - From call to Mongo, I am getting the date field formatted according to Mongo's own formatting syntax. But after getting the raw data from Mongo, I shall format each of the date field to whatever formatting I need.
+
+*/
+const moment = require("moment");
+
+// Original data that I will receive from Mongo
+const mongoData = [
+  {
+    _id: "5c77dc4c11ce1434b0029e7e",
+    imported_commodity_objectId: {
+      _id: "5c6c0f969c84ea3c7194a7de",
+      name: "Ash",
+      type: "Industrial Material",
+      createdAt: "2019-02-19T14:15:50.690Z",
+      updatedAt: "2019-02-19T14:15:50.690Z",
+      __v: 0
+    },
+    qty_in_mts: 22,
+    dateFromMongo: "2019-02-28T00:00:00.000Z",
+    no_of_vessels_per_day: 223,
+    createdAt: "2019-02-28T13:04:12.748Z",
+    updatedAt: "2019-02-28T13:04:21.203Z",
+    __v: 0
+  },
+  {
+    _id: "5c77d37169e8d22c8a18e622",
+    imported_commodity_objectId: {
+      _id: "5c6c0f839c84ea3c7194a7dd",
+      name: "Coal",
+      type: "Minerals",
+      createdAt: "2019-02-19T14:15:31.140Z",
+      updatedAt: "2019-02-19T14:15:31.140Z",
+      __v: 0
+    },
+    qty_in_mts: 55,
+    dateFromMongo: "2019-02-27T18:30:00.000Z",
+    no_of_vessels_per_day: 555,
+    createdAt: "2019-02-28T12:26:25.488Z",
+    updatedAt: "2019-02-28T12:26:33.223Z",
+    __v: 0
+  }
+];
+
+/* Note, here I am NOT mutating the original array.
+The basic idea is to create a new empty object for each item in the array and assign the properties from old objects to them, respectively. This means we get an object with a new reference, so we are not going to modify the Original One.
+  */
+const mutatedMongoData = mongoData.map(e => {
+  if (e.dateFromMongo) {
+    e = {
+      ...e,
+      dateFromMongo: moment(e.dateFromMongo).format("MMM D, YYYY 12:00:00 ") + `AM`
+    };
+  }
+  return e;
+});
+
+console.log(mutatedMongoData);
+
+
+/* Extremely important for React NOT TO MUTATE THE STATE
+
+FROM BLOG POST - https://medium.freecodecamp.org/handling-state-in-react-four-immutable-approaches-to-consider-d1f5c00249d5
+
+Imagine you have a form for editing a user. It’s common to create a single change handler to handle changes to all form fields. It may look something like this:
+
+
+```JS
+updateState(event) {
+ const {name, value} = event.target;
+ let user = this.state.user; // this is a reference, not a copy...
+ user[name] = value; // so this mutates state 🙀
+ return this.setState({user});
+}
+```
+
+I’m using ES6 object shorthand on line 5 — you can omit the right-hand side when the left-hand side matches.
+
+The concern is on line 4. Line 4 actually mutates state because the user variable is a reference to state. React state should be treated as immutable.
+
+From the React docs:
+
+Never mutate this.state directly, as calling setState() afterwards may replace the mutation you made. Treat this.state as if it were immutable.
+Why?
+
+setState batches work behind the scenes. This means a manual state mutation may be overridden when setState is processed.
+If you declare a shouldComponentUpdate method, you can’t use a === equality check inside because the object reference will not change. So the approach above has a potential performance impact as well.
+Bottom line: The example above often works okay, but to avoid edge cases, treat state as immutable.
+
+*/

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-of-Objects-mutate-simple.js

@@ -0,0 +1,40 @@
+const events = [
+  {
+    name: "First Event",
+    metadata: {
+      type: "public"
+    }
+  },
+  {
+    name: "Event 2",
+    metadata: {
+      type: "private"
+    }
+  },
+  {
+    name: "Third Event",
+    metadata: {
+      type: "closed"
+    }
+  }
+];
+
+/* FROM BLOG POST - https://medium.freecodecamp.org/handling-state-in-react-four-immutable-approaches-to-consider-d1f5c00249d5
+
+Note, here I am NOT mutating the original array.
+The basic idea is to create a new empty object for each item in the array and assign the properties from old objects to them, respectively. This means we get an object with a new reference, so we are not going to modify the Original One.
+  */
+const mappedEvents = events.map(e => {
+  if (e.name) {
+    e = { ...e, name: "Second Event Mutated" };
+  }
+  return e;
+});
+
+console.log(mappedEvents);
+
+/* OUTPUT -
+[ { name: 'Second Event Mutated', metadata: { type: 'public' } },
+  { name: 'Second Event Mutated', metadata: { type: 'private' } },
+  { name: 'Second Event Mutated', metadata: { type: 'closed' } } ]
+*/

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/array-right-rotation-by-no-of-positions.js

@@ -0,0 +1,16 @@
+/* Write a function that takes an array of integers and returns that array rotated by N positions.
+   For example, if N=2, given the input array [1, 2, 3, 4, 5, 6] the function should return [5, 6, 1, 2, 3, 4] */
+
+/* A> Rotating an array is the same as chopping it into two pieces and putting them together "backwards".
+
+B> So, for rotation, chop this array into 2 pieces the last 3 elements, and the rest of the elements.
+
+C> Now just bring those last 3 elements into first positon and concatenate the rest of the elements to this.
+*/
+
+function rightRotate (array, k) {
+    var L = array.length;
+    return array.slice(L - k).concat(array.slice(0, L - k));
+};
+
+console.log(rightRotate([1,2,3,4,5,6,7], 3));

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/find-closest-number-in-array.js

@@ -0,0 +1,8 @@
+// Find the number in an array that is closest to a given number
+
+// sort based on distance from the reference value num, and then take the first item.
+closestNumInArr = (arr, num) => {
+	return arr.sort((a, b) => Math.abs(num - a) - Math.abs(num - b))[0];
+}
+
+console.log(closestNumInArr([5,10,15,20,25,30,35], 22));

Large-Collection-of-Popular-Problems-with-Solutions/Array-Problems/find-count-of-max-elements.js

@@ -0,0 +1,30 @@
+/* Source Problem - https://youtu.be/E_hTGcx8o7g?t=3m24s - The Indian guy doing mock interview
+
+Given an array containing multiple number of max elements - count the number of max elements.
+
+so, given [ 1, 2, 2, 3, 4, 5, 4, 5] 
+
+I should return 2 as 5 occurs 2 times.
+*/
+
+maxCount = arr => {
+
+	arr = arr.sort((a, b) => b - a);
+
+	let max = Math.max(...arr);
+
+	result = 0;
+
+	for (let i = 0; i < arr.length; i++ ) {
+		if (max === arr[i]) {
+			result++
+		}
+		if (arr[i] < max) break;
+	}
+	return result;
+}
+
+
+let myArr = [ 1, 2, 2, 3, 4, 5, 4, 5] 
+
+console.log(maxCount(myArr));