Improved tasks 6-20

Author: javadev

src/main/js/g0001_0100/s0006_zigzag_conversion/solution.js

@@ -5,34 +5,34 @@
  * @param {number} numRows
  * @return {string}
  */
-var convert = function(s, numRows) {
-    const sLen = s.length;
+var convert = function (s, numRows) {
+    const sLen = s.length
     if (numRows === 1) {
-        return s;
+        return s
     }
-    const maxDist = numRows * 2 - 2;
-    let result = "";
+    const maxDist = numRows * 2 - 2
+    let result = ''
 
     for (let i = 0; i < numRows; i++) {
-        let index = i;
+        let index = i
         if (i === 0 || i === numRows - 1) {
             while (index < sLen) {
-                result += s[index];
-                index += maxDist;
+                result += s[index]
+                index += maxDist
             }
         } else {
             while (index < sLen) {
-                result += s[index];
-                index += maxDist - i * 2;
+                result += s[index]
+                index += maxDist - i * 2
                 if (index >= sLen) {
-                    break;
+                    break
                 }
-                result += s[index];
-                index += i * 2;
+                result += s[index]
+                index += i * 2
             }
         }
     }
-    return result;
+    return result
 }
 
 export { convert }

src/main/js/g0001_0100/s0007_reverse_integer/solution.js

@@ -6,19 +6,19 @@
  * @return {number}
  */
 var reverse = function (x) {
-    let r = x;
+    let r = x
     if (r < 0) {
         r = r.toString().split('')
         let a = r.shift()
         r.reverse()
         r.unshift('-')
 
         if (Number(r.join('')) > -2147483647) {
-            return Number(r.join(''));
+            return Number(r.join(''))
         }
     }
     let reverseN = Number(r.toString().split('').reverse().join(''))
     return reverseN < 2147483647 ? reverseN : 0
-};
+}
 
 export { reverse }

src/main/js/g0001_0100/s0008_string_to_integer_atoi/solution.js

@@ -4,48 +4,48 @@
  * @param {string} s
  * @return {number}
  */
-var myAtoi = function(str) {
+var myAtoi = function (str) {
     if (str == null || str.length === 0) {
-        return 0;
+        return 0
     }
 
-    let i = 0;
-    let negativeSign = false;
-    const MAX_INT = 2147483647; // Equivalent to Integer.MAX_VALUE
-    const MIN_INT = -2147483648; // Equivalent to Integer.MIN_VALUE
+    let i = 0
+    let negativeSign = false
+    const MAX_INT = 2147483647 // Equivalent to Integer.MAX_VALUE
+    const MIN_INT = -2147483648 // Equivalent to Integer.MIN_VALUE
 
     // Skip leading whitespaces
     while (i < str.length && str[i] === ' ') {
-        i++;
+        i++
     }
 
     if (i === str.length) {
-        return 0;
+        return 0
     }
 
     // Check for optional '+' or '-' sign
     if (str[i] === '+') {
-        i++;
+        i++
     } else if (str[i] === '-') {
-        i++;
-        negativeSign = true;
+        i++
+        negativeSign = true
     }
 
-    let num = 0;
+    let num = 0
 
     while (i < str.length && str[i] >= '0' && str[i] <= '9') {
-        const digit = str[i].charCodeAt(0) - '0'.charCodeAt(0);
-        
+        const digit = str[i].charCodeAt(0) - '0'.charCodeAt(0)
+
         // Check for overflow or underflow
         if (num > Math.floor(MAX_INT / 10) || (num === Math.floor(MAX_INT / 10) && digit > 7)) {
-            return negativeSign ? MIN_INT : MAX_INT;
+            return negativeSign ? MIN_INT : MAX_INT
         }
 
-        num = num * 10 + digit;
-        i++;
+        num = num * 10 + digit
+        i++
     }
 
-    return negativeSign ? -num : num;
-};
+    return negativeSign ? -num : num
+}
 
 export { myAtoi }

src/main/js/g0001_0100/s0009_palindrome_number/solution.js

@@ -6,18 +6,18 @@
  */
 var isPalindrome = function (x) {
     if (x < 0) {
-        return false;
+        return false
     }
 
-    let rev = 0;
-    let localX = x;
+    let rev = 0
+    let localX = x
 
     while (localX > 0) {
-        rev = rev * 10 + (localX % 10);
-        localX = Math.floor(localX / 10);
+        rev = rev * 10 + (localX % 10)
+        localX = Math.floor(localX / 10)
     }
 
-    return rev === x;
-};
+    return rev === x
+}
 
 export { isPalindrome }

src/main/js/g0001_0100/s0010_regular_expression_matching/solution.js

@@ -7,31 +7,31 @@
  * @return {boolean}
  */
 var isMatch = function (s, p) {
-    const cache = Array.from({ length: s.length + 1 }, () => Array(p.length + 1).fill(null));
+    const cache = Array.from({ length: s.length + 1 }, () => Array(p.length + 1).fill(null))
 
     function helper(i, j) {
         if (j === p.length) {
-            return i === s.length;
+            return i === s.length
         }
 
         if (cache[i][j] !== null) {
-            return cache[i][j];
+            return cache[i][j]
         }
 
-        const firstMatch = i < s.length && (s[i] === p[j] || p[j] === '.');
+        const firstMatch = i < s.length && (s[i] === p[j] || p[j] === '.')
 
-        let result;
+        let result
         if (j + 1 < p.length && p[j + 1] === '*') {
-            result = (firstMatch && helper(i + 1, j)) || helper(i, j + 2);
+            result = (firstMatch && helper(i + 1, j)) || helper(i, j + 2)
         } else {
-            result = firstMatch && helper(i + 1, j + 1);
+            result = firstMatch && helper(i + 1, j + 1)
         }
 
-        cache[i][j] = result;
-        return result;
+        cache[i][j] = result
+        return result
     }
 
-    return helper(0, 0);
-};
+    return helper(0, 0)
+}
 
 export { isMatch }

