update

Author: MaiDeveloper

best-time-to-buy-and-sell-stock-ii.js

@@ -0,0 +1,92 @@
+/**
+ * Best Time to Buy and Sell Stock II
+ * Say you have an array for which the ith element is the price of a given stock on day i.
+ *
+ * Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).
+ *
+ * Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).
+ *
+ * Example 1:
+ *
+ * Input: [7,1,5,3,6,4]
+ * Output: 7
+ * Explanation: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 5-1 = 4.
+ *              Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 6-3 = 3.
+ *
+ * Example 2:
+ *
+ * Input: [1,2,3,4,5]
+ * Output: 4
+ * Explanation: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 5-1 = 4.
+ *              Note that you cannot buy on day 1, buy on day 2 and sell them later, as you are
+ *              engaging multiple transactions at the same time. You must sell before buying again.
+ *
+ * Example 3:
+ *
+ * Input: [7,6,4,3,1]
+ * Output: 0
+ * Explanation: In this case, no transaction is done, i.e. max profit = 0.
+ */
+
+const assert = require('assert');
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ * @Complexity Analysis
+ * Time: O(n)
+ * Space: O(1)
+ */
+function maxProfit(prices) {
+    let profit = 0;
+
+    for (let i = 1, l = prices.length; i < l; i++) {
+      if (prices[i] > prices[i - 1]) {
+        profit += prices[i] - prices[i - 1];
+      }
+    }
+
+    return profit;
+}
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ * @Complexity Analysis
+ * Time: O(n)
+ * Space: O(1)
+ */
+function maxProfitPeakValley(prices) {
+  let len = prices.length;
+  let profit = 0;
+  let i = 0;
+  let valley;
+
+  while (i < len - 1) {
+
+    while (i < len - 1 && prices[i] >= prices[i + 1]) {
+      i++;
+    }
+
+    valley = prices[i];
+
+    while (i < len - 1 && prices[i] <= prices[i + 1]) {
+      i++;
+    }
+
+    profit += prices[i] - valley;
+  }
+
+
+  return profit;
+}
+
+
+assert.deepStrictEqual(maxProfit([7,1,5,3,6,4]), 7);
+assert.deepStrictEqual(maxProfit([1,2,3,4,5]), 4);
+assert.deepStrictEqual(maxProfit([7,6,4,3,1]), 0);
+
+assert.deepStrictEqual(maxProfitPeakValley([7,1,5,3,6,4]), 7);
+assert.deepStrictEqual(maxProfitPeakValley([1,2,3,4,5]), 4);
+assert.deepStrictEqual(maxProfitPeakValley([7,6,4,3,1]), 0);
+

merge-sort.js

@@ -0,0 +1,51 @@
+/**
+ * Algorithms: Implement Merge Sort
+ *
+ * Another intermediate sorting algorithm that is very common is merge sort. Like quick sort, merge sort also uses a divide-and-conquer, recursive methodology to sort an array. It takes advantage of the fact that it is relatively easy to sort two arrays as long as each is sorted in the first place. But we'll start with only one array as input, so how do we get to two sorted arrays from that? Well, we can recursively divide the original input in two until we reach the base case of an array with one item. A single-item array is naturally sorted, so then we can start combining. This combination will unwind the recursive calls that split the original array, eventually producing a final sorted array of all the elements. The steps of merge sort, then, are:
+ *
+ * 1) Recursively split the input array in half until a sub-array with only one element is produced.
+ *
+ * 2) Merge each sorted sub-array together to produce the final sorted array.
+ *
+ * Merge sort is an efficient sorting method, with time complexity of O(nlog(n)). This algorithm is popular because it is performant and relatively easy to implement.
+ *
+ * As an aside, this will be the last sorting algorithm we cover here. However, later in the section on tree data structures we will describe heap sort, another efficient sorting method that requires a binary heap in its implementation.
+ *
+ * Instructions: Write a function mergeSort which takes an array of integers as input and returns an array of these integers in sorted order from least to greatest. A good way to implement this is to write one function, for instance merge, which is responsible for merging two sorted arrays, and another function, for instance mergeSort, which is responsible for the recursion that produces single-item arrays to feed into merge. Good luck!
+ */
+
+function mergeSort(arr) {
+  if (arr.length <= 1) {
+    return arr;
+  }
+
+  const mid = Math.floor(arr.length / 2);
+  const left = mergeSort(arr.slice(0, mid));
+  const right = mergeSort(arr.slice(mid));
+
+  let i = 0;
+  let j = 0;
+  let sorted = [];
+
+  while (i < left.length && j < right.length) {
+    if (left[i] < right[j]) {
+      sorted.push(left[i++]);
+    } else {
+      sorted.push(right[j++]);
+    }
+  }
+
+  while (i < left.length) {
+    sorted.push(left[i++]);
+  }
+
+  while (j < right.length) {
+    sorted.push(right[j++]);
+  }
+
+  return sorted;
+}
+
+console.log(mergeSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]));
+console.log(mergeSort([1, 4, 2, 8, 345, 3]));
+console.log(mergeSort([1, 3, 2, 4, 5]));

quick-sort.js

@@ -0,0 +1,66 @@
+/**
+ * Algorithms: Implement Quick Sort
+ *
+ * Here we will move on to an intermediate sorting algorithm: quick sort. Quick sort is an efficient, recursive divide-and-conquer approach to sorting an array. In this method, a pivot value is chosen in the original array. The array is then partitioned into two subarrays of values less than and greater than the pivot value. We then combine the result of recursively calling the quick sort algorithm on both sub-arrays. This continues until the base case of an empty or single-item array is reached, which we return. The unwinding of the recursive calls return us the sorted array.
+ *
+ * Quick sort is a very efficient sorting method, providing O(nlog(n)) performance on average. It is also relatively easy to implement. These attributes make it a popular and useful sorting method.
+ *
+ * Instructions: Write a function quickSort which takes an array of integers as input and returns an array of these integers in sorted order from least to greatest. While the choice of the pivot value is important, any pivot will do for our purposes here. For simplicity, the first or last element could be used.
+ */
+
+function quickSort(array, left = 0, right = array.length - 1) {
+
+  if (left < right) {
+    let pivotIndex = pivot(array, left, right);
+
+    quickSort(array, left, pivotIndex - 1);
+    quickSort(array, pivotIndex + 1, right);
+  }
+
+  return array;
+}
+
+function pivot(array, left = 0, right = array.length - 1) {
+  let shift = left;
+
+  for (let i = left + 1; i <= right; i++) {
+    if (array[i] < array[left]) {
+      swap(array, i, ++shift);
+    }
+  }
+
+  swap(array, left, shift);
+
+  return shift;
+}
+
+// function partition(array, left, right) {
+//   let pivot = array[Math.floor((left + right) / 2)];
+
+//   while (left <= right) {
+
+//     while (array[left] < pivot) {
+//       left++;
+//     }
+
+//     while (array[right] > pivot) {
+//       right--;
+//     }
+
+//     if (left <= right) {
+//       swap(array, left, right);
+//       left++;
+//       right--;
+//     }
+
+//   }
+
+//   return left;
+// }
+
+function swap(arr, i, j) {
+  [arr[i], arr[j]] = [arr[j], arr[i]];
+}
+
+console.log(quickSort([1, 4, 2, 8, 345, 123, 43, 32, 5643, 63, 123, 43, 2, 55, 1, 234, 92]));
+