Update minsize Subarray sum & sort colors algorithms

Author: sudheerj

src/javascript/algorithms/array/6.minimumSizeSubarraySum/minSizeSubarraySum.js

@@ -3,25 +3,29 @@
 function minSizeSubarraySum(nums, target) {
 
     let left = right = total = 0;
-    let result = Infinity;
+    let minLength = Infinity;
 
     while(right < nums.length) {
         total += nums[right];
         while(total >= target) {
-            result = Math.min(right - left + 1, result);
+            minLength = Math.min(right - left + 1, minLength);
             total -= nums[left++];
         }
         right++;
     }
 
-    return result === Infinity ? 0 : result;
+    return minLength === Infinity ? 0 : minLength;
 }
 
-let target1 = 7, nums1 = [2,4,1,2,4,3];
-let target2 = 5, nums2 = [1, 5, 5, 5];
-let target3 = 15, nums3 = [2, 2, 2, 2, 2];
-
-console.log(minSizeSubarraySum(nums1, target1));
-console.log(minSizeSubarraySum(nums2, target2));
-console.log(minSizeSubarraySum(nums3, target3));
+// Test Cases
+  const testCases = [
+    { target: 7, nums: [2, 4, 1, 2, 4, 3] },
+    { target: 5, nums: [1, 5, 5, 5] },
+    { target: 15, nums: [2, 2, 2, 2, 2] }
+  ];
+  
+  for (const { target, nums } of testCases) {
+    console.log(`Input: target = ${target}, nums = [${nums}]`);
+    console.log(`Output: ${minSizeSubarraySum(nums, target)}\n`);
+  }
 

src/javascript/algorithms/array/6.minimumSizeSubarraySum/minSizeSubarraySum.md

@@ -12,26 +12,30 @@ Output: 2
 Input: target = 15, nums = [2, 2, 2, 2, 2]
 Output: 0
 
-**Algorithmic Steps:**
-This problem is solved with the help of **sliding window** approach without using any special data structure. The algorithmic approach can be summarized as follows:
 
-1. Initialize left and right pointers to 0, to keep track of the substring window boundaries.
+---
 
-2. Initialize total variable to 0, to store the sum of the subarray values to meet the target criteria.
+### Algorithmic Steps
 
-3. Initialize result variable to max integer value to indicate that there is no subarray to meet target value.
+This problem is efficiently solved using the **sliding window** technique without requiring any special data structures. The approach can be summarized as follows:
 
-4. Iterate over the input array using right pointer until the end of the string. 
+1. Initialize two pointers, `left` and `right`, both at `0`. These represent the current window boundaries.
+2. Initialize a variable `total` to `0` to keep track of the sum of the current window.
+3. Initialize `minLength` to a very large number (e.g., infinity) to represent the length of the smallest valid subarray found so far.
+4. Iterate through the array with the `right` pointer:
+   - Add `nums[right]` to `total`.
+   - While `total` is greater than or equal to `target`:
+     - Update `minLength` to the smaller value between the current `minLength` and the window size (`right - left + 1`).
+     - Subtract `nums[left]` from `total` and move the `left` pointer forward to try and find a smaller valid window.
+5. Continue until the `right` pointer reaches the end of the array.
+6. If `minLength` is still infinity (meaning no valid subarray was found), return `0`. Otherwise, return `minLength`.
 
-5. Calculate the total value by adding array value at respective right pointer.
+---
 
-6. If the total value is greater or equal to target, find the minimum of subarray sum and shrink the current window total and left pointer value. This step need to be repeated until there are no subarray exists to meet the target criteria.
+### Time and Space Complexity
 
-7. Increment the right pointer to find the next subarray.
-
-8. Repeat steps 4–7 until the right pointer reaches the end of the array.
-
-9. Return 0 if the result is still a maximum integer which indicates no valid subarray otherwise return the calculated minimum subarray value.
-
-**Time and Space complexity:**
-This algorithm has a time complexity of O(n) because we are traversing the array only twice at max. Since it doens't require any datastructure, the space complexity will be O(1).
+- **Time Complexity:** `O(n)`  
+  The array is traversed at most twice (once by each pointer), resulting in linear time complexity.
+  
+- **Space Complexity:** `O(1)`  
+  No additional data structures are used; only a fixed number of variables are maintained.

src/javascript/algorithms/array/7.sortColors/sortColors.md

@@ -1,7 +1,14 @@
-**Description:**
-Given an array `nums` with `n` objects colored red, white, where each object is color coded as integer: blue, 0 for red, 1 for white, and 2 for blue. We need to sort them in-place so that objects of the same color are grouped together, with the colors in the order red, white, and blue.
+# Sort Colors (Dutch National Flag Problem)
 
-This problem needs to be solved without using the library's sort function.
+## Description
+
+Given an array `nums` containing `n` integers where each integer is `0` (red), `1` (white), or `2` (blue), sort the array **in-place** so that elements of the same color are adjacent and in the order: red (0), white (1), and blue (2).
+
+**Constraints:**
+- Must not use any built-in sorting functions.
+- Must use constant space (`O(1)`).
+
+---
 
 ### Examples
 
@@ -15,26 +22,40 @@ Example 2:
 Input: nums = [2,1,0]
 Output: [0,1,2]
 
-**Algorithmic Steps:**
+---
+
+## Algorithmic Steps (Two-Pointer / Dutch National Flag)
 
-This problem is solved with the help of **two pointers** technique. It is also know as **"Dutch National Flag problem"**. The algorithmic approach can be summarized as follows:
+We use a **two-pointer** approach with three indices:
 
+- `left`: the position where the next `0` should be placed.
+- `right`: the position where the next `2` should be placed.
+- `i`: the current index we are evaluating.
 
-1. Initialize both left and right pointers to first index(i.e, `0`) and end index(i.e, `nums.length-1`) of the array respectively, to keep track of the current window boundaries.
+### Steps:
 
-2. Initialize current index pointer(i.e, `i`) to 0, to keep track of the current character while iterating the array.
+1. Initialize `left = 0`, `i = 0`, and `right = nums.length - 1`.
 
-3. Iterate over the input array using index pointer until the end of the array. 
+2. Traverse the array while `i <= right`:
+   - If `nums[i] == 0`:
+     - Swap `nums[i]` and `nums[left]`
+     - Increment both `i` and `left`
+   - If `nums[i] == 2`:
+     - Swap `nums[i]` and `nums[right]`
+     - Decrement `right` (do **not** increment `i` here)
+   - If `nums[i] == 1`:
+     - Just increment `i`
 
-4. If the current character is equals to 0, swap the character values at left pointer and index pointer. Also, increment the left pointer and index pointer.
+3. The array will be sorted in one pass.
 
-5. If the current character is equals to 2, swap the character values at right pointer and index pointer. Also, decrement the right pointer. 
+---
 
-6. If the character is neither `0` or `2`, then just increment the index pointer.
+## Time and Space Complexity
 
-7. Repeat steps 4–6 until the index pointer reaches the end of the array.
+- **Time Complexity:** `O(n)`  
+  Each element is processed at most once.
 
-8. Return the updated in-place array where characters are sorted.
+- **Space Complexity:** `O(1)`  
+  Sorting is done in-place without any additional data structures.
 
-**Time and Space complexity:**
-This algorithm takes a time complexity of `O(n)` because we are traversing the array only once. Also, it requires space complexity of `O(1)` because we are updating the array in-place without using an additional data structure.
+---