Merge branch 'master' into hackoct_24

Author: ignacio-chiazzo

Diff for: .eslintrc.json

@@ -10,6 +10,7 @@
         "sourceType": "module"
     },
     "rules": {
+        "camelcase": "error",
         "indent": [
             "error",
             2

Diff for: DesignDataStructure/designI.js

@@ -21,6 +21,8 @@ The data structure should be efficient enough to accommodate the operations acco
     Frequency: Least frequent. 
 */
 
+/*
+example:
 
 class effStructure {
   this.maxHeap = [];
@@ -33,4 +35,5 @@ class effStructure {
 3) deleteMin(): O(log N)
 4) deleteMax(): O(log N)
 5) Insert(log N)
-6) Delete: O(log N)
+6) Delete: O(log N)
+*/

Diff for: LeetcodeProblemsTests/Algorithms/medium/3Sum_Closest_Test.js renamed to LeetcodeProblemsTests/Algorithms/medium/3SumClosest_Test.js

@@ -25,22 +25,22 @@ Output: 0
 var maximalSquare = function(matrix) {
   var m = matrix.length;
   var n = (matrix[0] || []).length;
-  var dp = Array(m).fill(0).map(_ => Array(n));
+  var dp = Array(m).fill(0).map(() => Array(n));
   var max = 0;
 
   for (var k = 0; k < m; k++) {
-    dp[k][0] = matrix[k][0] === '1' ? 1 : 0;
+    dp[k][0] = matrix[k][0] === "1" ? 1 : 0;
     max = Math.max(max, dp[k][0]);
   }
 
   for (var p = 0; p < n; p++) {
-    dp[0][p] = matrix[0][p] === '1' ? 1 : 0;
+    dp[0][p] = matrix[0][p] === "1" ? 1 : 0;
     max = Math.max(max, dp[0][p]);
   }
 
   for (var i = 1; i < m; i++) {
     for (var j = 1; j < n; j++) {
-      if (matrix[i][j] === '1') {
+      if (matrix[i][j] === "1") {
         dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1;
         max = Math.max(max, dp[i][j]);
       } else {
@@ -52,3 +52,5 @@ var maximalSquare = function(matrix) {
   return max * max;
 
 };
+
+module.exports.maximalSquare = maximalSquare;

Diff for: LeetcodeProblemsTests/Algorithms/medium/Maximise_Hour_Glass_Sum.js renamed to LeetcodeProblemsTests/Algorithms/medium/Maximise_Hour_Glass_Sum_Test.js

@@ -1,13 +1,13 @@
-const assert = require('assert');
-const {Maximalsquare } = require('../LeetcodeProblems/Maximal_square');
+const assert = require("assert");
+const {Maximalsquare } = require("../LeetcodeProblems/Maximal_square");
 
 function test1() {
   var matrix = [
     [1, 0, 1, 0, 0],
     [1, 0, 1, 1, 1],
-    [1, 1, 1, 1 1],
+    [1, 1, 1, 1, 1],
     [1, 0, 0, 1, 0],
-  ]
+  ];
 
   assert.strictEqual(Maximalsquare(matrix), 4);
 }
@@ -16,16 +16,17 @@ function test2() {
   var matrix = [
     [0, 1],
     [1,0]
-  ]
+  ];
 
   assert.strictEqual(Maximalsquare(matrix), 1);
 }
 
 function test3(){
   var matrix = [
     [0]
-    ]
-   assert.strictEqual(Maximalsquare(matrix), 0);
+  ];
+
+  assert.strictEqual(Maximalsquare(matrix), 0);
 }
 
 function test() {
@@ -34,4 +35,4 @@ function test() {
   test3();
 }
 
-module.exports.test = test
+module.exports.test = test;

Diff for: Maximal_square.js

@@ -1,39 +1,40 @@
 function swap(items, leftIndex, rightIndex){
-    var temp = items[leftIndex];
-    items[leftIndex] = items[rightIndex];
-    items[rightIndex] = temp;
+  var temp = items[leftIndex];
+  items[leftIndex] = items[rightIndex];
+  items[rightIndex] = temp;
 }
 function partition(items, left, right) {
-    var pivot   = items[Math.floor((right + left) / 2)], //middle element
-        i       = left, //left pointer
-        j       = right; //right pointer
-    while (i <= j) {
-        while (items[i] < pivot) {
-            i++;
-        }
-        while (items[j] > pivot) {
-            j--;
-        }
-        if (i <= j) {
-            swap(items, i, j); //sawpping two elements
-            i++;
-            j--;
-        }
+  var pivot = items[Math.floor((right + left) / 2)], //middle element
+    i       = left, //left pointer
+    j       = right; //right pointer
+  while (i <= j) {
+    while (items[i] < pivot) {
+      i++;
     }
-    return i;
+    while (items[j] > pivot) {
+      j--;
+    }
+    if (i <= j) {
+      swap(items, i, j); //sawpping two elements
+      i++;
+      j--;
+    }
+  }
+  return i;
 }
 
 function quickSort(items, left, right) {
-    var index;
-    if (items.length > 1) {
-        index = partition(items, left, right); //index returned from partition
-        if (left < index - 1) { //more elements on the left side of the pivot
-            quickSort(items, left, index - 1);
-        }
-        if (index < right) { //more elements on the right side of the pivot
-            quickSort(items, index, right);
-        }
+  var index;
+  if (items.length > 1) {
+    index = partition(items, left, right); //index returned from partition
+    if (left < index - 1) { //more elements on the left side of the pivot
+      quickSort(items, left, index - 1);
+    }
+    if (index < right) { //more elements on the right side of the pivot
+      quickSort(items, index, right);
     }
-    return items;
+  }
+  return items;
 }
 
+module.exports.quickSort = quickSort;

Diff for: Maximal_square_Test.js

@@ -1,16 +1,17 @@
 // Testing Gist
 var heapSort = function(arr) {
   var n = arr.length;
-  for(var i = Math.floor(n/2) - 1; i >= 0; i--)
+  for(let i = Math.floor(n/2) - 1; i >= 0; i--) {
     heapify(arr, n, i);
+  }
 
-  for(var i = n - 1; i >= 0; i--) {
+  for(let i = n - 1; i >= 0; i--) {
     swap(arr, 0, i);
     heapify(arr, i, 0);
   }
 
   return arr;
-}
+};
 
 var heapify = function(arr, n, i) {
   var left = 2 * i + 1;
@@ -32,17 +33,17 @@ var heapify = function(arr, n, i) {
     swap(arr, i, right);
     heapify(arr, n, right);
   }
-}
+};
 
 var swap = function(arr, a, b) {
   var temp = arr[a];
   arr[a] = arr[b];
   arr[b] = temp;
-}
+};
 
 console.log(heapSort([14, 1, 10, 2, 3, 5, 6, 4, 7, 11, 12, 13]));
 console.log(heapSort([]));
 console.log(heapSort([1]));
 console.log(heapSort([2, 1]));
-console.log(heapSort([1,7,2,3,4,1,10,2,3,4,5]))
+console.log(heapSort([1,7,2,3,4,1,10,2,3,4,5]));
 

Diff for: SortingAlgorithms/QuickSort.js

@@ -2,34 +2,43 @@
 /* eslint-disable no-undef */
 const fs = require("fs");
 
+const PROBLEMS_FOLDERS = [
+  "./LeetcodeProblems/Algorithms/easy/",
+  "./LeetcodeProblems/Algorithms/medium/",
+  "./LeetcodeProblems/Algorithms/hard/"
+];
+
 const TESTS_FOLDERS = [
   "./LeetcodeProblemsTests/Algorithms/easy/",
   "./LeetcodeProblemsTests/Algorithms/medium/",
   "./LeetcodeProblemsTests/Algorithms/hard/"
-]
+];
 
 const REGEX_PATTERN_HIDDEN_FILES = /(^|\/)\.[^\/\.]/g;
 
-var test_all = async function () {
+const getAllTests = async function (paths) {
+  let problems = [];
+  for(const i in paths) {
+    const folder = paths[i];
+    const newProblems = await loadProblemsFiles(folder); // await
+    problems = problems.concat(newProblems);
+  }
+  return problems;
+};
+
+const runAllTests = async function (problems) {
   try {
-    var problems = [];
-    for(const i in TESTS_FOLDERS) {
-      var folder = TESTS_FOLDERS[i];
-      var new_problems = await loadProblemsFiles(folder); // await
-      problems = problems.concat(new_problems);
-    };
     console.log(problems);
-
-    var solvePromises = problems.map(solve);
+    var solvePromises = problems.map(solveProblem);
 
-    await Promise.all(solvePromises)
+    await Promise.all(solvePromises);
   } catch (error) {
     console.log(error);
     throw new Error(error);
   }
 };
 
-var solve = (problem) => {
+const solveProblem = (problem) => {
   try {
     console.log("Solving: " + problem);
 
@@ -47,28 +56,61 @@ var solve = (problem) => {
     console.log(error);
     throw new Error(error);
   }
-}
+};
 
-var loadProblemsFiles = (folder) => {
+const loadProblemsFiles = (folder) => {
   return new Promise(function (resolve, reject) {
     fs.readdir(folder, (error, files) => {
       if (error) {
         reject(error);
       } else {
         console.log(folder);
-        new_problems = files.filter((item) => !REGEX_PATTERN_HIDDEN_FILES.test(item));
-        new_problems = new_problems.map((item) => folder + item);
+        newProblems = files.filter((item) => !REGEX_PATTERN_HIDDEN_FILES.test(item));
+        newProblems = newProblems.map((item) => folder + item);
 
-        resolve(new_problems);
+        resolve(newProblems);
       }
     });
   });
 };
 
-if (process.argv.length > 2) {
-  const path = process.argv.pop();
-  solve(path);
-} else {
-  test_all();
+const getMissingTests = async function (tests, problems) {
+  const hasTestStatus = problems.reduce((status, problemPath) => {
+    const baseIndex = PROBLEMS_FOLDERS.findIndex((basePath) =>
+      problemPath.startsWith(basePath)
+    );
+
+    let testPath = problemPath
+      .replace(PROBLEMS_FOLDERS[baseIndex], TESTS_FOLDERS[baseIndex])
+      .replace(/\.js$/, "_Test.js");
+    
+    status.push({
+      problem: problemPath,
+      hasTest: tests.includes(testPath)
+    });
+
+    return status;
+  }, []);
+  const missingTests = hasTestStatus.filter((stat) => !stat.hasTest);
+  console.log("Total Problems:", problems.length);
+  console.log("Missing Tests:", missingTests.length);
+
+  if(missingTests.length) {
+    console.table(missingTests);
+  }
+};
+
+async function runScript() {
+  if (process.argv.length > 2) {
+    const path = process.argv.pop();
+    solveProblem(path);
+  } else {
+    const problems = await getAllTests(PROBLEMS_FOLDERS);
+    const tests = await getAllTests(TESTS_FOLDERS);
+  
+    await runAllTests(tests);
+    await getMissingTests(tests, problems);
+  }
 }
- 
+
+runScript();

Diff for: SortingAlgorithms/heapSort.js

@@ -1,4 +1,4 @@
-const assert = require('assert');
+const assert = require("assert");
 
 var assertList = function(list, expectedArr) {
   const listlength = list ? list.length() : 0;
@@ -7,6 +7,6 @@ var assertList = function(list, expectedArr) {
     assert.strictEqual(list.val, expectedArr[i]);
     list = list.next;
   }
-}
+};
 
 module.exports.assertList = assertList;