Run Prettier Batch 5

Author: ignacio-chiazzo

LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree.js

@@ -34,64 +34,58 @@ 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;
+var TreeNode = require("../../UtilsClasses/TreeNode").TreeNode;
 
 // Solution 1
-var lowestCommonAncestor = function(root, p, q) {
-  if(root === null)
-    return root;
-  if(p.val === root.val)
-    return p;
-  if(q.val === root.val)
-    return q;
+var lowestCommonAncestor = function (root, p, q) {
+  if (root === null) return root;
+  if (p.val === root.val) return p;
+  if (q.val === root.val) return q;
 
   const left = lowestCommonAncestor(root.left, p, q);
   const right = lowestCommonAncestor(root.right, p, q);
-  if(left !== null && right !== null)
-    return root;
+  if (left !== null && right !== null) return root;
   return left !== null ? left : right;
 };
 
 // Solution 2
-var lowestCommonAncestor2 = function(root, p, q) {
+var lowestCommonAncestor2 = function (root, p, q) {
   var pathToP = pathTo(root, p.val);
   var pathToQ = pathTo(root, q.val);
 
-  if(pathToP.length === 0 || pathToQ === 0)
-    return null;
+  if (pathToP.length === 0 || pathToQ === 0) return null;
 
   var iter = 0;
-  while(iter < pathToP.length - 1 && iter < pathToQ.length - 1 && pathToP[iter + 1] === pathToQ[iter + 1]) {
-    if(root.left !== null && root.left.val === pathToP[iter + 1]) {
-      root = root.left;  
+  while (
+    iter < pathToP.length - 1 &&
+    iter < pathToQ.length - 1 &&
+    pathToP[iter + 1] === pathToQ[iter + 1]
+  ) {
+    if (root.left !== null && root.left.val === pathToP[iter + 1]) {
+      root = root.left;
     } else {
-      root = root.right;  
+      root = root.right;
     }
     iter++;
   }
-    
+
   return root;
 };
 
-var pathTo = function(root, value) {
-  if(root === null)
-    return [];
-    
+var pathTo = function (root, value) {
+  if (root === null) return [];
+
   var list = [root.val];
-  if(root.val === value)
-    return list;
+  if (root.val === value) return list;
 
   const left = pathTo(root.left, value);
-  if (left.length > 0)
-    return list.concat(left);
+  if (left.length > 0) return list.concat(left);
+
+  const right = pathTo(root.right, value);
+  if (right.length > 0) return list.concat(right);
 
-  const right = pathTo(root.right, value);    
-  if(right.length > 0)
-    return list.concat(right);
-    
   return [];
-}
+};
 
 module.exports.lowestCommonAncestor = lowestCommonAncestor;
 module.exports.lowestCommonAncestor2 = lowestCommonAncestor2;

LeetcodeProblems/Algorithms/Spiral_Matrix.js

@@ -24,47 +24,45 @@ Input:
 Output: [1,2,3,4,8,12,11,10,9,5,6,7]
 */
 
-
 /**
  * @param {number[][]} matrix
  * @return {number[]}
  */
 
-var spiralOrder = function(matrix) {
-    if(matrix.length === 0)
-      return [];
-      
-    var retArray = [];
-    const rowLength = matrix.length;
-    const colLength = matrix[0].length;
-    const countRectangles = Math.ceil(Math.min(colLength, rowLength)/2)
-    for(var i = 0; i < countRectangles; i++)
-      printRect(matrix, i, rowLength, colLength, retArray);
+var spiralOrder = function (matrix) {
+  if (matrix.length === 0) return [];
+
+  var retArray = [];
+  const rowLength = matrix.length;
+  const colLength = matrix[0].length;
+  const countRectangles = Math.ceil(Math.min(colLength, rowLength) / 2);
+  for (var i = 0; i < countRectangles; i++)
+    printRect(matrix, i, rowLength, colLength, retArray);
 
-    return retArray;
+  return retArray;
 };
 
-var printRect = function(matrix, i, rowLength, colLength, retArray) {
+var printRect = function (matrix, i, rowLength, colLength, retArray) {
   const firstRow = i;
   const firstCol = i;
   const lastRow = rowLength - i - 1;
   const lastCol = colLength - i - 1;
-  
-  for(var col = firstCol; col <= lastCol; col++) {
+
+  for (var col = firstCol; col <= lastCol; col++) {
     retArray.push(matrix[firstRow][col]);
   }
-  for(var row = firstRow + 1; row <= lastRow; row++) {
+  for (var row = firstRow + 1; row <= lastRow; row++) {
     retArray.push(matrix[row][lastCol]);
   }
-  if(firstRow === lastRow || firstCol === lastCol) {
+  if (firstRow === lastRow || firstCol === lastCol) {
     return;
   }
-  for(var col = lastCol - 1; col >= firstCol; col--) {
+  for (var col = lastCol - 1; col >= firstCol; col--) {
     retArray.push(matrix[lastRow][col]);
   }
-  for(var row = lastRow - 1; row > firstRow; row--) {
+  for (var row = lastRow - 1; row > firstRow; row--) {
     retArray.push(matrix[row][firstCol]);
   }
-}
+};
 
 module.exports.spiralOrder = spiralOrder;

LeetcodeProblems/Algorithms/Sum_Of_Square_Numbers.js

@@ -18,18 +18,17 @@ Output: False
  * @param {number} c
  * @return {boolean}
  */
-var judgeSquareSum = function(c) {
+var judgeSquareSum = function (c) {
   var iter = 0;
   var set = new Set();
-  while(iter ** 2 <= c) {
+  while (iter ** 2 <= c) {
     var square = iter * iter;
-    if(square * 2 === c || set.has(c - square))
-      return true;
+    if (square * 2 === c || set.has(c - square)) return true;
 
     set.add(square);
     iter++;
   }
-  
+
   return false;
 };
 

LeetcodeProblems/Algorithms/Swap_Nodes_In_Pairs.js

@@ -24,25 +24,24 @@ You may not modify the values in the list's nodes, only nodes itself may be chan
  * @param {ListNode} head
  * @return {ListNode}
  */
-var swapPairs = function(head) {
-  if(head === null || head.next === null)
-      return head
-  var previous  = null;
-  var current   = head;
-  var following = (head.next != null) ? head.next.next : null;
+var swapPairs = function (head) {
+  if (head === null || head.next === null) return head;
+  var previous = null;
+  var current = head;
+  var following = head.next != null ? head.next.next : null;
   head = head.next;
-  
-  while(current !== null && current.next !== null) {
-      var next = current.next;
-      next.next = current; 
-      if(previous != null)
-          previous.next = next;
-      current.next = following;    
-      previous = current;
-      current = following;
-      following = (current !== null && current.next != null) ? current.next.next : null;
+
+  while (current !== null && current.next !== null) {
+    var next = current.next;
+    next.next = current;
+    if (previous != null) previous.next = next;
+    current.next = following;
+    previous = current;
+    current = following;
+    following =
+      current !== null && current.next != null ? current.next.next : null;
   }
-  
+
   return head;
 };
 

LeetcodeProblems/Algorithms/Symmetric_Tree.js

@@ -33,19 +33,20 @@ Bonus points if you could solve it both recursively and iteratively.
  * @param {TreeNode} root
  * @return {boolean}
  */
-var isSymmetric = function(root) {
-  if(root === null)
-    return true; 
+var isSymmetric = function (root) {
+  if (root === null) return true;
   return isSymetricAux(root.left, root.right);
 };
 
-var isSymetricAux = function(root1, root2) {
-  if(root1 === null)
-    return root2 === null;
-  
-  if(root2 === null || root1.val !== root2.val) {
+var isSymetricAux = function (root1, root2) {
+  if (root1 === null) return root2 === null;
+
+  if (root2 === null || root1.val !== root2.val) {
     return false;
   }
-  
-  return isSymetricAux(root1.left, root2.right) && isSymetricAux(root1.right, root2.left);
-}
+
+  return (
+    isSymetricAux(root1.left, root2.right) &&
+    isSymetricAux(root1.right, root2.left)
+  );
+};

LeetcodeProblems/Algorithms/Tic_Tac_Toe.js

@@ -1,14 +1,13 @@
-
 class TicTacToe {
   constructor() {
     this.matrix = [];
-    for(var i = 0; i < 3; i++) {
+    for (var i = 0; i < 3; i++) {
       this.matrix[i] = [];
-      for(var j = 0; j < 3; j++) {
+      for (var j = 0; j < 3; j++) {
         this.matrix[i][j] = "-";
       }
     }
-  };
+  }
 
   validToken(token) {
     if (token == "X" || token == "0" || token == "-") {
@@ -20,41 +19,45 @@ class TicTacToe {
 
   addToken(x, y, token) {
     // Check valid positions
-    if(this.validToken(token)) {
+    if (this.validToken(token)) {
       this.matrix[x][y] = token;
     }
-  };
+  }
 
   printBoard() {
     console.log("-------");
-    for(var row = 0; row < 3; row ++) {
-      console.log(this.matrix[row][0] + "|" 
-      + this.matrix[row][1] + "|" 
-      + this.matrix[row][2]); // Check new line;
+    for (var row = 0; row < 3; row++) {
+      console.log(
+        this.matrix[row][0] +
+          "|" +
+          this.matrix[row][1] +
+          "|" +
+          this.matrix[row][2]
+      ); // Check new line;
     }
     console.log("------- \n");
   }
 
   isBoardFull() {
-    for(var row = 0; row < 3; row ++) {
-      for(var col = 0; col < 3; col ++) { 
-        if(this.matrix[row][col] === "-") {
+    for (var row = 0; row < 3; row++) {
+      for (var col = 0; col < 3; col++) {
+        if (this.matrix[row][col] === "-") {
           console.log("Is not full");
           return false;
         }
-      }  
+      }
     }
     console.log("Is full");
     return true;
   }
 
   makeMove(str) {
-    if(this.isBoardFull()) {
+    if (this.isBoardFull()) {
       throw "Error Board is Full";
     }
-    for(var row = 0; row < 3; row ++) {
-      for(var col = 0; col < 3; col ++) { 
-        if(this.matrix[row][col] === "-") {
+    for (var row = 0; row < 3; row++) {
+      for (var col = 0; col < 3; col++) {
+        if (this.matrix[row][col] === "-") {
           this.addToken(row, col, str);
           return true;
         }