src/main/js/g0001_0100/s0011_container_with_most_water/solution.js

@@ -7,19 +7,19 @@
  * @return {number}
  */
 var maxArea = function (height) {
-    let maxArea = -1;
-    let left = 0;
-    let right = height.length - 1;
+    let maxArea = -1
+    let left = 0
+    let right = height.length - 1
     while (left < right) {
         if (height[left] < height[right]) {
-            maxArea = Math.max(maxArea, height[left] * (right - left));
-            left++;
+            maxArea = Math.max(maxArea, height[left] * (right - left))
+            left++
         } else {
-            maxArea = Math.max(maxArea, height[right] * (right - left));
-            right--;
+            maxArea = Math.max(maxArea, height[right] * (right - left))
+            right--
         }
     }
-    return maxArea;
-};
+    return maxArea
+}
 
 export { maxArea }

src/main/js/g0001_0100/s0015_3sum/solution.js

@@ -7,43 +7,43 @@
  * @return {number[][]}
  */
 var threeSum = function (nums) {
-    nums.sort((a, b) => a - b);
-    const len = nums.length;
-    const result = [];
+    nums.sort((a, b) => a - b)
+    const len = nums.length
+    const result = []
 
     for (let i = 0; i < len - 2; i++) {
-        let l = i + 1;
-        let r = len - 1;
+        let l = i + 1
+        let r = len - 1
 
         while (r > l) {
-            const sum = nums[i] + nums[l] + nums[r];
+            const sum = nums[i] + nums[l] + nums[r]
 
             if (sum < 0) {
-                l++;
+                l++
             } else if (sum > 0) {
-                r--;
+                r--
             } else {
-                result.push([nums[i], nums[l], nums[r]]);
+                result.push([nums[i], nums[l], nums[r]])
 
                 while (l < r && nums[l + 1] === nums[l]) {
-                    l++;
+                    l++
                 }
 
                 while (r > l && nums[r - 1] === nums[r]) {
-                    r--;
+                    r--
                 }
 
-                l++;
-                r--;
+                l++
+                r--
             }
         }
 
         while (i < len - 1 && nums[i + 1] === nums[i]) {
-            i++;
+            i++
         }
     }
 
-    return result;
-};
+    return result
+}
 
 export { threeSum }

src/main/js/g0001_0100/s0017_letter_combinations_of_a_phone_number/solution.js

@@ -8,33 +8,33 @@
  */
 var letterCombinations = function (digits) {
     if (digits.length === 0) {
-        return [];
+        return []
     }
 
-    const letters = ["", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"];
-    const result = [];
-    const current = [];
+    const letters = ['', '', 'abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
+    const result = []
+    const current = []
 
     function findCombinations(index) {
         if (current.length === digits.length) {
-            result.push(current.join(""));
-            return;
+            result.push(current.join(''))
+            return
         }
 
         for (let i = index; i < digits.length; i++) {
-            const digit = parseInt(digits[i]);
-            const letterGroup = letters[digit];
+            const digit = parseInt(digits[i])
+            const letterGroup = letters[digit]
 
             for (const char of letterGroup) {
-                current.push(char);
-                findCombinations(i + 1);
-                current.pop();
+                current.push(char)
+                findCombinations(i + 1)
+                current.pop()
             }
         }
     }
 
-    findCombinations(0);
-    return result;
-};
+    findCombinations(0)
+    return result
+}
 
 export { letterCombinations }

src/main/js/g0001_0100/s0019_remove_nth_node_from_end_of_list/solution.js

@@ -2,7 +2,7 @@
 // #Algorithm_I_Day_5_Two_Pointers #Level_2_Day_3_Linked_List #Big_O_Time_O(L)_Space_O(L)
 // #2024_12_03_Time_0_ms_(100.00%)_Space_51.2_MB_(27.67%)
 
-import { ListNode } from "../../com_github_leetcode/listnode";
+import { ListNode } from '../../com_github_leetcode/listnode'
 
 /**
  * Definition for singly-linked list.
@@ -17,22 +17,22 @@ import { ListNode } from "../../com_github_leetcode/listnode";
  * @return {ListNode}
  */
 var removeNthFromEnd = function (head, n) {
-    let nth = n;
+    let nth = n
 
     function removeNth(node) {
         if (node.next === null) {
-            return;
+            return
         }
-        removeNth(node.next);
-        nth--;
+        removeNth(node.next)
+        nth--
         if (nth === 0) {
-            node.next = node.next.next;
+            node.next = node.next.next
         }
     }
 
-    const dummy = new ListNode(0, head);
-    removeNth(dummy);
-    return dummy.next;
-};
+    const dummy = new ListNode(0, head)
+    removeNth(dummy)
+    return dummy.next
+}
 
 export { removeNthFromEnd }