ugate · July 16, 2020 20:31 · Jul 16, 2020 · Jul 16, 2020 · Jul 16, 2020 · Jul 9, 2020
diff --git a/array-has-dups.js → array.has.dups.js b/array-has-dups.js → array.has.dups.js
diff --git a/array.occurances.rank.js → array.occurrence.rank.js b/array.occurances.rank.js → array.occurrence.rank.js
@@ -5,7 +5,7 @@
  * // [ [2,3], [4,2], [1,2], [-100,2], [0,1], [-10,1],
  * //   [10,1], [5,1]
  * // ]
- * @param {*[]} The array that contains the items that will
+ * @param {*[]} arr The array that contains the items that will
  * be ranked
  * @returns {*[]} A multi-dimensional array that is sorted
  * by the array's most frequently occurring item to the
@@ -20,22 +20,19 @@ function occurrencesRanks(arr) {
   for (let item of arr) {
     map.set(item, (map.has(item) ? map.get(item) : 0) + 1);
   }
-  const ranked = [...map].sort(function(a, b) {
-    return b[1] - a[1];
-  });console.log(ranked)
+  const ranked = [...map].sort((a, b) => b[1] - a[1]);
   return ranked;
 }
-
 /**
  * Extracts an array's most frequently occurring item by a
  * given rank
  * @example
  * // result will be [0,1] since it is the 3rd most
  * // frequently occurring item in the passed array
  * occurrencesRank([2,4,0,-10,4,10,5,2,1,1,-100,2,-100], 3);
- * @param {*[]} The array that contains the items that will
+ * @param {*[]} arr The array that contains the items that will
  * be ranked
- * @param {Integer} The occurrence rank that will be used
+ * @param {Integer} rank The occurrence rank that will be used
  * @returns {*[]} A two item array where the
  * __1st__ entry is the passed array's value and the
  * __2nd__ entry is the number of times it occurred in the

diff --git a/array-rm-dups-sorted.js → array.rm.dups.sorted.js b/array-rm-dups-sorted.js → array.rm.dups.sorted.js
diff --git a/array-total-increase.js → array.total.increase.js b/array-total-increase.js → array.total.increase.js
diff --git a/array.highest.occurances.js → array.occurances.rank.js b/array.highest.occurances.js → array.occurances.rank.js
diff --git a/array.highest.occurances.js b/array.highest.occurances.js
@@ -1,23 +1,55 @@
-function occurances(arr, rank) {
-  if (!Array.isArray(arr) || arr.length || !rank) return;
-  let ranks = new Array(rank);
-  ranks[0] = arr[0];
-  ranks.fill(Number.MIN_SAFE_INTEGER, 1);
-  let counts = {};
-  for (let num of arr) {
-    counts[num] = counts.hasOwnProperty(num) ? counts[num] + 1 : 1;
+/**
+ * @example
+ * occurrencesRanks([2,4,0,-10,4,10,5,2,1,1,-100,2,-100]);
+ * // result will be:
+ * // [ [2,3], [4,2], [1,2], [-100,2], [0,1], [-10,1],
+ * //   [10,1], [5,1]
+ * // ]
+ * @param {*[]} The array that contains the items that will
+ * be ranked
+ * @returns {*[]} A multi-dimensional array that is sorted
+ * by the array's most frequently occurring item to the
+ * lowest. Each item in the array will contain a two item
+ * array where the
+ * __1st__ entry is the passed array's value and the
+ * __2nd__ entry is the number of times it occurred in the
+ * array.
+ */
+function occurrencesRanks(arr) {
+  const map = new Map();
+  for (let item of arr) {
+    map.set(item, (map.has(item) ? map.get(item) : 0) + 1);
   }
-  for (let num in counts) {
-    if (counts[num] > rank[0]) {
-      rank[2] = rank[1];
-      rank[1] = rank[0];
-      rank[0] = counts[num];
-    } else if (counts[num] > rank[1]) {
-      rank[2] = rank[1];
-      rank[1] = counts[num];
-    } else if (counts[num] > rank[2]) {
-      rank[2] = counts[num];
-    }
+  const ranked = [...map].sort(function(a, b) {
+    return b[1] - a[1];
+  });console.log(ranked)
+  return ranked;
+}
+
+/**
+ * Extracts an array's most frequently occurring item by a
+ * given rank
+ * @example
+ * // result will be [0,1] since it is the 3rd most
+ * // frequently occurring item in the passed array
+ * occurrencesRank([2,4,0,-10,4,10,5,2,1,1,-100,2,-100], 3);
+ * @param {*[]} The array that contains the items that will
+ * be ranked
+ * @param {Integer} The occurrence rank that will be used
+ * @returns {*[]} A two item array where the
+ * __1st__ entry is the passed array's value and the
+ * __2nd__ entry is the number of times it occurred in the
+ * array.
+ */
+function occurrencesRank(arr, rank) {
+  if (rank > arr.length) return;
+  const ranked = occurrencesRanks(arr);
+  if (rank > ranked.length) return;
+  let prev = 0, rnkCnt = 1;
+  for (let rnk of ranked) {
+    if (prev && prev[1] === rnk[1]) continue;
+    if (rnkCnt === rank) return rnk;
+    rnkCnt++;
+    prev = rnk;
   }
-  return rank[2]; // 3rd largest count in array
 }
diff --git a/array.highest.occurances.js b/array.highest.occurances.js
@@ -0,0 +1,23 @@
+function occurances(arr, rank) {
+  if (!Array.isArray(arr) || arr.length || !rank) return;
+  let ranks = new Array(rank);
+  ranks[0] = arr[0];
+  ranks.fill(Number.MIN_SAFE_INTEGER, 1);
+  let counts = {};
+  for (let num of arr) {
+    counts[num] = counts.hasOwnProperty(num) ? counts[num] + 1 : 1;
+  }
+  for (let num in counts) {
+    if (counts[num] > rank[0]) {
+      rank[2] = rank[1];
+      rank[1] = rank[0];
+      rank[0] = counts[num];
+    } else if (counts[num] > rank[1]) {
+      rank[2] = rank[1];
+      rank[1] = counts[num];
+    } else if (counts[num] > rank[2]) {
+      rank[2] = counts[num];
+    }
+  }
+  return rank[2]; // 3rd largest count in array
+}
diff --git a/array.sort.zeros.end.js b/array.sort.zeros.end.js
@@ -10,9 +10,35 @@ function sortZeroEnd(nums) {
   });
 }
 
