Used const for JavaScript code.

gazeldx · gazeldx · commit 14b320304129 · 2024-11-29T20:18:52.000+08:00
diff --git a/problems/0053-maximum-subarray.md b/problems/0053-maximum-subarray.md
@@ -2,13 +2,36 @@
 LeetCode problem: [53. Maximum Subarray](https://leetcode.com/problems/maximum-subarray/)
 
 ## LeetCode problem description
-> Given an integer array nums, find the subarray with the largest sum, and return its sum.
+> Given an integer array `nums`, find the `subarray` with the largest sum, and return its sum.
 
 ```
 Example 1:
+
 Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
 Output: 6
+
 Explanation: The subarray [4,-1,2,1] has the largest sum 6.
+------------------------------------------------------------------------
+
+Example 2:
+
+Input: nums = [1]
+Output: 1
+
+Explanation: The subarray [1] has the largest sum 1.
+------------------------------------------------------------------------
+
+Example 3:
+
+Input: nums = [5,4,-1,7,8]
+Output: 23
+Explanation: The subarray [5,4,-1,7,8] has the largest sum 23.
+------------------------------------------------------------------------
+
+Constraints:
+
+1. 1 <= nums.length <= 10**5
+2. -10**4 <= nums[i] <= 10**4
 ```
 
 ## Thoughts
@@ -122,7 +145,7 @@ public class Solution {
 ## JavaScript
 ```javascript
 var maxSubArray = function(nums) {
-    let dp = [...nums]
+    const dp = [...nums]
 
     for (let i = 1; i < dp.length; i++) {
         dp[i] = Math.max(nums[i], dp[i - 1] + nums[i])
diff --git a/problems/0072-edit-distance.md b/problems/0072-edit-distance.md
@@ -11,23 +11,33 @@ You have the following three operations permitted on a word:
 
 ```
 Example 1:
+
 Input: word1 = "horse", word2 = "ros"
 Output: 3
+
 Explanation:
 horse -> rorse (replace 'h' with 'r')
 rorse -> rose (remove 'r')
 rose -> ros (remove 'e')
 -------------------------------------------------------
 
 Example 2:
+
 Input: word1 = "intention", word2 = "execution"
 Output: 5
+
 Explanation:
 intention -> inention (remove 't')
 inention -> enention (replace 'i' with 'e')
 enention -> exention (replace 'n' with 'x')
 exention -> exection (replace 'n' with 'c')
 exection -> execution (insert 'u')
+-------------------------------------------------------
+
+Constraints:
+
+1. 0 <= word1.length, word2.length <= 500
+2. `word1` and `word2` consist of lowercase English letters.
 ```
 
 ## Thoughts
@@ -226,7 +236,7 @@ public class Solution {
 ## JavaScript
 ```javascript
 var minDistance = function(word1, word2) {
-    let dp = Array(word1.length + 1).fill().map(
+    const dp = Array(word1.length + 1).fill().map(
         () => Array(word2.length + 1).fill(0)
     )
     dp.forEach((_, i) => { dp[i][0] = i })
diff --git a/problems/0392-is-subsequence.md b/problems/0392-is-subsequence.md
@@ -14,6 +14,11 @@ Output: true
 Example 2:
 Input: s = "axc", t = "ahbgdc"
 Output: false
+
+Constraints:
+1. 0 <= s.length <= 100
+2. 0 <= t.length <= 10**4
+3. `s` and `t` consist only of lowercase English letters.
 ```
 
 ## Thoughts
@@ -174,7 +179,7 @@ public class Solution {
 ## JavaScript
 ```javascript
 var isSubsequence = function(s, t) {
-    let dp = Array(s.length + 1).fill().map(
+    const dp = Array(s.length + 1).fill().map(
         () => Array(t.length + 1).fill(false)
     )
     dp[0].fill(true)
diff --git a/problems/0416-partition-equal-subset-sum.md b/problems/0416-partition-equal-subset-sum.md
@@ -2,7 +2,7 @@
 LeetCode problem: [416. Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum/)
 
 ## LeetCode problem description
-> Given an integer array nums, return true if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or false otherwise.
+> Given an integer array `nums`, return `true` if you can partition the array into two subsets such that the sum of the elements in both subsets is equal or `false` otherwise.
 
 ```
 Example 1:
@@ -90,12 +90,12 @@ These five steps are a pattern for solving `Dynamic Programming` problems.
    # 5  T T F F F T T F F F T  T # dp
    ```
     * After analyzing the sample `dp` grid, we can derive the `Recurrence Formula`:
-   ```python
-   dp[j] = dp[j] or dp[j - nums[i]]
+   ```cpp
+   dp[j] = dp[j] || dp[j - nums[i]]
    ```
 4. Determine the `dp` array's traversal order
     * `dp[j]` depends on `dp[j]` and `dp[j - nums[i]]`, so we should traverse the `dp` array from top to bottom, then **from right to left**.
-    * Please think if we can traverse the `dp` array from top to bottom, then `from left to right`? In the `Python` code comments, I will answer this question.
+    * Please think if we can traverse the `dp` array from top to bottom, then `from left to right`? In the `Python` solution's code comments, I will answer this question.
 5. Check the `dp` array's value
     * Print the `dp` to see if it is as expected.
 
@@ -108,15 +108,16 @@ These five steps are a pattern for solving `Dynamic Programming` problems.
 class Solution:
     def canPartition(self, nums: List[int]) -> bool:
         sum_ = sum(nums)
+
         if sum_ % 2 == 1:
             return False
-        
+
         dp = [False] * ((sum_ // 2) + 1)
         dp[0] = True
-        
+
         for num in nums:
-            # If traverse from left to right, the newly assigned value `dp[j - num]` will affect the subsequent `dp[j]`. 
-            # Then it would be wrong because each `num` can only be used once.
+            # If traversing from left to right, the newly assigned value `dp[j]` will act as `dp[j - num]` later,
+            # then the subsequent `dp[j]` will be affected. But each `num` can only be used once.
             for j in range(len(dp) - 1, 0, -1):
                 if j < num:
                     break
@@ -131,13 +132,14 @@ class Solution {
 public:
     bool canPartition(vector<int>& nums) {
         auto sum = reduce(nums.begin(), nums.end());
+
         if (sum % 2 == 1) {
             return false;
         }
-        
+
         auto dp = vector<bool>(sum / 2 + 1);
         dp[0] = true;
-        
+
         for (auto num : nums) {
             for (auto j = dp.size() - 1; j >= num; j--) {
                 dp[j] = dp[j] || dp[j - num];
@@ -154,13 +156,14 @@ public:
 class Solution {
     public boolean canPartition(int[] nums) {
         var sum = IntStream.of(nums).sum();
+        
         if (sum % 2 == 1) {
             return false;
         }
-        
+
         var dp = new boolean[sum / 2 + 1];
         dp[0] = true;
-        
+
         for (var num : nums) {
             for (var j = dp.length - 1; j >= num; j--) {
                 dp[j] = dp[j] || dp[j - num];
@@ -177,13 +180,14 @@ class Solution {
 public class Solution {
     public bool CanPartition(int[] nums) {
         var sum = nums.Sum();
+
         if (sum % 2 == 1) {
             return false;
         }
-        
+
         var dp = new bool[sum / 2 + 1];
         dp[0] = true;
-        
+
         foreach (var num in nums) {
             for (var j = dp.Length - 1; j >= num; j--) {
                 dp[j] = dp[j] || dp[j - num];
@@ -198,20 +202,21 @@ public class Solution {
 ## JavaScript
 ```javascript
 var canPartition = function(nums) {
-    sum = _.sum(nums)
+    const sum = _.sum(nums)
+
     if (sum % 2 == 1) {
         return false
     }
 
-    dp = Array(sum / 2 + 1).fill(false)
+    const dp = Array(sum / 2 + 1).fill(false)
     dp[0] = true
 
-    for (num of nums) {
+    for (const num of nums) {
         for (let j = dp.length - 1; j >= num; j--) {
             dp[j] = dp[j] || dp[j - num]
         }
     }
-    
+
     return dp.at(-1)
 };
 ```
@@ -223,13 +228,14 @@ func canPartition(nums []int) bool {
     for _, num := range nums {
         sum += num
     }
+
     if sum % 2 == 1 {
         return false
     }
-    
+
     dp := make([]bool, sum / 2 + 1)
     dp[0] = true
-    
+
     for _, num := range nums {
         for j := len(dp) - 1; j >= num; j-- {
             dp[j] = dp[j] || dp[j - num]
@@ -244,6 +250,7 @@ func canPartition(nums []int) bool {
 ```ruby
 def can_partition(nums)
   sum = nums.sum
+
   return false if sum % 2 == 1
 
   dp = Array.new(sum / 2 + 1, false)
diff --git a/problems/0583-delete-operation-for-two-strings.md b/problems/0583-delete-operation-for-two-strings.md
@@ -15,6 +15,10 @@ Explanation: You need one step to make "sea" to "ea" and another step to make "e
 Example 2:
 Input: word1 = "leetcode", word2 = "etco"
 Output: 4
+
+Constraints:
+1. 1 <= word1.length, word2.length <= 500
+2. `word1` and `word2` consist of only lowercase English letters.
 ```
 
 ## Thoughts
@@ -187,7 +191,7 @@ public class Solution {
 ## JavaScript
 ```javascript
 var minDistance = function(word1, word2) {
-    let dp = Array(word1.length + 1).fill().map(
+    const dp = Array(word1.length + 1).fill().map(
         () => Array(word2.length + 1).fill(0)
     )
     dp.forEach((_, i) => { dp[i][0] = i })
