Added eslint

ignacio-chiazzo · ignacio-chiazzo · commit df2f337af224 · 2022-05-10T23:33:42.000-04:00
diff --git a/.eslintrc.js b/.eslintrc.js
@@ -0,0 +1,30 @@
+module.exports = {
+    "env": {
+        "node": true,
+        "es2021": true
+    },
+    
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "rules": {
+        "indent": [
+            "error",
+            2
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "quotes": [
+            "error",
+            "double"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ]
+    }
+};
diff --git a/LeetcodeProblems/Algorithms/Add_Two_Numbers.js b/LeetcodeProblems/Algorithms/Add_Two_Numbers.js
@@ -41,7 +41,7 @@ var addTwoNumbers = function (l1, l2) {
 
   const head = number;
   while (l1 !== null || l2 !== null) {
-    var elem = carry;
+    elem = carry;
     if (l1 !== null) {
       elem += l1.val;
       l1 = l1.next;
diff --git a/LeetcodeProblems/Algorithms/Backspace_String_Compare.js b/LeetcodeProblems/Algorithms/Backspace_String_Compare.js
@@ -40,10 +40,11 @@ Can you solve it in O(N) time and O(1) space?
 var backspaceCompare = function (S, T) {
   var iterS = S.length - 1;
   var iterT = T.length - 1;
-
+  var countBack = 0;
+      
   while (iterS >= 0 || iterT >= 0) {
     if (iterS >= 0 && S.charAt(iterS) === "#") {
-      var countBack = 0;
+      countBack = 0;
       while (iterS >= 0 && (countBack > 0 || S[iterS] === "#")) {
         if (iterS >= 0 && S[iterS] === "#") {
           countBack++;
@@ -54,7 +55,7 @@ var backspaceCompare = function (S, T) {
         iterS--;
       }
     } else if (iterT >= 0 && T.charAt(iterT) === "#") {
-      var countBack = 0;
+      countBack = 0;
       while (iterT >= 0 && (countBack > 0 || T[iterT] === "#")) {
         if (iterT >= 0 && T[iterT] === "#") {
           countBack++;
@@ -85,7 +86,7 @@ var backspaceCompare2 = function (S, T) {
   }
 
   var stackT = [];
-  for (var i = 0; i < T.length; i++) {
+  for (i = 0; i < T.length; i++) {
     if (T.charAt(i) === "#") stackT.shift();
     else stackT.unshift(T.charAt(i));
   }
diff --git a/LeetcodeProblems/Algorithms/Clone_Graph.js b/LeetcodeProblems/Algorithms/Clone_Graph.js
@@ -40,6 +40,8 @@ You don't need to understand the serialization to solve the problem.
  * }
  */
 
+class UndirectedGraphNode {} //TODO: Define me
+
 // SOLUTION 1 Using DFS
 /**
  * @param {UndirectedGraphNode} graph
@@ -93,3 +95,6 @@ var cloneGraphBFS = function (graph) {
 
   return copyReturn;
 };
+
+module.exports.cloneGraph = cloneGraph;
+module.exports.cloneGraphBFS = cloneGraphBFS;
diff --git a/LeetcodeProblems/Algorithms/Coin_Change.js b/LeetcodeProblems/Algorithms/Coin_Change.js
@@ -25,7 +25,7 @@ var coinChange = function (coins, amount) {
   for (var i = 0; i <= amount; i++) memo[i] = Number.POSITIVE_INFINITY;
 
   memo[0] = 0;
-  for (var i = 0; i < coins.length; i++) {
+  for (i = 0; i < coins.length; i++) {
     const coin = coins[i];
     for (var j = coin; j < memo.length; j++)
       memo[j] = min2(memo[j], memo[j - coin] + 1);
@@ -105,3 +105,5 @@ var min = function (a, b, c) {
 };
 
 module.exports.coinChange = coinChange;
+module.exports.coinChange1 = coinChange1;
+module.exports.coinChange2 = coinChange2;
diff --git a/LeetcodeProblems/Algorithms/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js b/LeetcodeProblems/Algorithms/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js
@@ -40,7 +40,7 @@ var buildTree = function (preorder, inorder) {
     inorder === null ||
     preorder.length !== inorder.length
   )
-    return nil;
+    return null;
 
   return buildTreeAux(
     preorder,
diff --git a/LeetcodeProblems/Algorithms/Edit_Distance.js b/LeetcodeProblems/Algorithms/Edit_Distance.js
@@ -41,8 +41,8 @@ var minDistance = function (word1, word2) {
     }
   }
 
-  for (var i = 1; i <= word1.length; i++) {
-    for (var j = 1; j <= word2.length; j++) {
+  for (i = 1; i <= word1.length; i++) {
+    for (j = 1; j <= word2.length; j++) {
       if (word1.charAt(i - 1) === word2.charAt(j - 1)) {
         matrix[i][j] = matrix[i - 1][j - 1];
       } else {
@@ -90,7 +90,7 @@ var minDistanceAux = function (word1, word2, iter1, iter2) {
   );
 };
 
-var min = function (a, b, c) {
+min = function (a, b, c) {
   if (a < b) return a < c ? a : c;
 
   return b < c ? b : c;
diff --git a/LeetcodeProblems/Algorithms/Escape_The_Ghosts.js b/LeetcodeProblems/Algorithms/Escape_The_Ghosts.js
@@ -44,7 +44,7 @@ The number of ghosts will not exceed 100.
  */
 var escapeGhosts = function (ghosts, target) {
   var distancePacman = getDistance([0, 0], target);
-  for (ghost in ghosts) {
+  for (var ghost in ghosts) {
     const distanceGhost = getDistance(ghosts[ghost], target);
     if (distancePacman > distanceGhost) return false;
   }
diff --git a/LeetcodeProblems/Algorithms/Generate_Parenthesis.js b/LeetcodeProblems/Algorithms/Generate_Parenthesis.js
@@ -20,7 +20,7 @@ var generateParenthesisApproach1 = function (n) {
   if (n === 0) return [];
 
   var str = "(".repeat(n);
-  sol = [];
+  var sol = [];
 
   genParAux(str, 0, 0, sol);
   return sol;
@@ -93,4 +93,5 @@ var insertAt = function (str, position, value) {
   return str.slice(0, position) + value + str.slice(position);
 };
 
+module.exports.generateParenthesisApproach1 = generateParenthesisApproach1;
 module.exports.generateParenthesisApproach2 = generateParenthesisApproach2;
diff --git a/LeetcodeProblems/Algorithms/Group_Anagrams.js b/LeetcodeProblems/Algorithms/Group_Anagrams.js
@@ -33,7 +33,7 @@ var groupAnagrams = function (strs) {
     }
   }
 
-  for (key in hashMap) ret.push(hashMap[key]);
+  for (var key in hashMap) ret.push(hashMap[key]);
 
   return ret;
 };
diff --git a/LeetcodeProblems/Algorithms/Implement_stack_using_queues.js b/LeetcodeProblems/Algorithms/Implement_stack_using_queues.js
@@ -42,14 +42,15 @@ class MyStack {
     if (this.q1.length === 0 && this.q2.length === 0) return null;
 
     if (this.q1.length > 0) {
+      var elem;
       while (this.q1.length > 1) {
-        var elem = this.q1.shift();
+        elem = this.q1.shift();
         this.q2.push(elem);
       }
       return this.q1.shift();
     } else {
       while (this.q2.length > 1) {
-        var elem = this.q2.shift();
+        elem = this.q2.shift();
         this.q1.push(elem);
       }
       return this.q2.shift();
@@ -58,13 +59,13 @@ class MyStack {
 
   top() {
     if (this.q1.length === 0 && this.q2.length === 0) return null;
-
+    var elem;
     if (this.q1.length > 0) {
-      var elem = this.pop();
+      elem = this.pop();
       this.q2.push(elem);
       return elem;
     } else {
-      var elem = this.pop();
+      elem = this.pop();
       this.q1.push(elem);
       return elem;
     }
diff --git a/LeetcodeProblems/Algorithms/Kth_Largest_Element_in_an_Array.js b/LeetcodeProblems/Algorithms/Kth_Largest_Element_in_an_Array.js
@@ -26,7 +26,7 @@ var findKthLargest = function (nums, k) {
     heapify(nums, nums.length, i);
   }
 
-  for (var i = nums.length - 1; i >= nums.length - k - 1 && i >= 0; i--) {
+  for (i = nums.length - 1; i >= nums.length - k - 1 && i >= 0; i--) {
     swap(nums, 0, i);
     heapify(nums, i, 0);
   }
diff --git a/LeetcodeProblems/Algorithms/Linked_List_Cycle_II.js b/LeetcodeProblems/Algorithms/Linked_List_Cycle_II.js
@@ -10,8 +10,6 @@ Follow up:
 Can you solve it without using extra space?
 */
 
-var ListNode = require("../../UtilsClasses/ListNode").ListNode;
-
 // Optimal solution
 /**
  * @param {ListNode} head
@@ -57,3 +55,4 @@ var detectCycle2 = function (head) {
 };
 
 module.exports.detectCycle = detectCycle;
+module.exports.detectCycle2 = detectCycle2;
diff --git a/LeetcodeProblems/Algorithms/Longest_Consecutive_Sequence.js b/LeetcodeProblems/Algorithms/Longest_Consecutive_Sequence.js
@@ -24,7 +24,7 @@ var longestConsecutive = function (nums) {
 
   var cons = 1;
   var currentCons = 1;
-  for (var i = 0; i < nums.length; i++) {
+  for (i = 0; i < nums.length; i++) {
     var number = nums[i];
     if (setNums.has(number)) {
       setNums.delete(number);
diff --git a/LeetcodeProblems/Algorithms/Longest_Palindromic_Substring.js b/LeetcodeProblems/Algorithms/Longest_Palindromic_Substring.js
@@ -25,12 +25,13 @@ var longestPalindrome = function (str) {
   var maxPal = 1;
   var posPalStart = 0;
   var currentPalStart = 0;
+  var iter = 1;
 
   for (var i = 1; i < str.length; i++) {
     if (str.charAt(i - 1) == str.charAt(i)) {
       currentPalStart = i - 1;
       var currentPal = 2;
-      var iter = 1;
+      iter = 1;
       while (
         i - iter - 1 >= 0 &&
         i + iter < str.length &&
@@ -47,10 +48,10 @@ var longestPalindrome = function (str) {
     }
   }
 
-  for (var i = 1; i < str.length - 1; i++) {
+  for (i = 1; i < str.length - 1; i++) {
     if (str.charAt(i - 1) == str.charAt(i + 1)) {
       currentPal = 1;
-      var iter = 1;
+      iter = 1;
       while (
         i - iter >= 0 &&
         i + iter < str.length &&
diff --git a/LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree.js b/LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree.js
@@ -34,8 +34,6 @@ All of the nodes' values will be unique.
 p and q are different and both values will exist in the binary tree.
 */
 
-var TreeNode = require("../../UtilsClasses/TreeNode").TreeNode;
-
 // Solution 1
 var lowestCommonAncestor = function (root, p, q) {
   if (root === null) return root;
diff --git a/LeetcodeProblems/Algorithms/Same_Tree.js b/LeetcodeProblems/Algorithms/Same_Tree.js
@@ -53,3 +53,5 @@ var isSameTree = function (p, q) {
 
   return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
 };
+
+module.exports.isSameTree = isSameTree;
diff --git a/LeetcodeProblems/Algorithms/Set_Matrix_Zeroes.js b/LeetcodeProblems/Algorithms/Set_Matrix_Zeroes.js
@@ -80,10 +80,10 @@ var setZeroes = function (matrix) {
     }
   }
 
-  for (var i = 0; i < matrix.length; i++)
+  for (i = 0; i < matrix.length; i++)
     if (matrix[i][pivotCol] === 0 && i !== pivotRow) fillRow(matrix, i);
 
-  for (var i = 0; i < matrix[0].length; i++)
+  for (i = 0; i < matrix[0].length; i++)
     if (matrix[pivotRow][i] === 0 && i !== pivotCol) fillCol(matrix, i);
 
   fillCol(matrix, pivotCol);
diff --git a/LeetcodeProblems/Algorithms/Simplify_Path.js b/LeetcodeProblems/Algorithms/Simplify_Path.js
@@ -45,6 +45,7 @@ var simplifyPath = function (path) {
     }
   }
   var ret = "";
+  var elem;
 
   while (queue.length > 0) {
     elem = queue.shift();
diff --git a/LeetcodeProblems/Algorithms/Spiral_Matrix.js b/LeetcodeProblems/Algorithms/Spiral_Matrix.js
@@ -57,10 +57,10 @@ var printRect = function (matrix, i, rowLength, colLength, retArray) {
   if (firstRow === lastRow || firstCol === lastCol) {
     return;
   }
-  for (var col = lastCol - 1; col >= firstCol; col--) {
+  for (col = lastCol - 1; col >= firstCol; col--) {
     retArray.push(matrix[lastRow][col]);
   }
-  for (var row = lastRow - 1; row > firstRow; row--) {
+  for (row = lastRow - 1; row > firstRow; row--) {
     retArray.push(matrix[row][firstCol]);
   }
 };
diff --git a/LeetcodeProblems/Algorithms/Subarray_Sum_Equals_K.js b/LeetcodeProblems/Algorithms/Subarray_Sum_Equals_K.js
@@ -45,7 +45,7 @@ var subarraySum2 = function (nums, k) {
   }
 
   var ret = 0;
-  for (var i = 0; i < sums.length - 1; i++) {
+  for (i = 0; i < sums.length - 1; i++) {
     for (var j = i + 1; j < sums.length; j++) {
       if (sums[j] - sums[i] === k) ret++;
     }
@@ -55,3 +55,4 @@ var subarraySum2 = function (nums, k) {
 };
 
 module.exports.subarraySum = subarraySum;
+module.exports.subarraySum2 = subarraySum2;
diff --git a/LeetcodeProblems/Algorithms/Subsets.js b/LeetcodeProblems/Algorithms/Subsets.js
@@ -23,9 +23,7 @@ Output:
 */
 
 var subsets = function (nums) {
-  var ret = [];
-
-  subsetByPosition = function (nums, position, current) {
+  var subsetByPosition = function (nums, position, current) {
     if (position == nums.length) {
       return [current];
     }
diff --git a/LeetcodeProblems/Algorithms/Symmetric_Tree.js b/LeetcodeProblems/Algorithms/Symmetric_Tree.js
@@ -50,3 +50,5 @@ var isSymetricAux = function (root1, root2) {
     isSymetricAux(root1.right, root2.left)
   );
 };
+
+module.exports.isSymmetric = isSymmetric;
diff --git a/LeetcodeProblems/Algorithms/Unique_Paths.js b/LeetcodeProblems/Algorithms/Unique_Paths.js
@@ -98,5 +98,5 @@ var uniquePaths3 = function (m, n) {
 };
 
 module.exports.uniquePaths1 = uniquePaths1;
-module.exports.uniquePaths2 = uniquePaths1;
+module.exports.uniquePaths2 = uniquePaths2;
 module.exports.uniquePaths3 = uniquePaths3;
diff --git a/LeetcodeProblems/Algorithms/merge_k_sorted_lists.js b/LeetcodeProblems/Algorithms/merge_k_sorted_lists.js
@@ -15,14 +15,12 @@ Input:
 Output: 1->1->2->3->4->4->5->6
 */
 
-const ListNodeTestHelper = require("../../utilsClasses/ListNodeTestHelper");
-
-var ListNode = require("../../utilsClasses/ListNode").ListNode;
-
 var mergeKLists = function (lists) {
   if (lists.length === 0) return null;
 
   var queue = [];
+  var list1;
+  var list2;
   for (var i = 0; i < lists.length; i++) queue.push(lists[i]);
 
   while (queue.length > 1) {
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ var buildTree = function (preorder, inorder) {`
`40`	`40`	`inorder === null \|\|`
`41`	`41`	`preorder.length !== inorder.length`
`42`	`42`	`)`
`43`		`- return nil;`
	`43`	`+ return null;`
`44`	`44`
`45`	`45`	`return buildTreeAux(`
`46`	`46`	`preorder,`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ The number of ghosts will not exceed 100.`
`44`	`44`	`*/`
`45`	`45`	`var escapeGhosts = function (ghosts, target) {`
`46`	`46`	`var distancePacman = getDistance([0, 0], target);`
`47`		`- for (ghost in ghosts) {`
	`47`	`+ for (var ghost in ghosts) {`
`48`	`48`	`const distanceGhost = getDistance(ghosts[ghost], target);`
`49`	`49`	`if (distancePacman > distanceGhost) return false;`
`50`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ var groupAnagrams = function (strs) {`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`		`- for (key in hashMap) ret.push(hashMap[key]);`
	`36`	`+ for (var key in hashMap) ret.push(hashMap[key]);`
`37`	`37`
`38`	`38`	`return ret;`
`39`	`39`	`};`