Reformat problems

Author: ignacio-chiazzo

LeetcodeProblems/Add_Two_Numbers.js

@@ -22,7 +22,7 @@ Explanation: 342 + 465 = 807.
  * }
  */
 
-var ListNode = require('../utilsClasses/ListNode').ListNode;
+var ListNode = require('../UtilsClasses/ListNode').ListNode;
 
 /**
  * @param {ListNode} l1

LeetcodeProblems/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js

@@ -28,7 +28,7 @@ Return the following binary tree:
  * }
  */
 
-var TreeNode = require('../utilsClasses/TreeNode').TreeNode;
+var TreeNode = require('../UtilsClasses/TreeNode').TreeNode;
 
 /**
  * @param {number[]} preorder

LeetcodeProblems/Flood_Fill.js

@@ -6,7 +6,9 @@ An image is represented by a 2-D array of integers, each integer representing th
 
 Given a coordinate (sr, sc) representing the starting pixel (row and column) of the flood fill, and a pixel value newColor, "flood fill" the image.
 
-To perform a "flood fill", consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on. Replace the color of all of the aforementioned pixels with the newColor.
+To perform a "flood fill", consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, 
+plus any pixels connected 4-directionally to those pixels (also with the same color as the starting pixel), and so on. 
+Replace the color of all of the aforementioned pixels with the newColor.
 
 At the end, return the modified image.
 
@@ -25,34 +27,31 @@ Note:
 The length of image and image[0] will be in the range [1, 50].
 The given starting pixel will satisfy 0 <= sr < image.length and 0 <= sc < image[0].length.
 The value of each color in image[i][j] and newColor will be an integer in [0, 65535].
-
 */
 
 var floodFill = function(image, sr, sc, newColor) {
   var oldColor = image[sr][sc];
 
-  if(newColor == oldColor) {
-      return image;
-  }
+  if(newColor == oldColor)
+    return image;
 
   image[sr][sc] = newColor;
 
-  if(sr > 0 && image[sr - 1][sc] == oldColor) {
-      floodFill(image, sr - 1, sc, newColor);    //Left
-  }
-  if(sc > 0 && image[sr][sc - 1] == oldColor) {
-      floodFill(image, sr, sc - 1, newColor);   //Up
-  }
-  if(sr < image.length - 1 && image[sr + 1][sc] == oldColor) {
-      floodFill(image, sr + 1, sc, newColor);    //Down
-  }
-  if(sc < image[0].length - 1 && image[sr][sc + 1] == oldColor) {
-      floodFill(image, sr, sc + 1, newColor);    // Right
-  }
+  if(sr > 0 && image[sr - 1][sc] == oldColor)
+    floodFill(image, sr - 1, sc, newColor); //Left
+  
+  if(sc > 0 && image[sr][sc - 1] == oldColor)
+    floodFill(image, sr, sc - 1, newColor); //Up
+
+  if(sr < image.length - 1 && image[sr + 1][sc] == oldColor)
+    floodFill(image, sr + 1, sc, newColor); //Down
+      
+  if(sc < image[0].length - 1 && image[sr][sc + 1] == oldColor)
+    floodFill(image, sr, sc + 1, newColor); // Right
+      
   return image;
 };
 
-
 function main() {
   console.log(floodFill([[1,1,1],[1,1,0],[1,0,1]], 1, 1, 2))
 }

LeetcodeProblems/Generate_Parentheses.js renamed to LeetcodeProblems/Generate_Parenthesis.js

@@ -16,8 +16,9 @@ For example, given n = 3, a solution set is:
 */
 
 // ************************************************  Approach1  ************************************************
