update

Author: MaiDeveloper

get-max-profit.js

@@ -0,0 +1,35 @@
+/**
+ *  Writing programming interview questions hasn't made me rich yet ... so I might give up and start trading Apple stocks all day instead.
+ *
+ *  First, I wanna know how much money I could have made yesterday if I'd been trading Apple stocks all day.
+ *
+ *  So I grabbed Apple's stock prices from yesterday and put them in an array called stockPrices, where:
+ *
+ *  The indices are the time (in minutes) past trade opening time, which was 9:30am local time.
+ *  The values are the price (in US dollars) of one share of Apple stock at that time.
+ *
+ *  So if the stock cost $500 at 10:30am, that means stockPrices[60] = 500.
+ *
+ *  Write an efficient function that takes stockPrices and returns the best profit I could have made from one purchase and one sale of one share of Apple stock yesterday.
+ */
+
+function getMaxProfit(prices) {
+  if (prices.length < 2) {
+    throw new Error("Require at least two prices");
+  }
+
+  let minBuying = prices[0];
+  let maxProfit = -Infinity;
+
+  for (let i = 1, l = prices.length; i < l; i++) {
+    minBuying = Math.min(minBuying, prices[i]);
+    maxProfit = Math.max(maxProfit, prices[i] - minBuying);
+  }
+
+  return maxProfit;
+}
+
+const stockPrices = [10, 7, 5, 8, 11, 9];
+
+console.log(getMaxProfit(stockPrices));
+// Returns 6 (buying for $5 and selling for $11)

largest-range.js

@@ -0,0 +1,125 @@
+const assert = require('assert');
+
+/**
+ * Largest Range
+ * Write a function that takes in an array of integers and returns an array of length 2 representing the largest range of numbers contained in that array. The first number in the output array should be the first number in the range while the second number should be the last number in the range. A range of numbers is defined as a set of numbers that come right after each other in the set of real integers. For instance, the output array [2, 6] represents the range {2, 3, 4, 5, 6}, which is a range of length 5. Note that numbers do not need to be ordered or adjacent in the array in order to form a range. Assume that there will only be one largest range.
+ */
+
+function largestRange(array) {
+  const nums = {};
+  let ans = [];
+  let largest = 0;
+
+  for (let n of array) {
+    nums[n] = true;
+  }
+
+  for (let n of array) {
+    let len = 1;
+    let min = n - 1;
+    let max = n + 1;
+
+    nums[n] = false;
+
+    while (nums[min] === true) {
+      nums[min] = false;
+      len++;
+      min--;
+    }
+
+    while (nums[max] === true) {
+      nums[max] = false;
+      len++;
+      max++;
+    }
+
+    if (len > largest) {
+      largest = len;
+      ans = [min + 1, max - 1];
+    }
+  }
+
+  return ans;
+}
+
+
+function largestRange2(array) {
+  const nums = {};
+  let ans = [];
+  let largest = 0;
+
+  for (let n of array) {
+    nums[n] = true;
+  }
+
+  for (let n of array) {
+    if (nums[n] === false) {
+      continue;
+    }
+
+    nums[n] = false;
+
+    let currLen = 1;
+    let left = n - 1;
+    let right = n + 1;
+
+    while (nums[left] === true) {
+      nums[left] = false;
+      currLen++;
+      left--;
+    }
+
+    while (nums[right] === true) {
+      nums[right] = false;
+      currLen++;
+      right++;
+    }
+
+    if (currLen > largest) {
+      largest = currLen;
+      ans = [left + 1, right - 1];
+    }
+  }
+
+  return ans;
+}
+
+function largestRangeBasic(array) {
+  if (array.length === 1) {
+    return [array[0], array[0]];
+  }
+
+  array.sort((a, b) => a - b);
+
+  let largest = 0;
+  let ans = [];
+  let i = 0;
+  let j = 0;
+
+  for (let l = array.length; j < l; j++) {
+    if (j === l - 1 || array[j] !== array[j + 1] - 1) {
+      let curr = j - i + 1;
+
+      if (curr > largest) {
+        largest = curr;
+        ans = [array[i], array[j]];
+        i = j + 1;
+      }
+    }
+  }
+
+
+
+  return ans;
+}
+
+
+console.time('Run Time');
+
+assert.deepStrictEqual(largestRange([1]), [1, 1]);
+assert.deepStrictEqual(largestRange([1, 2]), [1, 2]);
+assert.deepStrictEqual(largestRange([4, 2, 1, 3]), [1, 4]);
+assert.deepStrictEqual(largestRange([4, 2, 1, 3, 6]), [1, 4]);
+assert.deepStrictEqual(largestRange([8, 4, 2, 10, 3, 6, 7, 9, 1]), [6, 10]);
+
+console.timeEnd('Run Time');