Improved js tasks

Author: javadev

src/main/js/g0001_0100/s0003_longest_substring_without_repeating_characters/solution.js

@@ -8,20 +8,18 @@
  * @return {number}
  */
 var lengthOfLongestSubstring = function (s) {
-    const lastIndices = new Array(256).fill(-1) // Array to store last indices of characters
-    let maxLen = 0 // Tracks maximum length of substring
-    let curLen = 0 // Current substring length
-    let start = 0 // Start index of the current substring
+    const lastIndices = new Array(256).fill(-1)
+    let maxLen = 0
+    let curLen = 0
+    let start = 0
 
     for (let i = 0; i < s.length; i++) {
-        const cur = s.charCodeAt(i) // Get ASCII code of the current character
+        const cur = s.charCodeAt(i)
 
         if (lastIndices[cur] < start) {
-            // If the character hasn't been seen in the current substring
             lastIndices[cur] = i
             curLen++
         } else {
-            // If the character was seen, update the start position
             const lastIndex = lastIndices[cur]
             start = lastIndex + 1
             curLen = i - start + 1

src/main/js/g0001_0100/s0005_longest_palindromic_substring/solution.js

@@ -8,42 +8,36 @@
  * @return {string}
  */
 var longestPalindrome = function (s) {
-    // Create the transformed string with '#' characters
     const newStr = new Array(s.length * 2 + 1).fill('#')
     for (let i = 0; i < s.length; i++) {
         newStr[2 * i + 1] = s[i]
     }
 
-    const dp = new Array(newStr.length).fill(0) // Array to store radius of palindromes
-    let friendCenter = 0 // Center of the current known palindrome
-    let friendRadius = 0 // Radius of the current known palindrome
-    let lpsCenter = 0 // Center of the longest palindrome
-    let lpsRadius = 0 // Radius of the longest palindrome
+    const dp = new Array(newStr.length).fill(0)
+    let friendCenter = 0
+    let friendRadius = 0
+    let lpsCenter = 0
+    let lpsRadius = 0
 
     for (let i = 0; i < newStr.length; i++) {
-        // Calculate initial radius
         dp[i] =
             friendCenter + friendRadius > i ? Math.min(dp[2 * friendCenter - i], friendCenter + friendRadius - i) : 1
 
-        // Expand the palindrome around the current center
         while (i + dp[i] < newStr.length && i - dp[i] >= 0 && newStr[i + dp[i]] === newStr[i - dp[i]]) {
             dp[i]++
         }
 
-        // Update the friend palindrome if needed
         if (friendCenter + friendRadius < i + dp[i]) {
             friendCenter = i
             friendRadius = dp[i]
         }
 
-        // Update the longest palindrome if needed
         if (lpsRadius < dp[i]) {
             lpsCenter = i
             lpsRadius = dp[i]
         }
     }
 
-    // Extract the longest palindrome substring
     const start = Math.floor((lpsCenter - lpsRadius + 1) / 2)
     const end = Math.floor((lpsCenter + lpsRadius - 1) / 2)
     return s.substring(start, end)

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

@@ -11,10 +11,9 @@ var myAtoi = function (str) {
 
     let i = 0
     let negativeSign = false
-    const MAX_INT = 2147483647 // Equivalent to Integer.MAX_VALUE
-    const MIN_INT = -2147483648 // Equivalent to Integer.MIN_VALUE
+    const MAX_INT = 2147483647
+    const MIN_INT = -2147483648
 
-    // Skip leading whitespaces
     while (i < str.length && str[i] === ' ') {
         i++
     }
@@ -23,7 +22,6 @@ var myAtoi = function (str) {
         return 0
     }
 
-    // Check for optional '+' or '-' sign
     if (str[i] === '+') {
         i++
     } else if (str[i] === '-') {
@@ -36,7 +34,6 @@ var myAtoi = function (str) {
     while (i < str.length && str[i] >= '0' && str[i] <= '9') {
         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
         }

src/main/js/g0001_0100/s0025_reverse_nodes_in_k_group/solution.js

@@ -22,7 +22,6 @@ const reverseKGroup = function (head, k) {
     let len = head
     let count = 0
 
-    // Check if there are at least k nodes to reverse
     while (count < k) {
         if (len === null) {
             return head
@@ -31,7 +30,6 @@ const reverseKGroup = function (head, k) {
         count++
     }
 
-    // Reverse the first k nodes
     let current = head
     let next = null
     let prev = null
@@ -45,7 +43,6 @@ const reverseKGroup = function (head, k) {
         i++
     }
 
-    // Recursively reverse the next groups and connect the lists
     head.next = reverseKGroup(next, k)
 
     return prev

src/main/js/g0001_0100/s0031_next_permutation/solution.js

@@ -12,21 +12,18 @@ var nextPermutation = function(nums) {
 
     let i = nums.length - 2
 
-    // Find the first index `i` where nums[i] < nums[i + 1]
     while (i >= 0 && nums[i] >= nums[i + 1]) {
         i--
     }
 
     if (i >= 0) {
-        // Find the smallest number larger than nums[i] to swap with
         let j = nums.length - 1
         while (nums[j] <= nums[i]) {
             j--
         }
         swap(nums, i, j)
     }
 
-    // Reverse the portion of the array from index `i + 1` to the end
     reverse(nums, i + 1, nums.length - 1)
 };
 

src/main/js/g0001_0100/s0033_search_in_rotated_sorted_array/solution.js

@@ -17,7 +17,6 @@ var search = function(nums, target) {
             return mid
         }
         if (nums[lo] <= nums[mid]) {
-            // Target is in the sorted left half
             if (nums[lo] <= target && target <= nums[mid]) {
                 hi = mid - 1
             } else {

src/main/js/g0001_0100/s0039_combination_sum/solution.js

@@ -14,15 +14,15 @@ var combinationSum = function(candidates, target) {
     const combinationSumRec = (n, candidates, target, subList, ans) => {
         if (target === 0 || n === 0) {
             if (target === 0) {
-                ans.push([...subList]) // Create a copy of subList
+                ans.push([...subList])
             }
             return
         }
 
         if (target - candidates[n - 1] >= 0) {
             subList.push(candidates[n - 1])
             combinationSumRec(n, candidates, target - candidates[n - 1], subList, ans)
-            subList.pop() // Backtracking step
+            subList.pop()
         }
 
         combinationSumRec(n - 1, candidates, target, subList, ans)

src/main/js/g0001_0100/s0041_first_missing_positive/solution.js

@@ -12,7 +12,6 @@ var firstMissingPositive = function(nums) {
             nums[i] <= nums.length &&
             nums[nums[i] - 1] !== nums[i]
         ) {
-            // Swap nums[i] with nums[nums[i] - 1]
             let temp = nums[nums[i] - 1]
             nums[nums[i] - 1] = nums[i]
             nums[i] = temp

src/main/js/g0001_0100/s0042_trapping_rain_water/solution.js

@@ -16,20 +16,13 @@ var trap = function(height) {
         let lVal = height[l]
         let rVal = height[r]
 
-        // Determine the lower wall
         if (lVal < rVal) {
-            // Update the lower wall based on the left pointer
             lowerWall = Math.max(lVal, lowerWall)
-            // Add water trapped at the current position
             res += lowerWall - lVal
-            // Move the left pointer
             l++
         } else {
-            // Update the lower wall based on the right pointer
             lowerWall = Math.max(rVal, lowerWall)
-            // Add water trapped at the current position
             res += lowerWall - rVal
-            // Move the right pointer
             r--
         }
     }

src/main/js/g0001_0100/s0046_permutations/solution.js

@@ -17,7 +17,7 @@ var permute = function(nums) {
 
     const permuteRecur = (nums, finalResult, currResult, used) => {
         if (currResult.length === nums.length) {
-            finalResult.push([...currResult]) // Create a copy of currResult
+            finalResult.push([...currResult])
             return
         }
         for (let i = 0; i < nums.length; i++) {
@@ -28,7 +28,7 @@ var permute = function(nums) {
             used[i] = true
             permuteRecur(nums, finalResult, currResult, used)
             used[i] = false
-            currResult.pop() // Backtrack
+            currResult.pop()
         }
     }