Run Prettier Batch 4

Author: ignacio-chiazzo

LeetcodeProblems/Algorithms/SearchIng_Rotated_Sorted_Array.js

@@ -22,36 +22,36 @@ Output: -1
 
 */
 
-
 /**
  * @param {number[]} nums
  * @param {number} target
  * @return {number}
  */
-var search = function(nums, target) {
-  return searchAux(nums, target, 0, nums.length -1);
+var search = function (nums, target) {
+  return searchAux(nums, target, 0, nums.length - 1);
 };
 
-var searchAux = function(nums, target, start, end) {
-  if (start > end)
-    return - 1;
-  var middle =  Math.trunc((start + end) /2);
-  
-  if(nums[middle] == target) {
+var searchAux = function (nums, target, start, end) {
+  if (start > end) return -1;
+  var middle = Math.trunc((start + end) / 2);
+
+  if (nums[middle] == target) {
     return middle;
   }
-  
-  if(nums[middle] < nums[nums.length - 1]) { // right part sorted
-    if(nums[middle] < target && nums[nums.length - 1] >= target) {
+
+  if (nums[middle] < nums[nums.length - 1]) {
+    // right part sorted
+    if (nums[middle] < target && nums[nums.length - 1] >= target) {
       return searchAux(nums, target, middle + 1, end);
     }
     return searchAux(nums, target, start, middle - 1);
-  } else { // left part sorted
-    if(nums[0] <= target && nums[middle] > target) {
+  } else {
+    // left part sorted
+    if (nums[0] <= target && nums[middle] > target) {
       return searchAux(nums, target, start, middle - 1);
     }
     return searchAux(nums, target, middle + 1, end);
   }
-}
+};
 
 module.exports.search = search;

LeetcodeProblems/Algorithms/Search_a_2D_Matrix.js

@@ -33,28 +33,25 @@ Output: false
  * @param {number} target
  * @return {boolean}
  */
-var searchMatrix = function(matrix, target) {
-  if(matrix.length === 0)
-    return false;
+var searchMatrix = function (matrix, target) {
+  if (matrix.length === 0) return false;
   return searchMatrixAux(matrix, 0, matrix.length - 1, target);
 };
 
-var searchMatrixAux = function(matrix, firstRow, lastRow, target) {
-  if(firstRow === lastRow) {
-    var iter = 0; 
-    while(iter < matrix[0].length) {
-      if(matrix[firstRow][iter] === target)
-        return true;
+var searchMatrixAux = function (matrix, firstRow, lastRow, target) {
+  if (firstRow === lastRow) {
+    var iter = 0;
+    while (iter < matrix[0].length) {
+      if (matrix[firstRow][iter] === target) return true;
       iter++;
     }
   } else {
     var middle = Math.floor((firstRow + lastRow) / 2); // 0
-    if(target > matrix[middle][matrix[0].length - 1]) 
-      return searchMatrixAux(matrix, middle + 1, lastRow, target)
-    else 
-      return searchMatrixAux(matrix, firstRow, middle, target)
+    if (target > matrix[middle][matrix[0].length - 1])
+      return searchMatrixAux(matrix, middle + 1, lastRow, target);
+    else return searchMatrixAux(matrix, firstRow, middle, target);
   }
-  
+
   return false;
 };
 

LeetcodeProblems/Algorithms/Search_a_2D_Matrix_II.js

@@ -19,26 +19,25 @@ Given target = 20, return false.
 */
 
 /**
-* @param {number[][]} matrix
-* @param {number} target
-* @return {boolean}
-*/
-var searchMatrix = function(matrix, target) {
-  if (matrix.length == 0)
-    return false
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function (matrix, target) {
+  if (matrix.length == 0) return false;
   var lastCol = matrix[0].length - 1;
   var firstRow = 0;
-  
-  while(lastCol >= 0 && firstRow < matrix.length) {
-    if(matrix[firstRow][lastCol] == target) {
+
+  while (lastCol >= 0 && firstRow < matrix.length) {
+    if (matrix[firstRow][lastCol] == target) {
       return true;
-    } else if(matrix[firstRow][lastCol] > target) {
+    } else if (matrix[firstRow][lastCol] > target) {
       lastCol--;
     } else {
       firstRow++;
     }
   }
-  
+
   return false;
 };
 

LeetcodeProblems/Algorithms/Set_Matrix_Zeroes.js

@@ -43,69 +43,61 @@ Could you devise a constant space solution?
  * @param {number[][]} matrix
  * @return {void} Do not return anything, modify matrix in-place instead.
  */
-var setZeroes = function(matrix) {
-  if(matrix.length === 0)
-      return;
-  
+var setZeroes = function (matrix) {
+  if (matrix.length === 0) return;
+
   var pivotRow = -1;
   var pivotCol = -1;
   var iterRow = 0;
   var iterCol = 0;
   var found = false;
-  
+
   // Find a pivot
-  while(!found && iterRow < matrix.length) {
+  while (!found && iterRow < matrix.length) {
     iterCol = 0;
-    while(!found && iterCol < matrix[0].length) {
-      if(matrix[iterRow][iterCol] === 0) {
-        found = true
+    while (!found && iterCol < matrix[0].length) {
+      if (matrix[iterRow][iterCol] === 0) {
+        found = true;
         pivotRow = iterRow;
         pivotCol = iterCol;
       }
       iterCol++;
     }
     iterRow++;
   }
-  
-  if (!found)
-    return;
-  
+
+  if (!found) return;
+
   // Update the Column value
-  for(var i = 0; i < matrix.length; i++) {
-    if(i == pivotRow)
-      continue
-    for(var j = 0; j < matrix[0].length; j++) {
-      if(j == pivotCol)
-        continue;
-      if(matrix[i][j] === 0) {
+  for (var i = 0; i < matrix.length; i++) {
+    if (i == pivotRow) continue;
+    for (var j = 0; j < matrix[0].length; j++) {
+      if (j == pivotCol) continue;
+      if (matrix[i][j] === 0) {
         matrix[i][pivotCol] = 0;
         matrix[pivotRow][j] = 0;
       }
     }
   }
-  
-  for(var 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++)
-    if(matrix[pivotRow][i] === 0 && i !== pivotCol)
-      fillCol(matrix, i);
-  
+
+  for (var 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++)
+    if (matrix[pivotRow][i] === 0 && i !== pivotCol) fillCol(matrix, i);
+
   fillCol(matrix, pivotCol);
   fillRow(matrix, pivotRow);
 
   return matrix;
 };
 
-var fillRow = function(matrix, row) {
-  for(var i = 0; i < matrix[0].length; i++)
-      matrix[row][i] = 0;
-}
+var fillRow = function (matrix, row) {
+  for (var i = 0; i < matrix[0].length; i++) matrix[row][i] = 0;
+};
 
-var fillCol = function(matrix, col) {
-  for(var i = 0; i < matrix.length; i++)
-    matrix[i][col] = 0;
-}
+var fillCol = function (matrix, col) {
+  for (var i = 0; i < matrix.length; i++) matrix[i][col] = 0;
+};
 
 module.exports.setZeroes = setZeroes;

LeetcodeProblems/Algorithms/Simplify_Path.js

@@ -20,44 +20,44 @@ Another corner case is the path might contain multiple slashes '/' together, suc
 In this case, you should ignore redundant slashes and return "/home/foo".
 */
 
-
-var simplifyPath = function(path) {
+var simplifyPath = function (path) {
   var queue = [];
-  var iter = path.length - 1; 
-  while(iter >= 0) {
-    if(path.charAt(iter) === "/") {
+  var iter = path.length - 1;
+  while (iter >= 0) {
+    if (path.charAt(iter) === "/") {
       iter--;
-    } else if(path.slice(iter - 1, iter + 1) == "/.") {
-       iter -= 2;
-    } else if(path.slice(iter - 2, iter + 1) === "/..") {  
-        iter -= 3;    
-        queue.unshift("/..");
-    } else { // it's a characteriter
+    } else if (path.slice(iter - 1, iter + 1) == "/.") {
+      iter -= 2;
+    } else if (path.slice(iter - 2, iter + 1) === "/..") {
+      iter -= 3;
+      queue.unshift("/..");
+    } else {
+      // it's a characteriter
       const endChars = iter;
-      while(iter >= 0 && path.charAt(iter) !== "/") {
+      while (iter >= 0 && path.charAt(iter) !== "/") {
         iter--;
       }
-      if(queue.length > 0 && queue[0] === "/..") {
+      if (queue.length > 0 && queue[0] === "/..") {
         queue.shift();
       } else {
         queue.push("/" + path.slice(iter + 1, endChars + 1));
       }
     }
   }
   var ret = "";
-    
-  while(queue.length > 0) {
+
+  while (queue.length > 0) {
     elem = queue.shift();
-    if(elem == "/..") {
-      while(queue.length > 0 && queue.shift == "/..") {
+    if (elem == "/..") {
+      while (queue.length > 0 && queue.shift == "/..") {
         elem += "/..";
       }
-      elem = (queue.length > 0) ? elem : "";
+      elem = queue.length > 0 ? elem : "";
     } else {
       ret = elem + ret;
     }
   }
-  return (ret.length == 0) ? "/" : ret;
+  return ret.length == 0 ? "/" : ret;
 };
 
 module.exports.simplifyPath = simplifyPath;

LeetcodeProblems/Algorithms/Subarray_Sum_Equals_K.js

@@ -1,4 +1,3 @@
-
 /*
 Subarray Sum Equals K
 https://leetcode.com/problems/subarray-sum-equals-k/
@@ -13,50 +12,45 @@ The length of the array is in range [1, 20,000].
 The range of numbers in the array is [-1000, 1000] and the range of the integer k is [-1e7, 1e7].
 */
 
-
 /**
  * @param {number[]} nums
  * @param {number} k
  * @return {number}
  */
 
- // Solution 1
-var subarraySum = function(nums, k) {
+// Solution 1
+var subarraySum = function (nums, k) {
   var ret = 0;
-  for(var i = 0; i < nums.length; i++) {
+  for (var i = 0; i < nums.length; i++) {
     var count = 0;
-    for(var j = i; j < nums.length; j++) {
+    for (var j = i; j < nums.length; j++) {
       count += nums[j];
-      if(count === k)
-        ret++;
+      if (count === k) ret++;
     }
   }
-  
+
   return ret;
 };
 
-
 // Solution 2
-var subarraySum2 = function(nums, k) {
-  if(nums.length === 0)
-    return 0;
-  
+var subarraySum2 = function (nums, k) {
+  if (nums.length === 0) return 0;
+
   var sums = [];
   sums[0] = 0;
   var count = 0;
-  for(var i = 0; i < nums.length; i++) {
+  for (var i = 0; i < nums.length; i++) {
     count += nums[i];
     sums[i + 1] = count;
   }
-  
-  var ret = 0; 
-  for(var i = 0; i < sums.length - 1; i++) {
-    for(var j = i + 1; j < sums.length; j++) {
-      if(sums[j] - sums[i] === k)
-        ret++;
+
+  var ret = 0;
+  for (var i = 0; i < sums.length - 1; i++) {
+    for (var j = i + 1; j < sums.length; j++) {
+      if (sums[j] - sums[i] === k) ret++;
     }
   }
-  
+
   return ret;
 };
 

LeetcodeProblems/Algorithms/Subsets.js

@@ -22,19 +22,19 @@ Output:
 ]
 */
 
-
-
-var subsets = function(nums) {
+var subsets = function (nums) {
   var ret = [];
-  
+
   subsetByPosition = function (nums, position, current) {
-    if(position == nums.length) {
+    if (position == nums.length) {
       return [current];
     }
     var currentRight = current.slice().concat([nums[position]]);
-    return subsetByPosition(nums, position + 1, currentRight).concat(subsetByPosition(nums, position + 1, current));
-  }
-  
+    return subsetByPosition(nums, position + 1, currentRight).concat(
+      subsetByPosition(nums, position + 1, current)
+    );
+  };
+
   return subsetByPosition(nums, 0, []);
 };