first commit

Author: rupeshtiwari

index.html

@@ -0,0 +1 @@
+<div id="app"></div>

index.js

@@ -0,0 +1,12 @@
+// Import stylesheets
+import './style.css';
+
+// import './src/recursive-binary-search';
+import './src/find-max-sliding-window';
+
+
+// Write Javascript code!
+const appDiv = document.getElementById('app');
+appDiv.innerHTML = `<h1>Interview Coding Practice</h1>`;
+
+

package.json

@@ -0,0 +1,6 @@
+{
+  "name": "js",
+  "version": "0.0.0",
+  "private": true,
+  "dependencies": {}
+}

src/binary-search.js

@@ -0,0 +1,127 @@
+/**
+ * Given a sorted array of integers,
+ * return the index of the given key. R
+ * eturn -1 if the key is not found.
+ */
+
+// Problem Solving
+/**
+ * binary search
+ *
+ * Algo
+ * Divide and concur (technique)
+ *
+ * 1 2 3 4 5
+ * 2
+ *
+ * iterative easy to implement
+ * O(log n) Runtime complexity
+ * O(1) Memory complexity
+ *
+ * recursive easy to implement
+ * O(log n) Runtime complexity
+ * O(log n) Memory complexity
+ *
+ *
+ */
+
+/* Approach 2: Recursive Search 
+ Runtime Complexity: O(log n)
+ Memory Complexity: O(log n)
+*/
+export function recursiveBinarySearch(arr, key, low, high) {
+  let result = -1;
+  // let low = 0;
+  //let high = arr.length - 1;
+  let mid;
+
+  mid = low + Math.round(high - low);
+  if (arr[mid] === key) {
+    result = mid;
+
+    return result;
+  }
+  if (arr[mid] < key) {
+    low = mid + 1;
+  } else {
+    high = mid - 1;
+  }
+
+  if (low <= high) {
+    result = recursiveBinarySearch(arr, key, low, high);
+  }
+
+  return result;
+}
+
+// test
+console.warn('recursiveBinarySearch');
+log(recursiveBinarySearch([1, 2, 3], 3, 0, 2), 2);
+log(recursiveBinarySearch([4, 5, 6, 7, 8, 9, 10, 11], 9, 0, 7), 5);
+log(
+  recursiveBinarySearch([-10, -9, -8, -7, -6, -5, -4, 5, 6, 7, 8], -6, 0, 10),
+  4
+);
+log(recursiveBinarySearch([10, 20, 30, 35, 40, 50], 30, 0, 5), 2);
+log(recursiveBinarySearch([10, 20, 20, 20, 40, 50], 40, 0, 5), 4);
+
+
+let arr = [1, 10, 20, 47, 59, 63, 75, 88, 99, 107, 120, 133, 155, 162, 176, 188, 199, 200, 210, 222]
+let inputs = [[10,1], [49, -1], [99,8],[110,-1], [176,14]]
+
+for(var i =0; i< inputs.length ; i++ ) {
+  log(recursiveBinarySearch(arr, inputs[i][0], 0, arr.length-1), inputs[i][1]);
+}
+
+
+
+
+/* Approach 1: Iterative Search 
+ Runtime Complexity: O(log n)
+ Memory Complexity: O(1)
+*/
+export function iterativeBinarySearch(arr, key) {
+  let result = -1;
+  let low = 0;
+  let high = arr.length - 1;
+  let mid;
+
+  // find the mid
+  while (low <= high) {
+    mid = low + Math.round(high - low);
+    if (arr[mid] === key) {
+      result = mid;
+
+      return result;
+    }
+    if (arr[mid] < key) {
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  return result;
+}
+
+function log(result, expected) {
+  console.log('========');
+  if (result === expected) {
+    console.info('%c PASS','color:black;background-color:lawngreen');
+  } else {
+    console.info('%c FAIL','color:white;background-color:red');
+  }
+
+  console.log(`result: ${result}, expected: ${expected}`);
+}
+
+// test
+console.warn('iterativeBinarySearch');
+log(iterativeBinarySearch([1, 2, 3], 3), 2);
+log(iterativeBinarySearch([4, 5, 6, 7, 8, 9, 10, 11], 9), 5);
+log(iterativeBinarySearch([-10, -9, -8, -7, -6, -5, -4, 5, 6, 7, 8], -6), 4);
+log(iterativeBinarySearch([10, 20, 30, 35, 40, 50], 30), 2);
+log(iterativeBinarySearch([10, 20, 20, 20, 40, 50], 40), 4);
+for(var i =0; i< inputs.length ; i++ ) {
+  log(iterativeBinarySearch(arr, inputs[i][0]), inputs[i][1]);
+}

src/find-max-sliding-window.js

@@ -0,0 +1,93 @@
+/**
+ *
+ *  [-4, 2, 5, 3, 6, 9, 7, 8] window size = 3
+ *
+ *  approach -1,
+ *  take window size array
+ *  search max ( linear o(w))
+ *  repeat above 2 till n times
+ *  Runtime complexity O(n*w));
+ *  Memory complexity  O(n*w);
+ *
+ */
+
+
+function trace(msg) {
+  console.log(`%c ${msg}`, 'background-color:yellow;color:red');
+}
+function findMaxSlidingWindow(arr, window_size) {
+  const result = [];
+
+  function findMax(givenArr) {
+    trace('givenArr: [' + givenArr.join(',') + ']');
+    let max = givenArr[0];
+    for (var j = 0; j < givenArr.length; j++) {
+      max = Math.max(givenArr[j], max);
+    }
+
+    return max;
+  }
+  const size = arr.length - window_size;
+  for (var i = 0; i <= size; i++) {
+    const searchArr = arr.slice(i,i+ window_size);
+    result.push(findMax(searchArr));
+  }
+
+  return result;
+}
+// test
+log(findMaxSlidingWindow([-4, 2, 5, 3, 6, 9, 7, 8], 3));
+log(findMaxSlidingWindow([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3))
+log(findMaxSlidingWindow([10, 6, 9, -3, 23, -1, 34, 56, 67, -1, -4, -8, -2, 9, 10, 34, 67]  ,3))
+function log(msg) {
+  console.log('%c ========', 'color:black;background-color:lawngreen');
+
+  console.log(`%c [${msg}]`, 'color:blue');
+}
+
+const arr = [-4, 2, 5, 3, 6, 9, 7, 8];
+const winSizes = [3, 2, 4, 5];
+for (var i = 0; i < winSizes.length; i++) {
+  log(
+    'findMaxSlidingWindow(arr,' +
+      winSizes[i] +
+      ')' +
+      findMaxSlidingWindow(arr, winSizes[i])
+  );
+}
+
+
+
+/* *  approach -2,
+ *  take window size array
+ *  search max ( sort and search o(log n))
+ *  repeat above 2 till n times
+ *  Runtime complexity O(n log w);
+ *  Memory complexity  O(n log w);
+ *
+ */
+
+
+function findMaxSlidingWindow2(arr, window_size) {
+  const result = [];
+
+  function findMax(givenArr) {
+    trace('givenArr: [' + givenArr.join(',') + ']');
+    givenArr.sort((a,b)=>a-b);
+    return givenArr[givenArr.length-1];
+  }
+  const size = arr.length - window_size;
+  for (var i = 0; i <= size; i++) {
+    const searchArr = arr.slice(i,i+ window_size);
+    result.push(findMax(searchArr));
+  }
+
+  return result;
+}
+
+//test
+
+trace('findMaxSlidingWindow2')
+log(findMaxSlidingWindow2([-4, 2, 5, 3, 6, 9, 7, 8], 3));
+log(findMaxSlidingWindow2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],3))
+log(findMaxSlidingWindow2([10, 6, 9, -3, 23, -1, 34, 56, 67, -1, -4, -8, -2, 9, 10, 34, 67]  ,3))

style.css

@@ -0,0 +1,3 @@
+h1, h2 {
+  font-family: Lato;
+}

tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "target": "esnext"
+  }
+}