JS solution and tests for IC #3

Author: womcauliff

3-Highest-Product-of-Three/README.md

@@ -0,0 +1,15 @@
+# Highest Product of Three
+
+## Problem Description
+
+> Given an array of integers, find the highest product you can get from three of the integers.
+> The input `arrayOfInts` will always have at least three integers.
+
+## Implementation
+
+Given `n` integers in the array argument, my solution returns a result with time and space complexities of `O(n)` and `O(1)`, respectively.
+
+- JavaScript
+  - [Solution](./highestProductOf3.js)
+  - [Jest Tests](./highestProductOf3.test.js)
+  - [CodeSandbox](https://codesandbox.io/s/l4ny56913l?autoresize=1&fontsize=14&module=%2FhighestProductOf3.js&previewwindow=tests)

3-Highest-Product-of-Three/highestProductOf3.js

@@ -0,0 +1,80 @@
+/**
+ * Calculates the highest product of three numbers.
+ * @param {Number[]} arrayOfInts An array of integers with a minimum length of 3.
+ * @return {Number} The highest product of three numbers.
+ */
+function highestProductOf3(arrayOfInts) {
+  // Throw error if given array has fewer than 3 integers.
+  if (arrayOfInts.length < 3)
+    throw new Error("Minimum of three integers needed.");
+
+  // Track the greatest 3 positive values in descending order
+  const highestPositives = [-Infinity, -Infinity, -Infinity];
+  // Track the 2 lowest values in ascending order (for negative-to-positive product)
+  const lowestNegatives = [Infinity, Infinity];
+
+  // Sweep through all given integers once.
+  for (let i = 0; i < arrayOfInts.length; i++) {
+    const currentInt = arrayOfInts[i];
+
+    // Check if current integer is one of the greatest 3 values seen thus far
+    // Swap as needed (cascading swaps may occur).
+    let temp = currentInt;
+    let temp2 = temp;
+
+    // Largest value
+    if (temp > highestPositives[0]) {
+      temp2 = highestPositives[0];
+      highestPositives[0] = temp;
+      temp = temp2;
+    }
+    // 2nd Largest Value
+    if (temp > highestPositives[1]) {
+      temp2 = highestPositives[1];
+      highestPositives[1] = temp;
+      temp = temp2;
+    }
+    // 3rd Largest Value
+    if (temp > highestPositives[2]) {
+      temp2 = highestPositives[2];
+      highestPositives[2] = temp;
+      temp = temp2;
+    }
+
+    // Check if current integer is one of the least 2 negative values seen thus far
+    // Swap as needed (cascading swaps may occur).
+    if (currentInt < 0) {
+      temp = currentInt;
+      temp2 = temp;
+      // Least Negative Value
+      if (temp < lowestNegatives[0]) {
+        temp2 = lowestNegatives[0];
+        lowestNegatives[0] = temp;
+        temp = temp2;
+      }
+      // 2nd Least Negative Value
+      if (temp < lowestNegatives[1]) {
+        temp2 = lowestNegatives[1];
+        lowestNegatives[1] = temp;
+        temp = temp2;
+      }
+    }
+  }
+  // Calculate the product of the greatest 3 positive values,
+  const highest3 =
+    highestPositives[0] * highestPositives[1] * highestPositives[2];
+
+  // If at least two negative values were found
+  if (lowestNegatives[0] !== Infinity && lowestNegatives[1] !== Infinity) {
+    // Calculate the product of the greatest positive value with the 2 lowest negative values,
+    // (Negative multiplied by a negative gives a positive)
+    const highestWithLowest2 =
+      highestPositives[0] * lowestNegatives[0] * lowestNegatives[1];
+    // Return the greater result.
+    return Math.max(highest3, highestWithLowest2);
+  }
+
+  return highest3;
+}
+
+export default highestProductOf3;

3-Highest-Product-of-Three/highestProductOf3.test.js

@@ -0,0 +1,35 @@
+import highestProductOf3 from "./highestProductOf3";
+
+describe(`highestProductOf3()`, () => {
+  it(`finds highest product given a short array`, () => {
+    expect(highestProductOf3([1, 2, 3, 4])).toBe(24);
+  });
+
+  it(`finds highest product given a longer array`, () => {
+    expect(highestProductOf3([6, 1, 3, 5, 7, 8, 2])).toBe(336);
+  });
+
+  it(`finds highest product given a array has one negative`, () => {
+    expect(highestProductOf3([-5, 4, 8, 2, 3])).toBe(96);
+  });
+
+  it(`finds highest product given a array has two negatives`, () => {
+    expect(highestProductOf3([-10, 1, 3, 2, -10])).toBe(300);
+  });
+
+  it(`finds highest product given a array is all negatives`, () => {
+    expect(highestProductOf3([-5, -1, -3, -2])).toBe(-6);
+  });
+
+  it(`Throws an error given an empty array`, () => {
+    expect(() => highestProductOf3([])).toThrow();
+  });
+
+  it(`Throws an error given an array with one number`, () => {
+    expect(() => highestProductOf3([1])).toThrow();
+  });
+
+  it(`Throws an error given an array with two numbers`, () => {
+    expect(() => highestProductOf3([1, 1])).toThrow();
+  });
+});

README.md

@@ -42,6 +42,8 @@ The following problems are introduced in the [Interview Cake full course](https:
 
 - [1. Apple Stocks](./1-Apple-Stocks/README.md)
 
+- [3. Highest Product of Three](./3-Highest-Product-of-Three/README.md)
+
 - [4. Merging Meeting Times](./4-Merging-Meeting-Times/README.md)
 
 - [8. Balanced Binary Tree](./8-Balanced-Binary-Tree/README.md)