adding tandem bicycle and changed flight travels

Author: Jero786

README.md

@@ -103,6 +103,7 @@
 1. [Word Search](/word-search/index.test.js)
 1. [Product Array Except Self](/product-array-except-self/index.test.js)
 1. [Best time to Buy and Sell](/best-time-to-buy-and-sell/index.test.js)
+1. [Tandem Bicycle](/tandem-bicycle/index.test.js)
 
 ## Setup
 

flight-travels/index.js

@@ -7,23 +7,27 @@
  * @returns {number[]}
  */
 const getTwoFlightIndex = (flights = [], maxDistanceFlyAllowed) => {
-  
-  if ((flights.length < 2) || maxDistanceFlyAllowed < 1) {
-    throw Error('Given flags could not be less than two flights, and maxDistanceAllowed should be higher than zero');
+  if (flights.length < 2 || maxDistanceFlyAllowed < 1) {
+    throw Error(
+      'Given flags could not be less than two flights, and maxDistanceAllowed should be higher than zero'
+    );
   }
 
   let indexA = 0;
   let indexB = 1;
   let maxDistancePossible = Number.MIN_VALUE; // to be sure to be override first time
-  
+
   // O(n 2) time complexity
   // O(1) space time
   for (let i = 0; i < flights.length - 1; i++) {
-    for(let j = i + 1; j < flights.length; j++) {
+    for (let j = i + 1; j < flights.length; j++) {
       const currentFlySum = flights[i] + flights[j];
       if (currentFlySum === maxDistanceFlyAllowed) {
         return [i, j];
-      } else if (currentFlySum < maxDistanceFlyAllowed && currentFlySum > maxDistancePossible) {
+      } else if (
+        currentFlySum < maxDistanceFlyAllowed &&
+        currentFlySum > maxDistancePossible
+      ) {
         indexA = i;
         indexB = j;
         maxDistancePossible = currentFlySum;
@@ -33,6 +37,37 @@ const getTwoFlightIndex = (flights = [], maxDistanceFlyAllowed) => {
   return [indexA, indexB];
 };
 
+const getTwoFlightIndexPerformance = (flights = [], maxDistanceFlyAllowed) => {
+  flights.sort((a, b) => a - b); // O(n log n)
+  // CONTINUE..........
+  let leftIndex = 0;
+  let rightIndex = flights.length - 1;
+  let minValue = Math.MAX_VALUE;
+  let maxValue = Math.MIN_VALUE;
+
+  while (leftIndex < rightIndex) {
+    const currentSum = flights[leftIndex] + flights[rightIndex];
+    if (currentSum === maxDistanceFlyAllowed) {
+      return [leftIndex, rightIndex];
+    } else if (currentSum > maxDistanceFlyAllowed) {
+      rightIndex--;
+      if (flights[leftIndex] < minValue) {
+        minValue = flights[leftIndex];
+        minValueIndex = leftIndex;
+      }
+    } else {
+      leftIndex++;
+
+      if (flights[rightIndex] > maxValue) {
+        maxValue = flights[rightIndex]
+      }
+    }
+  }
+
+  return [leftIndex, rightIndex];
+};
+
 module.exports = {
-  getTwoFlightIndex
+  getTwoFlightIndex,
+  getTwoFlightIndexPerformance
 };

flight-travels/index.test.js

@@ -1,13 +1,30 @@
-const {getTwoFlightIndex} = require('.');
+const { getTwoFlightIndex, getTwoFlightIndexPerformance } = require('.');
 
 test('Flow travels should return the longest flight possibles', () => {
   // Arrange
   const flights = [10, 20, 5, 1, 40];
   const maxAirplaneDistance = 16;
-  
+
   // Act
   const flightsResults = getTwoFlightIndex(flights, maxAirplaneDistance);
-  
+
+  // Assert
+  expect(flightsResults.length).toEqual(2);
+  expect(flightsResults[0]).toEqual(0);
+  expect(flightsResults[1]).toEqual(2);
+});
+
+test('Flow travels should return the longest flight possibles', () => {
+  // Arrange
+  const flights = [10, 20, 5, 1, 40];
+  const maxAirplaneDistance = 16;
+
+  // Act
+  const flightsResults = getTwoFlightIndexPerformance(
+    flights,
+    maxAirplaneDistance
+  );
+
   // Assert
   expect(flightsResults.length).toEqual(2);
   expect(flightsResults[0]).toEqual(0);
@@ -18,26 +35,30 @@ test('Flight travels should not be less than 2 flight', () => {
   // Arrange
   const flights = [];
   const maxAirplaneDistance = 16;
-  
+
   // Act
   function shouldThrowError() {
     getTwoFlightIndex(flights, maxAirplaneDistance);
   }
-  
+
   // Assert
-  expect(shouldThrowError.bind(null, flights, maxAirplaneDistance)).toThrowError(/Given flags could not be less than two flights/i)
+  expect(
+    shouldThrowError.bind(null, flights, maxAirplaneDistance)
+  ).toThrowError(/Given flags could not be less than two flights/i);
 });
 
 test('Flight travels should not be less distance than 1', () => {
   // Arrange
   const flights = [10, 20, 30, 40];
   const maxAirplaneDistance = 0;
-  
+
   // Act
   function shouldThrowError() {
     getTwoFlightIndex(flights, maxAirplaneDistance);
   }
-  
+
   // Assert
-  expect(shouldThrowError.bind(null, flights, maxAirplaneDistance)).toThrowError(/Given flags could not be less than two flights/i)
-});
+  expect(
+    shouldThrowError.bind(null, flights, maxAirplaneDistance)
+  ).toThrowError(/Given flags could not be less than two flights/i);
+});

tandem-bicycle/index.js

@@ -0,0 +1,73 @@
+/**
+ * 
+  A tandem bicycle is a bicycle that's operated by two people: person A and
+  person B. Both people pedal the bicycle, but the person that pedals faster
+  dictates the speed of the bicycle. So if person A pedals at a speed of
+  5, and person B pedals at a speed of 4, the tandem
+  bicycle moves at a speed of 5 (i.e.,
+  tandemSpeed = max(speedA, speedB)).
+
+
+  You're given two lists of positive integers: one that contains the speeds of
+  riders wearing red shirts and one that contains the speeds of riders wearing
+  blue shirts. Each rider is represented by a single positive integer, which is
+  the speed that they pedal a tandem bicycle at. Both lists have the same
+  length, meaning that there are as many red-shirt riders as there are
+  blue-shirt riders. Your goal is to pair every rider wearing a red shirt with a
+  rider wearing a blue shirt to operate a tandem bicycle.
+
+
+  Write a function that returns the maximum possible total speed or the minimum
+  possible total speed of all of the tandem bicycles being ridden based on an
+  input parameter, fastest. If fastest = true, your
+  function should return the maximum possible total speed; otherwise it should
+  return the minimum total speed.
+
+
+  "Total speed" is defined as the sum of the speeds of all the tandem bicycles
+  being ridden. For example, if there are 4 riders (2 red-shirt riders and 2
+  blue-shirt riders) who have speeds of 1, 3, 4, 5, and if they're
+  paired on tandem bicycles as follows: [1, 4], [5, 3], then the
+  total speed of these tandem bicycles is 4 + 5 = 9.
+
+Sample Input
+redShirtSpeeds = [5, 5, 3, 9, 2]
+blueShirtSpeeds = [3, 6, 7, 2, 1] 
+fastest = true
+
+Sample Output
+32
+
+} listOne 
+ * @param {*} listTwo 
+ * @param {*} fastest 
+ * @returns 
+ */
+function makeTandemBicycle(listOne, listTwo, fastest) {
+
+    if (fastest) {
+        listOne.sort((a, b) => 
+        a < b
+        ? 1
+        : a === b
+        ? 0
+        : -1
+    );
+    } else {
+       listOne.sort((a, b) => a - b);
+    }
+    
+    listTwo.sort((a, b) => a - b);
+
+    let sum = 0;
+
+    for (let i = 0; i < listOne.length; i++) {
+        sum += Math.max(listOne[i], listTwo[i]);
+    }
+
+    return sum;
+}
+
+module.exports = {
+    makeTandemBicycle
+}

tandem-bicycle/index.test.js

@@ -0,0 +1,23 @@
+const { makeTandemBicycle } = require('.');
+
+describe('tandem bicycle', () => {
+    it('should return fastest', () => {
+        const redShirtSpeeds = [5, 5, 3, 9, 2];
+        const blueShirtSpeeds = [3, 6, 7, 2, 1];
+        const isFastest = true;
+
+        const result = makeTandemBicycle(redShirtSpeeds, blueShirtSpeeds, isFastest);
+
+        expect(result).toEqual(32);
+    });
+
+     it('should return slowest', () => {
+        const redShirtSpeeds = [5, 5, 3, 9, 2];
+        const blueShirtSpeeds = [3, 6, 7, 2, 1];
+        const isFastest = false;
+
+        const result = makeTandemBicycle(redShirtSpeeds, blueShirtSpeeds, isFastest);
+
+        expect(result).toEqual(25);
+    });
+});