+/**
+ * Moves all the zeros to the end of the array while maintaining order
+ * @param {Integer[]} nums The numbers to be evaluated
+ * @returns {Integer[]} The passed nums
+ */
+function moveZerosEnd(nums) {
+  for (let i = 0, ln = nums.length; i < ln; ++i) {
+    if (nums[i] === 0) {
+      nums.push(nums.splice(i, 1)[0]);
+      --ln;
+      if (nums[i] === 0) --i;
+    }
+  }
+  return nums;
+}
+
 console.clear();
 
 console.log(`===================================`);
 var x = [0,1,0,3,12], y = [1,3,12,0,0];
 console.log(x, '===>', y);
-console.log('FINAL ===>', sortZeroEnd(x));
+console.log('FINAL ===>', sortZeroEnd(x));
+
+console.log(`===================================`);
+var x = [0,0,1], y = [1,0,0];
+console.log(x, '===>', y);
+console.log('FINAL ===>', moveZerosEnd(x));
+
+console.log(`===================================`);
+var x = [0,1,0,3,12], y = [1,3,12,0,0];
+console.log(x, '===>', y);
+console.log('FINAL ===>', moveZerosEnd(x));
diff --git a/array-has-dups.js b/array-has-dups.js
@@ -5,7 +5,7 @@
  */
 function hasDuplicate(arr) {
   for (let i = 0, j, ln = arr.length; i < ln; ++i) {
-    for (j = i + 1; j < ln; ++j) { console.log(arr[i], '===>', arr[j]);
+    for (j = i + 1; j < ln; ++j) {
       if (arr[i] === arr[j]) return true;
     }
   }

diff --git a/array-rm-dups-sorted.js b/array-rm-dups-sorted.js
@@ -18,6 +18,8 @@ function removeDuplicates(arr) {
   return arr.length;
 }
 
+// return [...new Set(nums)];
+
 // optimized
 function removeDuplicates2(nums) {
   let len = nums.length;
@@ -28,8 +30,8 @@ function removeDuplicates2(nums) {
     if (val === nums[i]) continue;
     index++;
     nums[index] = val = nums[i];
-  } 
-  return index+1;  
+  }
+  return index+1;
 }
 
 console.clear();

diff --git a/array.intersection.js b/array.intersection.js
@@ -0,0 +1,31 @@
+// not working yet
+function intersection(a, b) {
+  const ints = [];
+  for (let i = 0, al = a.length, bl = b.length; i < al; ++i) {
+    if (b.includes(a[i]) && ints.length < bl) {
+      ints.push(a[i]);
+    }
+  }
+  return ints;//a.filter((x => b.includes(x));
+}
+
+console.clear();
+
+console.log(`===================================`);
+var x = [1,2,2,1], y = [2,2];
+console.log(x, y);
+console.log('FINAL ===>', intersection(x,y)); //[2,2]
+
+var x = [4,9,5], y = [9,4,9,8,4];
+console.log(x, y);
+console.log('FINAL ===>', intersection(x,y));// [4,9]
+
+var x = [1,2,2,1], y = [2];
+console.log(x, y);
+console.log('FINAL ===>', intersection(x,y));// [2]
+
+var x = [61,24,20,58,95,53,17,32,45,85,70,20,83,62,35,89,5,95,12,86,58,77,30,64,46,13,5,92,67,40,20,38,31,18,89,85,7,30,67,34,62,35,47,98,3,41,53,26,66,40,54,44,57,46,70,60,4,63,82,42,65,59,17,98,29,72,1,96,82,66,98,6,92,31,43,81,88,60,10,55,66,82,0,79,11,81];
+var y = [5,25,4,39,57,49,93,79,7,8,49,89,2,7,73,88,45,15,34,92,84,38,85,34,16,6,99,0,2,36,68,52,73,50,77,44,61,48];
+var x = [1,2,2,1], y = [2];
+console.log(x, y);
+console.log('FINAL ===>', intersection(x,y));// [5,4,57,79,7,89,88,45,34,92,38,85,6,0,77,44,61]
diff --git a/array.sort.zeros.end.js b/array.sort.zeros.end.js
@@ -0,0 +1,18 @@
+/**
+ * Sorts an array of numbers so that all the zeros are at the end of the array
+ * @param {Integer[]} nums The numbers to sort
+ */
+function sortZeroEnd(nums) {
+  return nums.sort(function(a, b) {
+    if (a !== 0 && b === 0) return -1;
+    if (a === 0 && b !== 0) return 1;
+    return a - b;
+  });
+}
+
+console.clear();
+
+console.log(`===================================`);
+var x = [0,1,0,3,12], y = [1,3,12,0,0];
+console.log(x, '===>', y);
+console.log('FINAL ===>', sortZeroEnd(x));
diff --git a/array.unique.js b/array.unique.js
@@ -0,0 +1,12 @@
+/**
+ * Returns the 1st unique number in an array
+ * @param {Integer[]} arr The array to evaluate
+ * @returns {Integer} The unique number in the array (or zero when none)
+ */
+function uniqueNumber(nums) {
+  let unique;
+  for (let num of nums) {
+    unique ^= num;
+  }
+  return unique;
+}
diff --git a/array-has-dups.js b/array-has-dups.js
@@ -0,0 +1,24 @@
+/**
+ * Checks an array for duplicates
+ * @param {*[]} arr The array to check for duplicates
+ * @returns {Boolean} True when there are duplicates, false when there are none
+ */
+function hasDuplicate(arr) {
+  for (let i = 0, j, ln = arr.length; i < ln; ++i) {
+    for (j = i + 1; j < ln; ++j) { console.log(arr[i], '===>', arr[j]);
+      if (arr[i] === arr[j]) return true;
+    }
+  }
+  return false;
+}
+
+// optimized
+function containsDuplicate(nums) {
+  nums.sort();
+  for (let i = 1, prev = nums[0], curr, ln = nums.length; i < ln; ++i) {
+    curr = nums[i];
+    if (curr === prev) return true;
+    prev = curr;
+  }
+  return false;
+};
diff --git a/array-rm-dups-sorted.js b/array-rm-dups-sorted.js
@@ -0,0 +1,64 @@
+/**
+ * Removes duplicate entries in an array (in-place w/o generating another array)
+ * @param {*[]} arr The array where duplicates will be removed
+ * @returns {Integer} The new length of the array after removal
+ */
+function removeDuplicates(arr) {
+  for (let i = 0, si = 0, cnt; i < arr.length; ++i) {
+    if (arr[i] === arr[i + 1]) continue;
+    cnt = i - si;
+    if (cnt > 0) {
+      arr.splice(si, cnt);
+      i -= cnt;
+      si = i + 1;
+    } else if (arr[i] !== arr[i + 1]) {
+      si++;
+    }
+  }
+  return arr.length;
+}
+
+// optimized
+function removeDuplicates2(nums) {
+  let len = nums.length;
+  if (len === 1) return 1;
+  let index = 0;
+  let val = nums[0];
+  for(let i = 1; i < len; ++i) {
+    if (val === nums[i]) continue;
+    index++;
+    nums[index] = val = nums[i];
+  } 
+  return index+1;  
+}
+
+console.clear();
+console.log(`===================================`);
+var x = [1,1,1,2,2,2,3,4];
+console.log(x);
+removeDuplicates(x);
+console.log('FINAL ===>', x);
+
+console.log(`===================================`);
+var x = [1,2,2,2,3,4,4];
+console.log(x);
+removeDuplicates(x);
+console.log('FINAL ===>', x);
+
+console.log(`===================================`);
+var x = [1,1,1,2,3,3,4];
+console.log(x);
+removeDuplicates(x);
+console.log('FINAL ===>', x);
+
+console.log(`===================================`);
+var x = [1,2,2,3,4];
+console.log(x);
+removeDuplicates(x);
+console.log('FINAL ===>', x);
+
+console.log(`===================================`);
+var x = [1,1,2,3,4,4];
+console.log(x);
+removeDuplicates(x);
+console.log('FINAL ===>', x);
diff --git a/array-total-increase.js b/array-total-increase.js
@@ -0,0 +1,39 @@
+/**
+ * Determines the total increase between numbers in an array
+ * @param {*[]} arr The array that will be evaluated
+ * @returns {Integer} The total increase
+ */
+function maxProfit(arr) {
+  let max = 0;
+  for (let i = 1, ln = arr.length; i < ln; ++i) {
+    if (arr[i] > arr[i - 1]) {
+      max += arr[i] - arr[i - 1];
+    }
+  }
+  return max;
+}
+
+console.clear();
+var x = [7,1,5,3,6,4];
+console.log(x);
+console.log('EXPECTED 7 ===>', maxProfit(x));
+
+console.log(`===================================`);
+var x = [1,2,3,4,5];
+console.log(x);
+console.log('EXPECTED 4 ===>', maxProfit(x));
+
+console.log(`===================================`);
+var x = [7,6,4,3,1];
+console.log(x);
+console.log('EXPECTED 0 ===>', maxProfit(x));
+
+console.log(`===================================`);
+var x = [1,1,5,3,9,4];
+console.log(x);
+console.log('EXPECTED 10 ===>', maxProfit(x));
+
+console.log(`===================================`);
+var x = [6,2,3,4,7];
+console.log(x);
+console.log('EXPECTED 5 ===>', maxProfit(x));
diff --git a/array.shift.elements.js b/array.shift.elements.js
@@ -0,0 +1,38 @@
+/**
+ * Shifts an array to the right or left by a given amount via an array copy
+ * or in-place
+ * @param {*[]} arr The array to shift
+ * @param {Integer} amt The number of array elements to shift by
+ * @param {Boolean} [left] Truthy to shift to the left, otherwise, shifts
+ * elements to the right
+ * @param {Boolean} [copy] Truthy to make a copy of the array when shifting
+ * or falsy to shift the passed array in-place. __NOTE: The lower the `amt`
+ * the _faster_ the shift will be in-place versus making a copy. The reverse
+ * is also true- the higher the `amt` the _faster_ the copy will be versus
+ * shifting in-place.__
+ * @returns {*[]} Either the passed array (in-place) or a newly shifted array
+ * (copy)
+ */
+function shift(arr, amt, left, copy) {
+  if (copy) { // copy is faster
+    let count = amt > arr.length ? amt % arr.length : amt;
+    return arr.concat(arr.splice(0, (left ? count : arr.length - count)));
+  }
+  while (amt > 0) {
+    if (left) arr.push(arr.shift());
+    else arr.unshift(arr.pop());
+    --amt;
+  }
+  return arr;
+}
+
+console.clear();
+
+var x = [1,2,3,4,5,6,7], amt = 2;
+console.log('->', x);
+console.log(`shift right by ${amt} (copy)`, shift([1,2,3,4,5,6,7], amt, false, true));
+console.log(`shift right by ${amt} (in place)`, shift([1,2,3,4,5,6,7], amt));
+console.log(`===================================`);
+var x = [1,2,3,4,5,6,7], amt = 8;
+console.log(`shift right by ${amt} (copy)`, shift([1,2,3,4,5,6,7], amt, false, true));
+console.log(`shift right by ${amt} (in place)`, shift([1,2,3,4,5,6,7], amt));
No results found