-var generateParenthesesApproach1 = function(n) {
-  if(n === 0) { return [] };
+var generateParenthesisApproach1 = function(n) {
+  if(n === 0) 
+    return [];
 
   var str = "(".repeat(n);
     sol = [];
@@ -26,12 +27,6 @@ var generateParenthesesApproach1 = function(n) {
   return sol;
 };
 
-/* 
-@param {string} str contains the string generated.
-@param {number} position Current position of the string where new parenthesis would be added.
-@param {string} leftParenthesis Amount for parenthesis left to be added.
-@param {[string]} sol array that contains the solution found so far.
-*/
 var genParAux = function(str, position, leftParentheses, sol) {
   if(position === str.length) {
     var ret = str + ")".repeat(leftParentheses);
@@ -40,7 +35,8 @@ var genParAux = function(str, position, leftParentheses, sol) {
   }
 
   genParAux(str, position + 1, leftParentheses + 1, sol); // Don't insert anything
-  if(leftParentheses === 0) { return; }
+  if(leftParentheses === 0) 
+    return;
 
   for(var i = 1; i <= leftParentheses; i++) {
     var parString = ")".repeat(i);
@@ -50,8 +46,9 @@ var genParAux = function(str, position, leftParentheses, sol) {
 }
 
 // ************************************************  Approach2  ************************************************
-var generateParenthesesApproach2 = function(n) {
-  if(n === 0) { return [] };
+var generateParenthesisApproach2 = function(n) {
+  if(n === 0) 
+    return [];
 
   var sol = [];
   genParAuxApproach2("", 0, 0, 0, n * 2, sol)
@@ -60,16 +57,17 @@ var generateParenthesesApproach2 = function(n) {
 
 var genParAuxApproach2 = function(str, leftPar, rightPar, index, totalCharCount, sol) {
   if(index === totalCharCount) {
-    if(rightPar === leftPar) {
+    if(rightPar === leftPar)
       sol.push(str);
-    }
+    
     return;
   }
 
   var strLeft = insertAt(str, index, "(");
   genParAuxApproach2(strLeft, leftPar + 1, rightPar, index + 1, totalCharCount, sol);
 
-  if(rightPar === leftPar) { return; }
+  if(rightPar === leftPar) 
+    return;
 
   var strRight = insertAt(str, index, ")");
   genParAuxApproach2(strRight, leftPar, rightPar + 1, index + 1, totalCharCount, sol);
@@ -82,14 +80,14 @@ var insertAt = function(str, position, value) {
 function main() {
   console.log("Approach 1");
   [0, 1, 2, 3].forEach(function(elem) {
-    console.log(`${elem}: ${generateParenthesesApproach2(elem)}`);
+    console.log(`${elem}: ${generateParenthesisApproach2(elem)}`);
   })
 
   console.log("-------------");
 
   console.log("Approach 2");
   [0, 1, 2, 3].forEach(function(elem) {
-    console.log(`${elem}: ${generateParenthesesApproach2(elem)}`);
+    console.log(`${elem}: ${generateParenthesisApproach2(elem)}`);
   })
 }
 

LeetcodeProblems/Group_Anagrams.js

@@ -23,27 +23,26 @@ var groupAnagrams = function(strs) {
   var ret = [];
   var hashMap = {};
   for(var i = 0; i < strs.length; i++) {
-      const elem = strs[i];
-      const elemSorted = sortString(strs[i]);
-      
-      if(hashMap[elemSorted]) {
-          hashMap[elemSorted].push(elem);
-      } else {
-          hashMap[elemSorted] = [elem];
-      }
+    const elem = strs[i];
+    const elemSorted = sortString(strs[i]);
+    
+    if(hashMap[elemSorted]) {
+      hashMap[elemSorted].push(elem);
+    } else {
+      hashMap[elemSorted] = [elem];
+    }
   }
 
-  for(key in hashMap) {
+  for(key in hashMap)
     ret.push(hashMap[key]);
-  }
+  
 
   return ret;
 };
 
 var sortString = function(str) {
-  if(str.length === 0) {
-      return str;
-  }
+  if(str.length === 0)
+    return str;
 
   return str.split("").sort().join("");
 }

LeetcodeProblems/Linked_List_Cycle_II.js

@@ -10,7 +10,7 @@ Follow up:
 Can you solve it without using extra space?
 */
 
-var ListNode = require('../utilsClasses/ListNode').ListNode;
+var ListNode = require('../UtilsClasses/ListNode').ListNode;
 
 // Optimal solution
 /**
@@ -42,19 +42,19 @@ var detectCycle = function(head) {
 
 // Naiver solution using a Set
 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)) {
-            return iter;
-        }
-        setNodes.add(iter);
-        iter = iter.next
-    }
+  if(head === null || head.next === null) {
     return null;
+  }
+  var setNodes = new Set();
+  var iter = head;
+  while(iter !== null) {
+    if(setNodes.has(iter)) {
+      return iter;
+    }
+    setNodes.add(iter);
+    iter = iter.next
+  }
+  return null;
 };
 
 var main = function() {

LeetcodeProblems/Longest_Consecutive_Sequence.js

@@ -30,6 +30,7 @@ var longestConsecutive = function(nums) {
     var number = nums[i];
     if(setNums.has(number)) {
       setNums.delete(number);
+      
       var prevNum = number - 1;
       while(setNums.has(prevNum)){
         currentCons++;

LeetcodeProblems/Longest_Palindromic_Substring.js

@@ -32,8 +32,7 @@ var longestPalindrome = function(str) {
       currentPalStart = i - 1;
       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;

LeetcodeProblems/Lowest_Common_Ancestor_of_a_Binary_Tree.js

@@ -4,7 +4,9 @@ https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
 
 Given a binary tree, find the lowest common ancestor (LCA) of two given nodes in the tree.
 
-According to the definition of LCA on Wikipedia: “The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants (where we allow a node to be a descendant of itself).”
+According to the definition of LCA on Wikipedia: 
+“The lowest common ancestor is defined between two nodes p and q as the lowest node in T that has both p and q as descendants 
+(where we allow a node to be a descendant of itself).”
 
 Given the following binary tree:  root = [3,5,1,6,2,0,8,null,null,7,4]
 
@@ -32,6 +34,8 @@ 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)
@@ -48,40 +52,78 @@ var lowestCommonAncestor = function(root, p, q) {
   return left !== null ? left : right;
 };
 
-
 // Solution 2
-var lowestCommonAncestor1 = function(root, p, q) {
-  const pathToP = pathTo(root, p.val);
-  const pathToQ = pathTo(root, q.val);
-  
-  if(pathToP === null || pathToQ === null) 
-      return null;
-  
-  if(pathToP.length === 1)
-      return pathToP[0];
-  if(pathToQ.length === 1)
-      return pathToQ[0];
+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;
 
   var iter = 0;
-  while(pathToP[iter + 1] === pathToQ[iter + 1])
-    iter++
+  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;  
+    }
+    iter++;
+  }
 
-  return pathToP[iter];
+  return root;
 };
 
-var pathTo = function(root, a) {
+var pathTo = function(root, value) {
   if(root === null)
-    return null;
-  if(root.val === a)
-    return [root.val];
+    return [];
+    
+  var list = [root.val];
+  if(root.val === value)
+    return list;
 
-  const left = pathTo(root.left, a);
-  if (left !== null)
-    return [root.val].concat(left);
+  const left = pathTo(root.left, value);
+  if (left.length > 0)
+    return list.concat(left);
 
-  const right = pathTo(root.right, a);
-  if(right !== null)
-    return [root.val].concat(right);
+  const right = pathTo(root.right, value);    
+  if(right.length > 0)
+    return list.concat(right);
 
-  return null;
+  return [];
 }
+
+
+var main = function() {
+  var root = new TreeNode(3);
+  
+  var right = new TreeNode(1);
+  right.left = new TreeNode(0);
+  right.right = new TreeNode(8);
+  root.right = right;
+
+  var left = new TreeNode(5);
+  left.left = new TreeNode(6);
+  
+  var tempRight = new TreeNode(2);
+  tempRight.left = new TreeNode(7);
+  tempRight.right = new TreeNode(4);
+  left.right = tempRight;
+
+  root.left = left;
+
+  //         _______3______
+  //        /              \
+  //     ___5__          ___1__
+  //    /      \        /      \
+  //    6      _2       0       8
+  //          /  \
+  //          7   4
+
+  console.log(lowestCommonAncestor(root, left, tempRight.right));
+  console.log(lowestCommonAncestor(root, left, right));
+
+  console.log(lowestCommonAncestor2(root, left, tempRight.right));
+  console.log(lowestCommonAncestor2(root, left, right));
+}
+
+module.exports.main = main;