Run Prettier Batch 3

Author: ignacio-chiazzo

LeetcodeProblems/Algorithms/Implement_stack_using_queues.js

@@ -24,44 +24,42 @@ Depending on your language, queue may not be supported natively. You may simulat
 You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).
 */
 
-class MyStack  {
+class MyStack {
   constructor() {
     this.q1 = [];
     this.q2 = [];
-  };
+  }
 
   push(elem) {
-    if(this.q1.length > 0) {
+    if (this.q1.length > 0) {
       this.q1.push(elem);
     } else {
-      this.q2.push(elem); 
+      this.q2.push(elem);
     }
-  };
+  }
 
   pop() {
-    if(this.q1.length === 0 && this.q2.length === 0)
-      return null;
+    if (this.q1.length === 0 && this.q2.length === 0) return null;
 
-    if(this.q1.length > 0) {
-      while(this.q1.length > 1) {
+    if (this.q1.length > 0) {
+      while (this.q1.length > 1) {
         var elem = this.q1.shift();
         this.q2.push(elem);
       }
       return this.q1.shift();
     } else {
-      while(this.q2.length > 1) {
+      while (this.q2.length > 1) {
         var elem = this.q2.shift();
         this.q1.push(elem);
       }
       return this.q2.shift();
     }
-  };
+  }
 
   top() {
-    if(this.q1.length === 0 && this.q2.length === 0)
-      return null;
+    if (this.q1.length === 0 && this.q2.length === 0) return null;
 
-    if(this.q1.length > 0) {
+    if (this.q1.length > 0) {
       var elem = this.pop();
       this.q2.push(elem);
       return elem;
@@ -70,11 +68,11 @@ class MyStack  {
       this.q1.push(elem);
       return elem;
     }
-  };
+  }
 
   empty() {
     return this.q1.length == 0 && this.q2.length === 0;
-  };
+  }
 }
 
-module.exports.MyStack = MyStack;
+module.exports.MyStack = MyStack;

LeetcodeProblems/Algorithms/Kth_Largest_Element_in_an_Array.js

@@ -16,45 +16,43 @@ Note:
 You may assume k is always valid, 1 ≤ k ≤ array's length.
 */
 
-
 /**
  * @param {number[]} nums
  * @param {number} k
  * @return {number}
  */
-var findKthLargest = function(nums, k) {
-  for(var i = Math.floor(nums.length/2) - 1; i >= 0; i--) {
+var findKthLargest = function (nums, k) {
+  for (var i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
     heapify(nums, nums.length, i);
   }
-  
-  for(var i = nums.length -1; i >= nums.length - k - 1 && i >= 0; i--) {
+
+  for (var i = nums.length - 1; i >= nums.length - k - 1 && i >= 0; i--) {
     swap(nums, 0, i);
     heapify(nums, i, 0);
   }
-  
+
   return nums[nums.length - k];
-}
+};
 
-var heapify = function(nums, length, i) {
+var heapify = function (nums, length, i) {
   var left = 2 * i + 1;
   var right = 2 * i + 2;
-  
-  if(left >= length)
-    return;
-  
-  if(nums[i] < nums[left] && (right >= length || nums[left] > nums[right])) { 
+
+  if (left >= length) return;
+
+  if (nums[i] < nums[left] && (right >= length || nums[left] > nums[right])) {
     swap(nums, left, i);
     heapify(nums, length, left);
-  } else if(right < length && nums[right] > nums[i]) {
-    swap(nums, right, i)
-    heapify(nums, length, right)
+  } else if (right < length && nums[right] > nums[i]) {
+    swap(nums, right, i);
+    heapify(nums, length, right);
   }
-}
+};
 
-var swap = function(nums, a, b) {
+var swap = function (nums, a, b) {
   const temp = nums[a];
   nums[a] = nums[b];
   nums[b] = temp;
-}
+};
 
 module.exports.findKthLargest = findKthLargest;

LeetcodeProblems/Algorithms/Linked_List_Cycle_II.js

@@ -10,27 +10,26 @@ Follow up:
 Can you solve it without using extra space?
 */
 
-var ListNode = require('../../UtilsClasses/ListNode').ListNode;
+var ListNode = require("../../UtilsClasses/ListNode").ListNode;
 
 // Optimal solution
 /**
-* @param {ListNode} head
-* @return {ListNode}
-*/
-var detectCycle = function(head) {
-  if (head === null)
-    return null;
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var detectCycle = function (head) {
+  if (head === null) return null;
 
   var slow = head;
   var fast = head;
 
-  while(fast.next !== null && fast.next.next !== null) {
+  while (fast.next !== null && fast.next.next !== null) {
     slow = slow.next;
     fast = fast.next.next;
-    if(fast == slow) {
+    if (fast == slow) {
       var a = head;
       var b = slow;
-      while(a !== b) {
+      while (a !== b) {
         a = a.next;
         b = b.next;
       }
@@ -41,18 +40,18 @@ var detectCycle = function(head) {
 };
 
 // Naiver solution using a Set
-var detectCycle2 = function(head) {
-  if(head === null || head.next === null) {
+var detectCycle2 = function (head) {
+  if (head === null || head.next === null) {
     return null;
   }
   var setNodes = new Set();
   var iter = head;
-  while(iter !== null) {
-    if(setNodes.has(iter)) {
+  while (iter !== null) {
+    if (setNodes.has(iter)) {
       return iter;
     }
     setNodes.add(iter);
-    iter = iter.next
+    iter = iter.next;
   }
   return null;
 };

LeetcodeProblems/Algorithms/Longest_Consecutive_Sequence.js

@@ -17,36 +17,33 @@ Explanation: The longest consecutive elements sequence is [1, 2, 3, 4]. Therefor
  * @param {number[]} nums
  * @return {number}
  */
-var longestConsecutive = function(nums) {
-  if(nums.length === 0) 
-    return 0;
+var longestConsecutive = function (nums) {
+  if (nums.length === 0) return 0;
   var setNums = new Set();
-  for(var i = 0; i < nums.length; i++)
-    setNums.add(nums[i]);
-  
+  for (var i = 0; i < nums.length; i++) setNums.add(nums[i]);
+
   var cons = 1;
   var currentCons = 1;
-  for(var i = 0; i < nums.length; i++) {
+  for (var i = 0; i < nums.length; i++) {
     var number = nums[i];
-    if(setNums.has(number)) {
+    if (setNums.has(number)) {
       setNums.delete(number);
-      
+
       var prevNum = number - 1;
-      while(setNums.has(prevNum)){
+      while (setNums.has(prevNum)) {
         currentCons++;
         setNums.delete(prevNum);
         prevNum--;
       }
-      
+
       var nextNum = number + 1;
-      while(setNums.has(nextNum)){
+      while (setNums.has(nextNum)) {
         currentCons++;
         setNums.delete(nextNum);
         nextNum++;
       }
-      
-      if(currentCons > cons)
-        cons = currentCons    
+
+      if (currentCons > cons) cons = currentCons;
     }
     currentCons = 1;
   }

LeetcodeProblems/Algorithms/Longest_Palindromic_Substring.js

@@ -19,48 +19,55 @@ Output: "bb"
  * @param {string} s
  * @return {string}
  */
-var longestPalindrome = function(str) {
-	if(str.length == 0)
-		return "";
-	
-  var maxPal = 1; 
-	var posPalStart = 0;
+var longestPalindrome = function (str) {
+  if (str.length == 0) return "";
+
+  var maxPal = 1;
+  var posPalStart = 0;
   var currentPalStart = 0;
 
-	for(var i = 1; i < str.length; i++) {
-    if(str.charAt(i - 1) == str.charAt(i)) { 
+  for (var i = 1; i < str.length; i++) {
+    if (str.charAt(i - 1) == str.charAt(i)) {
       currentPalStart = i - 1;
-      var currentPal = 2; 
+      var currentPal = 2;
       var iter = 1;
-      while(i - iter - 1  >= 0 && i + iter < str.length && str.charAt(i - iter - 1) == str.charAt(i + iter)) {
+      while (
+        i - iter - 1 >= 0 &&
+        i + iter < str.length &&
+        str.charAt(i - iter - 1) == str.charAt(i + iter)
+      ) {
         currentPalStart = i - iter - 1;
         iter++;
         currentPal += 2;
       }
-    } 
-    if(currentPal > maxPal) {
+    }
+    if (currentPal > maxPal) {
       maxPal = currentPal;
       posPalStart = currentPalStart;
     }
   }
-  
-  for(var i = 1; i < str.length - 1; i++) {
-    if(str.charAt(i - 1) == str.charAt(i + 1)) {
+
+  for (var i = 1; i < str.length - 1; i++) {
+    if (str.charAt(i - 1) == str.charAt(i + 1)) {
       currentPal = 1;
       var iter = 1;
-      while(i - iter >= 0 && i + iter < str.length && str.charAt(i - iter) == str.charAt(i + iter)) {
+      while (
+        i - iter >= 0 &&
+        i + iter < str.length &&
+        str.charAt(i - iter) == str.charAt(i + iter)
+      ) {
         currentPalStart = i - iter;
         iter++;
         currentPal += 2;
       }
     }
-    if(currentPal > maxPal) {
+    if (currentPal > maxPal) {
       maxPal = currentPal;
       posPalStart = currentPalStart;
     }
   }
-  
+
   return str.slice(posPalStart, posPalStart + maxPal);
-}
+};
 
-module.exports.longestPalindrome = longestPalindrome
+module.exports.longestPalindrome = longestPalindrome;

LeetcodeProblems/Algorithms/Majority_Element.js

@@ -18,30 +18,27 @@ Output: 2
 Note: You should have a better solution than O(N)
 */
 
-
 /**
  * @param {number[]} nums
  * @return {number}
  */
-var majorityElement = function(nums) {
-  if(nums.length === 0)
-    return -1;
-  
+var majorityElement = function (nums) {
+  if (nums.length === 0) return -1;
+
   var candidate = nums[0];
   var proves = 1;
-  
-  for(var i = 1; i < nums.length; i++) {
-    if(nums[i] === candidate) 
-      proves++;
+
+  for (var i = 1; i < nums.length; i++) {
+    if (nums[i] === candidate) proves++;
     else {
       proves--;
-      if(proves === 0)  {
+      if (proves === 0) {
         candidate = nums[i];
         proves = 1;
       }
     }
   }
-  
+
   return candidate;
 };
 

LeetcodeProblems/Algorithms/Max_Area_Of_Island.js

@@ -27,26 +27,37 @@ Note: The length of each dimension in the given grid does not exceed 50.
  * @param {number[][]} grid
  * @return {number}
  */
-var maxAreaOfIsland = function(grid) {
+var maxAreaOfIsland = function (grid) {
   var maxArea = 0;
 
-  for(var i = 0; i < grid.length; i++) {
-      for(var j = 0; j < grid[0].length; j++) {
-          maxArea = Math.max(markIsland(i, j, grid), maxArea);
-      }
+  for (var i = 0; i < grid.length; i++) {
+    for (var j = 0; j < grid[0].length; j++) {
+      maxArea = Math.max(markIsland(i, j, grid), maxArea);
+    }
   }
 
   return maxArea;
 };
 
-var markIsland = function(row, col, grid) {
-  if(row < 0 || row >= grid.length || col < 0 || col >= grid[0].length || grid[row][col] == 0) {
-      return 0;
+var markIsland = function (row, col, grid) {
+  if (
+    row < 0 ||
+    row >= grid.length ||
+    col < 0 ||
+    col >= grid[0].length ||
+    grid[row][col] == 0
+  ) {
+    return 0;
   }
 
   grid[row][col] = 0;
-  return 1 + markIsland(row + 1, col, grid) + markIsland(row - 1, col, grid) 
-          + markIsland(row, col +1, grid) + markIsland(row, col - 1, grid);
-}
+  return (
+    1 +
+    markIsland(row + 1, col, grid) +
+    markIsland(row - 1, col, grid) +
+    markIsland(row, col + 1, grid) +
+    markIsland(row, col - 1, grid)
+  );
+};
 
 module.exports.maxAreaOfIsland = maxAreaOfIsland;

LeetcodeProblems/Algorithms/Maximal_Square.js

@@ -16,53 +16,51 @@ Input:
 Output: 4
 */
 
-
 /**
  * @param {character[][]} matrix
  * @return {number}
  */
-var maximalSquare = function(matrix) {
+var maximalSquare = function (matrix) {
   var maxSquare = 0;
-  for(var i = 0; i < matrix.length; i++) {
-    for(var j = 0; j < matrix[0].length; j++) {
-      if(matrix[i][j] === "1") { // found a 1
+  for (var i = 0; i < matrix.length; i++) {
+    for (var j = 0; j < matrix[0].length; j++) {
+      if (matrix[i][j] === "1") {
+        // found a 1
         const currentMaxSideLength = getCurrentMaxSideLength(matrix, i, j);
-        if(currentMaxSideLength ** 2 > maxSquare)
+        if (currentMaxSideLength ** 2 > maxSquare)
           maxSquare = currentMaxSideLength ** 2;
-      }   
+      }
     }
   }
-  
+
   return maxSquare;
 };
 
-var getCurrentMaxSideLength = function(matrix, i, j) {
+var getCurrentMaxSideLength = function (matrix, i, j) {
   var max = 1;
-  while(i + max < matrix.length && j + max < matrix[0].length) {
+  while (i + max < matrix.length && j + max < matrix[0].length) {
     var lastRow = i + max;
     var lastCol = j + max;
-        
+
     // check last column
-    var iterRow = i; 
-    while(iterRow <= lastRow){
-      if(matrix[iterRow][lastCol] === "0")
-        return max;
-      
+    var iterRow = i;
+    while (iterRow <= lastRow) {
+      if (matrix[iterRow][lastCol] === "0") return max;
+
       iterRow++;
     }
-    
+
     // check last row
     var iterCol = j;
-    while(iterCol <= lastCol) {
-      if(matrix[lastRow][iterCol] === "0")
-        return max;
+    while (iterCol <= lastCol) {
+      if (matrix[lastRow][iterCol] === "0") return max;
       iterCol++;
     }
-    
+
     max++;
   }
-  
+
   return max;
-}
+};
 
 module.exports.maximalSquare = maximalSquare;

LeetcodeProblems/Algorithms/Maximun_Subarray.js

@@ -14,24 +14,21 @@ Follow up:
 
 */
 
-
-var maxSubArray = function(nums) {
-  if(nums.length == 0) 
-    return 0;
+var maxSubArray = function (nums) {
+  if (nums.length == 0) return 0;
   var maxSub = nums[0];
   var currentMax = nums[0];
-  
-  for(var i = 1; i < nums.length; i++) {
+
+  for (var i = 1; i < nums.length; i++) {
     currentMax = max(nums[i], currentMax + nums[i]);
-    if(currentMax > maxSub)
-      maxSub = currentMax;
+    if (currentMax > maxSub) maxSub = currentMax;
   }
 
   return maxSub;
 };
 
-var max = function(i, j) {
-  return (i > j) ? i : j;
-}
+var max = function (i, j) {
+  return i > j ? i : j;
+};
 
 module.exports.maxSubArray = maxSubArray;

LeetcodeProblems/Algorithms/Min_Stack.js

@@ -20,7 +20,6 @@ minStack.top();      --> Returns 0.
 minStack.getMin();   --> Returns -2.
 */
 
-
 class MinStack {
   constructor() {
     this.minStack = [];
@@ -30,47 +29,40 @@ class MinStack {
   }
 
   push(value) {
-    if(this.countStack === this.stack.length)
-      this.stack.push(value);
-    else 
-      this.stack[this.countStack] = value;
+    if (this.countStack === this.stack.length) this.stack.push(value);
+    else this.stack[this.countStack] = value;
     this.countStack++;
-    
+
     const min = this.getMin();
-    if(min === null || min >= value) {
-      if(this.countMinStack === this.minStack.length)
+    if (min === null || min >= value) {
+      if (this.countMinStack === this.minStack.length)
         this.minStack.push(value);
-      else 
-        this.minStack[this.countMinStack] = value;
+      else this.minStack[this.countMinStack] = value;
       this.countMinStack++;
     }
   }
 
   pop() {
-    if(this.countStack === 0)
-      return null;
+    if (this.countStack === 0) return null;
 
     var elem = this.stack[this.countStack - 1];
     this.countStack--;
-    
-    if(elem === this.minStack[this.countMinStack - 1])
-      this.countMinStack--;
+
+    if (elem === this.minStack[this.countMinStack - 1]) this.countMinStack--;
 
     return elem;
   }
 
   top() {
-    if(this.countStack === 0)
-      return null;
-    
+    if (this.countStack === 0) return null;
+
     return this.stack[this.countStack - 1];
   }
 
   getMin() {
-    if(this.countMinStack === 0)
-      return null;
+    if (this.countMinStack === 0) return null;
 
-    return this.minStack[this.countMinStack - 1]
+    return this.minStack[this.countMinStack - 1];
   }
 }
 

LeetcodeProblems/Algorithms/Minimum_Window_Substring.js

@@ -15,31 +15,34 @@ If there is no such window in S that covers all characters in T, return the empt
 If there is such window, you are guaranteed that there will always be only one unique minimum window in S.
 */
 
+var minWindow = function (s, t) {
+  if (t.length === 0 || s.length < t.length) return "";
 
-var minWindow = function(s, t) {
-  if(t.length === 0 || s.length < t.length)
-    return "";
-  
   var start = 0;
   var end = 0;
   var solutionStart, solutionEnd;
   var hashT = getHash(t);
   var currentHash = {};
   var currentCount = 0;
-  while(end < s.length) {
+  while (end < s.length) {
     const letter = s.charAt(end);
-    if(hashT[letter]) {
-      currentHash[letter] = (currentHash[letter]) ? currentHash[letter] + 1 : 1;
-      if(currentHash[letter] <= hashT[letter])
-        currentCount++;
-      if(currentCount === t.length) {
-        while(hashT[s[start]] === undefined || currentHash[s[start]] > hashT[s[start]]) {
-          if(currentHash[s[start]] !== undefined)
+    if (hashT[letter]) {
+      currentHash[letter] = currentHash[letter] ? currentHash[letter] + 1 : 1;
+      if (currentHash[letter] <= hashT[letter]) currentCount++;
+      if (currentCount === t.length) {
+        while (
+          hashT[s[start]] === undefined ||
+          currentHash[s[start]] > hashT[s[start]]
+        ) {
+          if (currentHash[s[start]] !== undefined)
             currentHash[s[start]] = currentHash[s[start]] - 1;
-          
+
           start++;
         }
-        if(solutionEnd === undefined || end - start < solutionEnd - solutionStart) {
+        if (
+          solutionEnd === undefined ||
+          end - start < solutionEnd - solutionStart
+        ) {
           solutionStart = start;
           solutionEnd = end;
         }
@@ -51,17 +54,17 @@ var minWindow = function(s, t) {
     }
     end++;
   }
-  
+
   return s.slice(solutionStart, solutionEnd + 1);
-};    
+};
 
-var getHash = function(t) {
+var getHash = function (t) {
   var hash = {};
-  for(var i = 0; i < t.length; i++) {
+  for (var i = 0; i < t.length; i++) {
     const letter = t.charAt(i);
-    hash[letter] = (hash[letter]) ? hash[letter] + 1 : 1;
+    hash[letter] = hash[letter] ? hash[letter] + 1 : 1;
   }
   return hash;
-}
+};
 
 module.exports.minWindow = minWindow;

LeetcodeProblems/Algorithms/NQueens.js

@@ -17,57 +17,76 @@ Output: [
   ".Q.."]
 ]
 Explanation: There exist two distinct solutions to the 4-queens puzzle as shown above.
-*/    
-
+*/
 
 /**
  * @param {number} n
  * @return {string[][]}
  */
-var solveNQueens = function(n) {
+var solveNQueens = function (n) {
   var sol = [];
   solveNQueensAux(n, 0, new Set(), new Set(), new Set(), [], sol);
   return parseSolutions(sol, n);
 };
 
-var solveNQueensAux = function(n, row, diagonalDiffs, diagonalSums, cols, currentSol, sol) {
-  if(row == n) { 
-    sol.push(currentSol);  
-    return; 
+var solveNQueensAux = function (
+  n,
+  row,
+  diagonalDiffs,
+  diagonalSums,
+  cols,
+  currentSol,
+  sol
+) {
+  if (row == n) {
+    sol.push(currentSol);
+    return;
   }
-  
-  for(var i = 0; i < n; i++) {
+
+  for (var i = 0; i < n; i++) {
     const diagonalDiff = i - row;
     const diagonalSum = i + row;
-    if(!diagonalDiffs.has(diagonalDiff) && !cols.has(i) && !diagonalSums.has(diagonalSum)) {
+    if (
+      !diagonalDiffs.has(diagonalDiff) &&
+      !cols.has(i) &&
+      !diagonalSums.has(diagonalSum)
+    ) {
       diagonalDiffs.add(diagonalDiff);
       diagonalSums.add(diagonalSum);
       cols.add(i);
-      solveNQueensAux(n, row + 1, diagonalDiffs, diagonalSums, cols, [...currentSol, ...[[row, i]]], sol);
+      solveNQueensAux(
+        n,
+        row + 1,
+        diagonalDiffs,
+        diagonalSums,
+        cols,
+        [...currentSol, ...[[row, i]]],
+        sol
+      );
       cols.delete(i);
       diagonalDiffs.delete(diagonalDiff);
       diagonalSums.delete(diagonalSum);
     }
   }
-}
+};
 
-var parseSolutions = function(sols, n) {
+var parseSolutions = function (sols, n) {
   var matrixes = [];
-  for(var i = 0; i < sols.length; i++) {
+  for (var i = 0; i < sols.length; i++) {
     var sol = sols[i];
     var matrix = [];
-    for(var row = 0; row < n; row++) {
-      matrix[row] = []
+    for (var row = 0; row < n; row++) {
+      matrix[row] = [];
       const queenPos = sol[row];
-      for(var col = 0; col < n; col++) {
-        matrix[row] += (queenPos[1] == col) ? "Q" : ".";
+      for (var col = 0; col < n; col++) {
+        matrix[row] += queenPos[1] == col ? "Q" : ".";
       }
     }
 
     matrixes.push(matrix);
   }
 
   return matrixes;
-}
+};
 
 module.exports.solveNQueens = solveNQueens;

LeetcodeProblems/Algorithms/Number_of_Islands.js

@@ -25,40 +25,38 @@ Input:
 Output: 3
 */
 
-
 /*
  * @param {character[][]} grid
  * @return {number}
  */
-var numIslands = function(grid) {
-  if(grid.length === 0)
-      return 0;
-  
+var numIslands = function (grid) {
+  if (grid.length === 0) return 0;
+
   var countIslands = 0;
   const rowsCount = grid.length;
   const columnsCount = grid[0].length;
-  for(var i = 0; i < rowsCount; i++) {
-    for(var j = 0; j < columnsCount; j++) {
-      if(grid[i][j] == 1) {
+  for (var i = 0; i < rowsCount; i++) {
+    for (var j = 0; j < columnsCount; j++) {
+      if (grid[i][j] == 1) {
         countIslands++;
         colorIsland(grid, i, j, rowsCount, columnsCount);
       }
     }
   }
-  
+
   return countIslands;
 };
 
-var colorIsland = function(grid, i, j, rowsCount, columnsCount) {
-  if(i < 0 || j < 0 || i >= rowsCount || j >= columnsCount || grid[i][j] == 0)
-      return;
-  
+var colorIsland = function (grid, i, j, rowsCount, columnsCount) {
+  if (i < 0 || j < 0 || i >= rowsCount || j >= columnsCount || grid[i][j] == 0)
+    return;
+
   grid[i][j] = 0;
-  
+
   colorIsland(grid, i - 1, j, rowsCount, columnsCount);
   colorIsland(grid, i + 1, j, rowsCount, columnsCount);
   colorIsland(grid, i, j - 1, rowsCount, columnsCount);
   colorIsland(grid, i, j + 1, rowsCount, columnsCount);
-}
+};
 
 module.exports.numIslands = numIslands;

LeetcodeProblems/Algorithms/Number_of_Segments_in_a_String.js

@@ -12,24 +12,22 @@ Input: "Hello, my name is John"
 Output: 5
 */
 
-
 /**
  * @param {string} s
  * @return {number}
  */
-var countSegments = function(s) {
+var countSegments = function (s) {
   var count = 0;
   var i = 0;
 
-  while(i < s.length) {
-    if(s[i] !== " ") {
+  while (i < s.length) {
+    if (s[i] !== " ") {
       count++;
-      while(i < s.length && s[i] !== " ")
-        i++;
+      while (i < s.length && s[i] !== " ") i++;
     }
     i++;
   }
-  
+
   return count;
 };
 

LeetcodeProblems/Algorithms/Permutations.js

@@ -18,24 +18,24 @@ Output:
 ]
 */
 
-var permute = function(nums) {
+var permute = function (nums) {
   return permuteAux(nums, 0, [], new Set());
 };
 
-var permuteAux = function(nums, pos, currentSol, set) {
-  if(pos === nums.length) {
+var permuteAux = function (nums, pos, currentSol, set) {
+  if (pos === nums.length) {
     return [currentSol];
   }
   var ret = [];
-  for(var i = 0; i < nums.length; i++) {
-    if(!set.has(nums[i])) {
-      set.add(nums[i])
+  for (var i = 0; i < nums.length; i++) {
+    if (!set.has(nums[i])) {
+      set.add(nums[i]);
       var sol = permuteAux(nums, pos + 1, currentSol.concat(nums[i]), set);
       ret = [...ret, ...sol];
       set.delete(nums[i]);
     }
   }
   return ret;
-}
+};
 
 module.exports.permute = permute;

LeetcodeProblems/Algorithms/Permutations_II.js

@@ -15,29 +15,28 @@ Output:
 ]
 */
 
-
-var permuteUnique = function(nums) {
+var permuteUnique = function (nums) {
   var map = {};
-  for(var i = 0; i < nums.length; i++) {
-      var value = nums[i];
-      map[value] = (map[value]) ? map[value] + 1 : 1;
+  for (var i = 0; i < nums.length; i++) {
+    var value = nums[i];
+    map[value] = map[value] ? map[value] + 1 : 1;
   }
-  
+
   return permuteUniqueAux(nums.length, map, []);
 };
 
-var permuteUniqueAux = function(n, map, currentSol) {
-  if(currentSol.length === n) {
+var permuteUniqueAux = function (n, map, currentSol) {
+  if (currentSol.length === n) {
     return [currentSol];
   }
 
   var ret = [];
-  for(var num in map) {
+  for (var num in map) {
     const occ = map[num];
-    if(occ === 1) {
+    if (occ === 1) {
       delete map[num];
     } else {
-      map[num] = occ -1 ;
+      map[num] = occ - 1;
     }
     ret = [...ret, ...permuteUniqueAux(n, map, currentSol.concat(num))];
     map[num] = occ;

LeetcodeProblems/Algorithms/Permutations_With_Duplicates.js

@@ -1,32 +1,32 @@
-
-
 // Permutations without
-var subsetWithoutDuplicates = function(nums) {
-  if(nums.lenght == 0){
+var subsetWithoutDuplicates = function (nums) {
+  if (nums.lenght == 0) {
     return;
   }
   var solution = [];
   subsetWithoutDuplicatesAux(nums, [], solution);
   return solution;
-}
+};
 
-var subsetWithoutDuplicatesAux = function(nums, current, sol) {
-  if(nums.length == 0){
+var subsetWithoutDuplicatesAux = function (nums, current, sol) {
+  if (nums.length == 0) {
     sol.push(current);
   }
 
   var setNums = new Set();
 
   nums.forEach((value, index) => {
-    if(setNums.has(value)) {
+    if (setNums.has(value)) {
       return;
     }
     setNums.add(value);
-    var newCurrent = [...current, value]
-    
-    var newNum = nums.filter(function(num, idx) { return index !== idx});
+    var newCurrent = [...current, value];
+
+    var newNum = nums.filter(function (num, idx) {
+      return index !== idx;
+    });
     subsetWithoutDuplicatesAux(newNum, newCurrent, sol);
-  })
-}
+  });
+};
 
 module.exports.subsetWithoutDuplicates = subsetWithoutDuplicates;

LeetcodeProblems/Algorithms/Permutations_Without_Duplicates.js

@@ -19,25 +19,27 @@ Output:
 */
 
 // Permutations without Duplicates
-var subsetWithoutDuplicates = function(nums) {
-  if(nums.lenght == 0){
+var subsetWithoutDuplicates = function (nums) {
+  if (nums.lenght == 0) {
     return;
   }
   var solution = [];
   subsetWithoutDuplicatesAux(nums, [], solution);
   return solution;
-}
+};
 
-var subsetWithoutDuplicatesAux = function(nums, current, sol) {
-  if(nums.length == 0){
+var subsetWithoutDuplicatesAux = function (nums, current, sol) {
+  if (nums.length == 0) {
     sol.push(current);
   }
 
-  for(var i = 0; i < nums.length; i++) {
-    var newCurrent = [...current, nums[i]]
-    var newNums = nums.filter(function(num, index) { return index !== i });
+  for (var i = 0; i < nums.length; i++) {
+    var newCurrent = [...current, nums[i]];
+    var newNums = nums.filter(function (num, index) {
+      return index !== i;
+    });
     subsetWithoutDuplicatesAux(newNums, newCurrent, sol);
   }
-}
+};
 
 module.exports.subsetWithoutDuplicates = subsetWithoutDuplicates;

LeetcodeProblems/Algorithms/Regular_Expression_Matching.js

@@ -51,43 +51,51 @@ Output: false
  * @param {*} p 
  */
 
-
-var isMatch = function(s, p) {
+var isMatch = function (s, p) {
   return isMatchAux(s, p, 0, 0);
 };
 
-var isMatchAux = function(str, pattern, posStr, posPat) {
-  if(posStr == str.length)
+var isMatchAux = function (str, pattern, posStr, posPat) {
+  if (posStr == str.length)
     return posPat == pattern.length || canBeZero(pattern, posPat);
 
-  if(posPat < pattern.length - 1 && pattern.charAt(posPat + 1) == "*") {
+  if (posPat < pattern.length - 1 && pattern.charAt(posPat + 1) == "*") {
     const valuePattern = pattern.charAt(posPat);
     posPat = posPat + 2;
 
-    if (isMatchAux(str, pattern, posStr, posPat)) { // 0 matches
-      return true
+    if (isMatchAux(str, pattern, posStr, posPat)) {
+      // 0 matches
+      return true;
     }
-    
-    while(posStr < str.length && (str.charAt(posStr) === valuePattern || valuePattern === ".")) {
-      if(isMatchAux(str, pattern, posStr + 1, posPat)) {
+
+    while (
+      posStr < str.length &&
+      (str.charAt(posStr) === valuePattern || valuePattern === ".")
+    ) {
+      if (isMatchAux(str, pattern, posStr + 1, posPat)) {
         return true;
       }
       posStr++;
     }
-  } else if(str.charAt(posStr) === pattern.charAt(posPat) || pattern.charAt(posPat) === ".") {
+  } else if (
+    str.charAt(posStr) === pattern.charAt(posPat) ||
+    pattern.charAt(posPat) === "."
+  ) {
     return isMatchAux(str, pattern, posStr + 1, posPat + 1);
   }
-  
+
   return false;
-}
+};
 
-var canBeZero = function(pattern, posPat) {
-  while(posPat < pattern.length && pattern.charAt(posPat) == "*" || 
-    posPat < pattern.length - 1 && pattern.charAt(posPat + 1) == "*") {
+var canBeZero = function (pattern, posPat) {
+  while (
+    (posPat < pattern.length && pattern.charAt(posPat) == "*") ||
+    (posPat < pattern.length - 1 && pattern.charAt(posPat + 1) == "*")
+  ) {
     posPat++;
   }
-  
+
   return posPat == pattern.length;
-}
+};
 
 module.exports.isMatch = isMatch;

LeetcodeProblems/Algorithms/Remove_Invalid_Parentheses.js

@@ -24,49 +24,47 @@ Output: [""]
  * @param {string} s
  * @return {string[]}
  */
-var removeInvalidParentheses = function(s) {
+var removeInvalidParentheses = function (s) {
   var queue = [];
   var visited = new Set();
   queue.push(s);
   var result = [];
   var found = false;
-    
-  while(queue.length !== 0) {
+
+  while (queue.length !== 0) {
     var str = queue.shift();
-    if(isValid(str)) {
+    if (isValid(str)) {
       result.push(str);
       found = true;
-    } else if(!found){   
-      for(var i = 0; i < s.length; i++) {
-        if(str[i] === "(" || str[i] === ")") {
+    } else if (!found) {
+      for (var i = 0; i < s.length; i++) {
+        if (str[i] === "(" || str[i] === ")") {
           var subStr = str.slice(0, i) + str.slice(i + 1, s.length);
-          if(!visited.has(subStr)) {
-            queue.push(subStr);   
+          if (!visited.has(subStr)) {
+            queue.push(subStr);
             visited.add(subStr);
           }
-        }    
+        }
       }
     }
   }
-  
+
   return result;
 };
 
-var isValid = function(s) {
+var isValid = function (s) {
   var leftCount = 0;
   var iter = 0;
-  while(iter < s.length) {
-    if(s[iter] === "(") 
-      leftCount++;
-    else if(s[iter] === ")") {
+  while (iter < s.length) {
+    if (s[iter] === "(") leftCount++;
+    else if (s[iter] === ")") {
       leftCount--;
-      if(leftCount < 0)
-        return false;
+      if (leftCount < 0) return false;
     }
     iter++;
-  }    
-  
+  }
+
   return leftCount === 0;
-}
+};
 
 module.exports.removeInvalidParentheses = removeInvalidParentheses;

LeetcodeProblems/Algorithms/Restore_IP_Addresses.js

@@ -10,34 +10,42 @@ Input: "25525511135"
 Output: ["255.255.11.135", "255.255.111.35"]
 */
 
-var restoreIpAddresses = function(s) {
+var restoreIpAddresses = function (s) {
   var restore = restoreInputBits("", s, 4);
 
   var ret = [];
-  for(var i = 0; i < restore.length; i++) {
+  for (var i = 0; i < restore.length; i++) {
     ret.push(restore[i].join("."));
   }
 
   return ret;
 };
 
-var restoreInputBits = function(partial, s, num) {
-  if(s.length == 0 && num == 0 )
-    return [partial];
-  if(s.length < num || s.length > num * 3 || num == 0) 
-    return [];
-  
-  const oneNum = restoreInputBits([...partial, s.slice(0, 1)], s.slice(1), num - 1);
-
-  if(s.length === 1 || s.slice(0, 1) === "0")
-    return oneNum 
-
-  const twoNums = restoreInputBits([...partial, s.slice(0, 2)], s.slice(2), num - 1);
-  if(s.length === 2 || s.slice(0, 3) > 255)
-    return [...oneNum, ...twoNums] 
-
-  const threeNums = restoreInputBits([...partial, s.slice(0, 3)], s.slice(3), num - 1);
+var restoreInputBits = function (partial, s, num) {
+  if (s.length == 0 && num == 0) return [partial];
+  if (s.length < num || s.length > num * 3 || num == 0) return [];
+
+  const oneNum = restoreInputBits(
+    [...partial, s.slice(0, 1)],
+    s.slice(1),
+    num - 1
+  );
+
+  if (s.length === 1 || s.slice(0, 1) === "0") return oneNum;
+
+  const twoNums = restoreInputBits(
+    [...partial, s.slice(0, 2)],
+    s.slice(2),
+    num - 1
+  );
+  if (s.length === 2 || s.slice(0, 3) > 255) return [...oneNum, ...twoNums];
+
+  const threeNums = restoreInputBits(
+    [...partial, s.slice(0, 3)],
+    s.slice(3),
+    num - 1
+  );
   return [...oneNum, ...twoNums, ...threeNums];
-}
+};
 
 module.exports.restoreIpAddresses = restoreIpAddresses;

LeetcodeProblems/Algorithms/Reverse_String_II.js

@@ -11,31 +11,29 @@ The string consists of lower English letters only.
 Length of the given string and k will in the range [1, 10000]
 */
 
-var reverseStr = function(s, k) {
-  if(k <= 1)
-    return s;
+var reverseStr = function (s, k) {
+  if (k <= 1) return s;
   var ret = "";
-  for(var iterK = 0; iterK * k < s.length; iterK = iterK + 2) {
+  for (var iterK = 0; iterK * k < s.length; iterK = iterK + 2) {
     const start = iterK * k;
-    const end = start + k - 1; 
-  
+    const end = start + k - 1;
+
     ret += reverse(s, start, end);
-    ret += s.slice(end + 1, k * (iterK + 2)); 
+    ret += s.slice(end + 1, k * (iterK + 2));
   }
-  
+
   return ret;
 };
 
-var reverse = function(s, start, end) {
+var reverse = function (s, start, end) {
   var ret = "";
-  if(end >= s.length)
-    end = s.length - 1;
-  
-  while(start <= end) {
+  if (end >= s.length) end = s.length - 1;
+
+  while (start <= end) {
     ret += s.charAt(end);
     end--;
   }
   return ret;
-}
+};
 
 module.exports.reverseStr = reverseStr;

LeetcodeProblems/Algorithms/Same_Tree.js

@@ -32,7 +32,7 @@ Input:     1         1
         [1,2,1],   [1,1,2]
 
 Output: false
-*/ 
+*/
 
 /**
  * Definition for a binary tree node.
@@ -46,12 +46,10 @@ Output: false
  * @param {TreeNode} q
  * @return {boolean}
  */
-var isSameTree = function(p, q) {
-  if(p === null)
-    return q === null;
-  
-  if(q === null || p.val !== q.val)
-    return false;
-  
+var isSameTree = function (p, q) {
+  if (p === null) return q === null;
+
+  if (q === null || p.val !== q.val) return false;
+
   return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
 };

LeetcodeProblems/Algorithms/merge_k_sorted_lists.js

@@ -15,48 +15,45 @@ Input:
 Output: 1->1->2->3->4->4->5->6
 */
 
-const ListNodeTestHelper = require('../../utilsClasses/ListNodeTestHelper');
+const ListNodeTestHelper = require("../../utilsClasses/ListNodeTestHelper");
 
-var ListNode = require('../../utilsClasses/ListNode').ListNode;
+var ListNode = require("../../utilsClasses/ListNode").ListNode;
+
+var mergeKLists = function (lists) {
+  if (lists.length === 0) return null;
 
-var mergeKLists = function(lists) {
-  if(lists.length === 0)
-    return null;
-  
   var queue = [];
-  for(var i = 0; i < lists.length; i++) 
-    queue.push(lists[i]);
-  
-  while(queue.length > 1) {
+  for (var i = 0; i < lists.length; i++) queue.push(lists[i]);
+
+  while (queue.length > 1) {
     list1 = queue.shift();
     list2 = queue.shift();
     queue.push(mergeLists(list1, list2));
   }
-  
+
   return queue.shift();
 };
 
-var mergeLists = function(list1, list2) {
-  if(list1 === null) {
+var mergeLists = function (list1, list2) {
+  if (list1 === null) {
     return list2;
-  } else if(list2 === null) 
-    return list1;
-    
+  } else if (list2 === null) return list1;
+
   var iter1 = list1;
-  var iter2 = list2;  
+  var iter2 = list2;
   var head;
-  
-  if(iter1.val < iter2.val) {
+
+  if (iter1.val < iter2.val) {
     head = iter1;
-    iter1 = iter1.next
+    iter1 = iter1.next;
   } else {
     head = iter2;
     iter2 = iter2.next;
   }
 
   var iterHead = head;
-  while(iter1 !== null && iter2 !== null) {
-    if(iter1.val < iter2.val) {
+  while (iter1 !== null && iter2 !== null) {
+    if (iter1.val < iter2.val) {
       iterHead.next = iter1;
       iter1 = iter1.next;
     } else {
@@ -66,14 +63,14 @@ var mergeLists = function(list1, list2) {
     iterHead = iterHead.next;
     iterHead.next = null;
   }
-  
-  if(iter1 !== null) {
+
+  if (iter1 !== null) {
     iterHead.next = iter1;
-  } else if(iter2 !== null) {
+  } else if (iter2 !== null) {
     iterHead.next = iter2;
   }
-  
+
   return head;
-}
+};
 
 module.exports.mergeKLists = mergeKLists;