binary search in js

Author: sohail0992

hackerRank/smallest-absolute-difference/smallest-absolute-difference.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const fs = require('fs');
+
+process.stdin.resume();
+process.stdin.setEncoding('utf-8');
+
+let inputString = '';
+let currentLine = 0;
+
+process.stdin.on('data', inputStdin => {
+    inputString += inputStdin;
+});
+
+process.stdin.on('end', function() {
+    inputString = inputString.replace(/\s*$/, '')
+        .split('\n')
+        .map(str => str.replace(/\s*$/, ''));
+
+    main();
+});
+
+function readLine() {
+    return inputString[currentLine++];
+}
+
+// Complete the minimumAbsoluteDifference function below.
+function minimumAbsoluteDifference(arr) {
+  let pointer = 0;
+  let smallestDifference = Math.abs(arr[pointer] - arr[1]);
+  while (arr.length > pointer) {
+    for (let i = pointer; i < arr.length-1; i++) {
+        const difference = Math.abs(arr[pointer] - arr[i + 1]);
+        if (smallestDifference > difference) {
+          smallestDifference = difference;
+      }
+    }
+    pointer++;
+  }
+  return smallestDifference;
+}
+
+function main() {
+    const ws = fs.createWriteStream(process.env.OUTPUT_PATH);
+
+    const n = parseInt(readLine(), 10);
+
+    const arr = readLine().split(' ').map(arrTemp => parseInt(arrTemp, 10));
+
+    const result = minimumAbsoluteDifference(arr);
+
+    ws.write(result + '\n');
+
+    ws.end();
+}

momcenteral/addup/addup.js

@@ -0,0 +1,44 @@
+
+
+function getMax(x, y) {
+  if (x > y) {
+    return x;
+  } else {
+    return y;
+  }
+}
+
+function argmap(arr1, arr2) {
+  var arrToReturn = []
+  var i = 0
+  var reset = 0
+  var arr1Length = arr1.length
+  var arr2Length = arr2.length
+  // loop will run till the length of array of greater size
+  while (i < getMax(arr1Length, arr2Length)) {
+      // verify if i is less than length - 1 for both
+      // if yes add the sum of values on the index from both array
+      // if no add the index from the array which has that index
+      if (i < arr1Length && i < arr2Length) {
+         arrToReturn.push(arr1[i] + arr2[i])
+      } else if (i < arr1Length) {
+        if (reset >= arr2Length) {
+          reset = 0
+        }
+        arrToReturn.push(arr1[i] + arr2[reset])
+        reset = reset + 1
+      } else {
+        if (reset >= arr1Length) {
+          reset = 0
+        }
+        arrToReturn.push(arr1[reset] + arr2[i])
+        reset = reset + 1
+      }
+      i = i + 1
+  }
+  // printArray(arrToReturn)
+  return arrToReturn
+}
+
+
+module.exports = argmap;

momcenteral/addup/test.js

@@ -0,0 +1,59 @@
+var argmap = require('./addup');
+var assert = require('assert');
+
+//add object to add custom tests
+let testSamples = [
+  {
+    arr1: [3, 2],
+    arr2: [4, 3, 2, 9, 10, 12],
+    output: [7, 5, 5, 11, 13, 14]
+  },
+  {
+    arr1: [1,2],
+    arr2: [1,2,3,4],
+    output: [2, 4, 4, 6]
+  },
+  {
+    arr1: [1,2,3,4],
+    arr2: [5,6,7, 8],
+    output: [6,8,10,12]
+  },
+  {
+    arr1: [4, 3, 2, 1],
+    arr2: [2, 1],
+    output: [6, 4, 4, 2]
+  },
+  {
+    arr1: [4, 3, 2, 9],
+    arr2: [2, 1],
+    output: [6, 4, 4, 10]
+  },
+  {
+    arr1: [4, 3, 2, 9, 10, 12],
+    arr2: [2, 1],
+    output: [6, 4, 4, 10, 12, 13]
+  },
+  {
+    arr1: [4, 3, 2, 9, 10, 12, 8, -1],
+    arr2: [2, 1],
+    output: [6, 4, 4, 10, 12, 13, 10, 0]
+  },
+  {
+    arr1: [4, 3],
+    arr2: [2, 1],
+    output: [6, 4]
+  }
+
+];
+
+//don't modify this
+testSamples.forEach((eachSample,index) => {
+  let output = argmap(eachSample.arr1,eachSample.arr2);
+  console.log(output, 'output: ')
+  describe('Function output should be equal to test sample output', function() {
+    it('Test # ' + index, function() {
+      assert.deepStrictEqual(output,eachSample.output);
+    });
+  });
+});
+

