Improved 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()
         }
     }
 

src/main/js/g0001_0100/s0053_maximum_subarray/solution.js

@@ -12,11 +12,9 @@ var maxSubArray = function(nums) {
     let sum = 0
 
     for (const num of nums) {
-        // Calculate subarray sum
         sum += num
         maxi = Math.max(sum, maxi)
         if (sum < 0) {
-            // Reset sum if it's negative
             sum = 0
         }
     }

src/main/js/g0001_0100/s0056_merge_intervals/solution.js

@@ -7,7 +7,6 @@
  * @return {number[][]}
  */
 var merge = function(intervals) {
-    // Sort intervals based on the starting points
     intervals.sort((a, b) => a[0] - b[0])
 
     const result = []
@@ -16,10 +15,8 @@ var merge = function(intervals) {
 
     for (const next of intervals) {
         if (current[1] >= next[0]) {
-            // Merge intervals
             current[1] = Math.max(current[1], next[1])
         } else {
-            // Move to the next interval
             current = next;
             result.push(current)
         }

src/main/js/g0001_0100/s0062_unique_paths/solution.js

@@ -9,25 +9,21 @@
  * @return {number}
  */
 var uniquePaths = function(m, n) {
-    // Initialize a 2D array with all values set to 0
     const dp = Array.from({ length: m }, () => Array(n).fill(0))
 
-    // Fill the first row and first column with 1
     for (let i = 0; i < m; i++) {
         dp[i][0] = 1
     }
     for (let j = 0; j < n; j++) {
         dp[0][j] = 1
     }
 
-    // Fill the rest of the dp table
     for (let i = 1; i < m; i++) {
         for (let j = 1; j < n; j++) {
             dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
         }
     }
 
-    // The answer is in the bottom-right corner
     return dp[m - 1][n - 1]
 };
 

src/main/js/g0001_0100/s0064_minimum_path_sum/solution.js

@@ -10,29 +10,24 @@ var minPathSum = function(grid) {
     const rows = grid.length
     const cols = grid[0].length
 
-    // Handle the special case where grid has only one cell
     if (rows === 1 && cols === 1) {
         return grid[0][0]
     }
 
-    // Create a 2D array for dynamic programming
     const dm = Array.from({ length: rows }, () => Array(cols).fill(0))
 
-    // Initialize the last column
     let s = 0
     for (let r = rows - 1; r >= 0; r--) {
         dm[r][cols - 1] = grid[r][cols - 1] + s
         s += grid[r][cols - 1]
     }
 
-    // Initialize the last row
     s = 0
     for (let c = cols - 1; c >= 0; c--) {
         dm[rows - 1][c] = grid[rows - 1][c] + s
         s += grid[rows - 1][c]
     }
 
-    // Recursive helper function
     const recur = (r, c) => {
         if (
             dm[r][c] === 0 &&
@@ -49,7 +44,6 @@ var minPathSum = function(grid) {
         return dm[r][c]
     }
 
-    // Start recursion from the top-left corner
     return recur(0, 0)
 };
 

src/main/js/g0001_0100/s0070_climbing_stairs/solution.js

@@ -12,19 +12,15 @@ var climbStairs = function(n) {
         return n
     }
 
-    // Create a cache (DP array) to store results
     const cache = new Array(n)
 
-    // Initialize base cases
     cache[0] = 1
     cache[1] = 2
 
-    // Fill the cache using the recurrence relation
     for (let i = 2; i < n; i++) {
         cache[i] = cache[i - 1] + cache[i - 2]
     }
 
-    // Return the result for the nth step
     return cache[n - 1]
 };
 

src/main/js/g0001_0100/s0072_edit_distance/solution.js

@@ -12,18 +12,15 @@ var minDistance = function(w1, w2) {
     const n1 = w1.length
     const n2 = w2.length
 
-    // Ensure the longer word is always w1
     if (n2 > n1) {
         return minDistance(w2, w1)
     }
 
-    // Initialize the dp array
     const dp = new Array(n2 + 1).fill(0)
     for (let j = 0; j <= n2; j++) {
         dp[j] = j
     }
 
-    // Compute minimum distance
     for (let i = 1; i <= n1; i++) {
         let pre = dp[0]
         dp[0] = i