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;
 };