momcenteral/depthLeaves/depthLeaves.js

@@ -0,0 +1,77 @@
+var maxDepth = function(arr) {
+  if (arr == false || !arr) {
+      return 0
+  }
+  if (arr[1] == false && arr[2] == false) {
+      return 1
+  } else {
+      var l = maxDepth(arr[1])
+      var r = maxDepth(arr[2])
+      if (l > r) {
+          return 1 + l
+      } else {
+          return 1 + r
+      }
+  }
+}
+
+
+var getLeafCountsAtDepth = function(arr, depth, count, n) {
+  console.log("getLeafCountsAtDepth", n)
+  count = count + 1
+  n =  n
+  if (arr == false || !arr) {
+      return n
+  }
+  if (arr[1] == false && arr[2] == false) {
+      console.log(count, 'c', depth, 'd')
+      if (count == depth) {
+          n = n + 1
+          console.log(n, 'iiii')
+      }
+      return n
+  } else {
+      getLeafCountsAtDepth(arr[1], depth, count, n)
+      getLeafCountsAtDepth(arr[2], depth, count, n)
+      return n
+  }
+}
+let leafNodes = [];
+let treeDepth = 0;
+
+let leafCount = (arr, branch) => {
+	if (!arr || (arr.length && arr.length === 0)) {
+		return;
+	}
+	if (arr[1] === false && arr[2] === false) {
+		console.log('pushing', branch);
+		leafNodes.push(branch);
+		if (treeDepth < branch) {
+			treeDepth = branch;
+		}
+		return;
+	} else {
+		branch = branch + 1;
+		leafCount(arr[1], branch);
+		leafCount(arr[2], branch);
+	} 
+}
+
+const run = (tree1) => {
+	leafCount(tree1, 1);
+	console.log(leafNodes, treeDepth)
+	totalLeaves = 0;
+	leafNodes.forEach(x => {
+		if (x === treeDepth) {
+			totalLeaves ++;
+		}
+	});
+	console.log('totalLeaves', totalLeaves);
+  return totalLeaves
+}
+
+module.exports = {
+  maxDepth: maxDepth,
+  getLeafCountsAtDepth: getLeafCountsAtDepth,
+  run: run
+};

momcenteral/depthLeaves/test.js

@@ -0,0 +1,44 @@
+var func = require('./depthLeaves');
+var assert = require('assert');
+// console.log(output.maxDepth, 'maxDepth')
+//add object to add custom tests
+
+//   2
+// /   \
+// 5     9
+// \
+// 7
+let testSamples = [
+  {
+    arr1: [2, [5, false, [7, false, false]], [9, false, false]],
+    output: 1
+  },
+  {
+    arr1: [2, [5,[6, false, false], [7, [1, false, false], false]], [8,[9, false, false], [12, [0, false, false]]]],
+    output: 2
+  }
+];
+
+//                  2
+     //          /   \
+     //         5      8
+     //        / \    / \
+     //       6   7  9   12
+     //          /       \
+     //         1         0
+
+
+//don't modify this
+testSamples.forEach((eachSample, index) => {
+  let depth = func.maxDepth(eachSample.arr1);
+  console.log(depth, 'd');
+  // let output = func.getLeafCountsAtDepth(eachSample.arr1, depth, 0, 0);
+  // // output = func.run(eachSample.arr1);
+
+  // describe('Function output should be equal to test sample output', function () {
+  //   it('Test # ' + index, function () {
+  //     assert.deepStrictEqual(output, eachSample.output);
+  //   });
+  // });
+});
+