Merge branch 'master' of https://github.com/sohail0992/js-algorithms

Author: sohail0992

interview/fibonacci-sum/Readme.md

@@ -0,0 +1,17 @@
+Write a program that
+prints 1 2 3 4 5 6 7 ... up to some +ve integer N
+the natural number series, but
+with all numbers that also show up in the fibonacci series replaced with -1
+so a refresher on fibonacci if you need it:
+the fibonacci series starts with the numbers 0 and 1
+and then you can generate all subsequent numbers by summing the previous 2 numbers in the series
+so the series goes 0 1 1 2 3 5 8 13 21 .. etc
+so in your program, it should print the natural number series, but any number that also occurs in the fibonacci series needs to be replaced with -1
+the output should look like -1 -1 -1 4 -1 6 7 -1 9 10 ... etc
+
+## Example
+
+```
+Given N = 7, arr will be [1,2,3,4,5,6,7] and output  [-1, -1, -1, 4, -1, 6, 7]
+```
+

interview/fibonacci-sum/fibnocci-sum-3.js

@@ -0,0 +1,20 @@
+var fibnnacciSumSeries = function(limit) {
+    const list = [];
+    const fibSequence = { 1: true };
+    let left = 1, right = 1;
+    for (let i = 1; i <= limit; i++) {
+      if (fibSequence[i]) {
+        list.push(-1);
+      } else {
+        list.push(i);
+      }
+      const temp = left;
+      left = right;
+      right = temp + right;
+      fibSequence[right] = true;
+    }
+    return list;
+}
+  
+module.exports = fibnnacciSumSeries;
+  

interview/fibonacci-sum/fibonacci-sum.js

@@ -0,0 +1,19 @@
+var fibnnacciSumSeries = function(N) {
+  const toReturn = [];
+  let prevInt = 0, currentInt = 1, nextTerm;
+  for (let i = 1; i <= N; i++) {
+    toReturn.push(i);
+  }
+  for (let i = 1; i <= N; i++) {
+    nextTerm = prevInt + currentInt;
+    prevInt = currentInt;
+    currentInt = nextTerm;
+    const indexOfFibnaciNumber = toReturn.findIndex(each => each === nextTerm);
+    if (indexOfFibnaciNumber > -1) {
+      toReturn[indexOfFibnaciNumber] = -1;
+    }
+  }
+  return toReturn;
+};
+
+module.exports = fibnnacciSumSeries;

interview/fibonacci-sum/fibonaccis-sum-2.js

@@ -0,0 +1,25 @@
+function isPerfectSquare(x)
+{
+  let s = parseInt(Math.sqrt(x));
+  return (s * s == x);
+}
+ 
+// Returns true if n is a Fibinacci Number, else false
+function isFibonacci(n)
+{
+    // n is Fibinacci if one of 5*n*n + 4 or 5*n*n - 4 or both
+    // is a perferct square
+    return isPerfectSquare(5*n*n + 4) ||
+           isPerfectSquare(5*n*n - 4);
+}
+
+
+var fibnnacciSumSeries = function(N) {
+  const toReturn = [];
+  for (let i = 1; i <= N; i++) {
+    toReturn.push(isFibonacci(i) ? -1 : i);
+  }
+  return toReturn;
+};
+
+module.exports = fibnnacciSumSeries;

interview/fibonacci-sum/test.js

@@ -0,0 +1,30 @@
+var fibnnacciSumSeries = require('./fibnocci-sum-3');
+var expect = require('chai').expect;
+var assert = require('assert');
+
+//add object to add custom tests
+let testSamples = [
+  // {
+  //   N: 4,
+  //   output: [0, 1, 1, 2]
+  // },
+  {
+    N: 7,
+    output: [-1, -1, -1, 4, -1, 6, 7]
+  },
+  {
+    N: 5,
+    output: [-1, -1, -1, 4, -1]
+  }
+];
+
+//don't modify this
+testSamples.forEach((eachSample,index) => {
+  let output = fibnnacciSumSeries(eachSample.N);
+  describe('Function output should be equal to test sample output', function() {
+    it('Test # ' + index, function() {
+      assert.deepEqual(output,eachSample.output);
+    });
+  });
+});
+

searchAlgrothems/binarySearch/index.js

@@ -0,0 +1,24 @@
+
+var binarySearch = function(arr, valueToSearch, lowerIndex, upperIndex) {
+    if (lowerIndex > upperIndex) {
+        return -1;
+    }
+    const mid = parseInt((upperIndex + lowerIndex)/2);
+    if (valueToSearch === arr[mid]) {
+        console.log('found at ' + mid);
+        return mid;
+    }
+    if (valueToSearch > arr[mid]) {
+        lowerIndex = mid + 1;
+        return binarySearch(arr, valueToSearch,  lowerIndex, upperIndex);
+    } else {
+        upperIndex = mid - 1;
+        return binarySearch(arr, valueToSearch,  lowerIndex, upperIndex);
+    }
+  
+}
+
+const arr = [6, 8, 19, 20, 23, 41, 49, 53, 56];
+let indexOfValue = binarySearch(arr, 6, 0, arr.length - 1);
+console.log(indexOfValue, 'index of value');
+module.exports = binarySearch;

searchAlgrothems/quickSort/index.js

@@ -0,0 +1,45 @@
+// O (n 2) worst case
+
+function partition(arr, first, last) {
+    const pivot = first;
+    let lowerIndex = first + 1;
+    let upperIndex = last;
+     // call first element as pivot
+    // loop till the higher and lower indices cross each other
+    while (upperIndex >= lowerIndex) {
+        if (arr[pivot] > arr[lowerIndex]) {
+            lowerIndex++;
+        } else if (arr[upperIndex] > arr[pivot]) {
+            upperIndex--;
+        } else if (arr[pivot] > arr[upperIndex] && arr[lowerIndex] > arr[upperIndex]) {
+            // now lower index value is greater than pivot so we stop incrementing the lowerindex
+            // we will decrement the upperIndex until we find a value that is less than pivot and lowerindex value we will switch array indices positions
+            const temp = arr[upperIndex];
+            arr[upperIndex] = arr[lowerIndex];
+            arr[lowerIndex] = temp;
+            upperIndex--;
+            lowerIndex++;
+        }
+    }
+    // swap pivot with uper
+    const temp = arr[upperIndex];
+    arr[upperIndex] = arr[pivot];
+    arr[pivot] = temp;
+    return upperIndex;
+}
+
+function quickSort(arr, first, last) {
+    if (first < last) {
+        const pivot = partition(arr, first, last);
+        quickSort(arr, first, pivot - 1);
+        quickSort(arr, pivot + 1, last);
+    }
+}
+
+
+const arr = [20, 6, 8, 53, 23, 87, 42, 19];
+console.log(arr, 'orignal');
+quickSort(arr, 0, (arr.length - 1));
+console.log(arr, 'sorted');
+
+module.exports = quickSort;