refact: review

Author: hongbo-miao

JavaScript/0008. String to Integer (atoi).js

@@ -41,7 +41,7 @@
  * @param {string} str
  * @return {number}
  */
-function myAtoi1(str) {
+const myAtoi1 = (str) => {
   // (abc)  capture group
   //
   // [abc]  any of a, b, or c
@@ -66,9 +66,9 @@ function myAtoi1(str) {
   if (n > max) return max;
 
   return n;
-}
+};
 
-function myAtoi(str) {
+const myAtoi = (str) => {
   const s = str.replace(/\s*/, '').match(/^[-+\d]*/);
   const n = parseInt(s);
 
@@ -82,4 +82,4 @@ function myAtoi(str) {
   }
 
   return 0;
-}
+};

JavaScript/0014. Longest Common Prefix.js

@@ -33,7 +33,7 @@ function longestCommonPrefix1(strs) {
   const str0 = strs[0];
   for (let i = 0; i < str0.length; i++) {
     const c = str0[i];
-    for (let s of strs) {
+    for (const s of strs) {
       if (s[i] !== c) return str0.slice(0, i);
     }
   }
@@ -56,7 +56,7 @@ function longestCommonPrefix(strs) {
   }
 
   let minLen = Infinity;
-  for (let s of strs) {
+  for (const s of strs) {
     minLen = Math.min(minLen, s.length);
   }
 

JavaScript/0017. Letter Combinations of a Phone Number.js

@@ -21,7 +21,7 @@
 //   M is the number of digits in the input that maps to 4 letters (e.g. 7, 9), and N+M is the total number digits in the input.
 //
 // Space O(3^N * 4^M) since one has to keep O(3^N * 4^M) solutions.
-function letterCombinations(digits) {
+const letterCombinations = (digits) => {
   if (digits == null || digits.length === 0) return [];
 
   const map = {
@@ -36,17 +36,17 @@ function letterCombinations(digits) {
   };
 
   const res = [];
-  function go(i, s) {
+  const go = (i, s) => {
     if (i === digits.length) {
       res.push(s);
       return;
     }
 
-    for (let c of map[digits[i]]) {
+    for (const c of map[digits[i]]) {
       go(i + 1, s + c);
     }
-  }
+  };
 
   go(0, '');
   return res;
-}
+};

JavaScript/0019. Remove Nth Node From End of List.js

@@ -26,7 +26,7 @@
 /** Two pointers slow and fast */
 // Time O(n)
 // Space O(1)
-function removeNthFromEnd(head, n) {
+const removeNthFromEnd = (head, n) => {
   const preHead = new ListNode(null); // for case n = 1, to remove the last node in the list to avoid slow.next is null in slow.next.next
   preHead.next = head;
 
@@ -44,4 +44,4 @@ function removeNthFromEnd(head, n) {
 
   slow.next = slow.next.next;
   return preHead.next;
-}
+};

JavaScript/0022. Generate Parentheses.js

@@ -20,10 +20,10 @@
 // Space O((2^2n) * n)
 //
 // We can generate all 2^2n sequences of '(' and ')' characters. Then, we will check if each one is valid.
-function generateParenthesis1(n) {
+const generateParenthesis1 = (n) => {
   let res = [];
 
-  function generate(arr) {
+  const generate = (arr) => {
     if (arr.length === 2 * n) {
       if (valid(arr)) {
         res.push(arr.join(''));
@@ -36,50 +36,50 @@ function generateParenthesis1(n) {
       generate(arr);
       arr.pop();
     }
-  }
+  };
 
-  function valid(arr) {
+  const valid = (arr) => {
     let bal = 0;
-    for (let c of arr) {
+    for (const c of arr) {
       if (c === '(') bal += 1;
       else bal -= 1;
       if (bal < 0) return false
     }
     return bal === 0;
-  }
+  };
 
   generate([]);
   return res;
-}
+};
 
 /** 2) Backtracking */
 // The complexity analysis rests on understanding how many elements there are in generateParenthesis(n). It turns out
 // this is the n-th Catalan number 1 / n+1 (2n n), which is bounded asymptotically by 4^n / (n * sqrt(n))
 // Time O(4^n / sqrt(n)). Each valid sequence has at most n steps during the backtracking procedure.
 // Space O(4^n / sqrt(n)). As described above, and using O(n) space to store the sequence.
 
-function generateParenthesis2(n) {
+const generateParenthesis2 = (n) => {
   const res = [];
 
-  function go(l, r, s) {
+  const go = (l, r, s) => {
     if (s.length === 2 * n) {
       res.push(s);
       return;
     }
 
     if (l < n) go(l + 1, r, s + '(');
     if (r < l) go(l, r + 1, s + ')');
-  }
+  };
 
   go(0, 0, '');
   return res;
-}
+};
 
 /** 3) Backtracking, similar to 2) */
-function generateParenthesis3(n) {
+const generateParenthesis3 = (n) => {
   const res = [];
 
-  function go(l, r, s) { // l: left remaining, r: right remaining
+  const go = (l, r, s) => { // l: left remaining, r: right remaining
     if (l > r) return; // Check valid by the number of '(' should be always >= ')'
 
     if (l === 0 && r === 0) {
@@ -89,11 +89,11 @@ function generateParenthesis3(n) {
 
     if (l > 0) go(l - 1, r, s + '(');
     if (r > 0) go(l, r - 1, s + ')');
-  }
+  };
 
   go(n, n, '');
   return res;
-}
+};
 
 /** 4) Closure number */
 // Time O(4^n / sqrt(n))
@@ -109,18 +109,18 @@ function generateParenthesis3(n) {
 //
 // For each closure number i, we know the starting and ending brackets must be at index 0 and 2*i + 1. Then, the
 // 2*i elements between must be a valid sequence, plus the rest of the elements must be a valid sequence.
-function generateParenthesis(n) {
+const generateParenthesis = (n) => {
   const res = [];
   if (n === 0) {
       res.push('');
   } else {
     for (let i = 0; i < n; i++) {
-      for (let l of generateParenthesis(i)) {
-        for (let r of generateParenthesis(n - 1 - i)) {
+      for (const l of generateParenthesis(i)) {
+        for (const r of generateParenthesis(n - 1 - i)) {
           res.push('(' + l + ')' + r);
         }
       }
     }
   }
   return res;
-}
+};

JavaScript/0028. Implement strStr().js

@@ -25,32 +25,31 @@
  */
 
 /** 1) Cheating */
-function strStr1(haystack, needle) {
+const strStr1 = (haystack, needle) => {
+  if (needle == null || needle === '') return 0;
   return haystack.indexOf(needle);
-}
+};
 
 /** 2) Brute force */
-function strStr2(haystack, needle) {
+const strStr2 = (haystack, needle) => {
+  if (needle == null || needle === '') return 0;
   for (let i = 0; i < haystack.length - needle.length + 1; i++) {
     if (haystack.substr(i, needle.length) === needle) return i;
   }
-
   return -1;
-}
+};
 
 /** 3) Same to 2) */
-function strStr(haystack, needle) {
+const strStr = (haystack, needle) => {
   if (needle == null || needle === '') return 0;
-
   for (let i = 0; i < haystack.length - needle.length + 1; i++) {
     for (let j = 0; j < needle.length; j++) {
       if (haystack[i + j] !== needle[j]) break;
       if (j === needle.length - 1) return i;
     }
   }
-
   return -1;
-}
+};
 
 /** 4) KMP */
 // https://www.zhihu.com/question/21923021

JavaScript/0029. Divide Two Integers.js

@@ -25,14 +25,14 @@
  */
 
 /** 1) Cheating */
-function divide1(dividend, divisor) {
+const divide1 = (dividend, divisor) => {
   if (dividend === -(2 ** 31) && divisor === -1) return 2 ** 31 - 1;
   return ~~(dividend / divisor);
-}
+};
 
 /** 2) */
 // https://leetcode.com/problems/divide-two-integers/discuss/13407/Detailed-Explained-8ms-C++-solution
-function divide(dividend, divisor) {
+const divide = (dividend, divisor) => {
   if (dividend === -(2 ** 31) && divisor === -1) return 2 ** 31 - 1;
 
   const sign = Math.sign(dividend) * Math.sign(divisor);
@@ -56,6 +56,5 @@ function divide(dividend, divisor) {
     res += multiple;
     dividend -= tmp;
   }
-
   return sign * res;
-}
+};

JavaScript/0038. Count and Say.js

@@ -27,15 +27,15 @@
  * @param {number} n
  * @return {string}
  */
-function countAndSay(n) {
+const countAndSay = (n) => {
   let res = '1';
   for (let i = 1; i < n; i++) {
     res = say(res);
   }
   return res;
-}
+};
 
-function say(s) {
+const say = (s) => {
   let res = '';
   let count = 0;
   let num = s[0];
@@ -49,6 +49,5 @@ function say(s) {
       num = s[i];
     }
   }
-
   return res + count + num;
-}
+};

JavaScript/0046. Permutations.js

@@ -27,10 +27,10 @@
 //   Let's do a rough estimation of the result: N! <= ∑(k = 1 to N) (N! / (N - k)!) = ∑(k = 1 to N) P(N, k) <= N * N!,
 //   i.e. the algorithm performs better than O(N * N!) and a bit slower than N!.
 // Space O(N!) since one has to keep N! solutions.
-function permute(nums) {
+const permute = (nums) => {
   const res = [];
 
-  function go(curr, rest) {
+  const go = (curr, rest) => {
     if (!rest.length) {
       res.push(curr);
       return;
@@ -43,8 +43,8 @@ function permute(nums) {
         [...rest.slice(0, i), ...rest.slice(i + 1)],
       );
     }
-  }
+  };
 
   go([], nums);
   return res;
-}
+};