Update maxProductSubarray and minRotatedSortedarray algorithms

Author: sudheerj

src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.js

@@ -1,18 +1,18 @@
 function maxProductSubArray(nums) {
-    let result = nums[0];
-    let currentMax = currentMin = 1;
+    let result = nums[0], currentMax = nums[0], currentMin = nums[0];
 
-    for(let num of nums) {
-        let tempMaxProduct = currentMax * num;
-        let tempMinProduct = currentMin * num;
-        currentMax = Math.max(Math.max(tempMaxProduct, tempMinProduct), num);
-        currentMin = Math.min(Math.min(tempMaxProduct, tempMinProduct), num);
+    for(let i=1; i < nums.length; i++) {
+        const num = nums[i];
+        const tempMaxProduct = currentMax * num;
+        const tempMinProduct = currentMin * num;
+        currentMax = Math.max(num, tempMaxProduct, tempMinProduct);
+        currentMin = Math.min(num, tempMaxProduct, tempMinProduct);
         result = Math.max(result, currentMax);
     }
     return result;
 }
 
 let numbers1 = [6, 7,-4, 5, 8, 1];
 console.log(maxProductSubArray(numbers1));
-let numbers2 = [2, 7,-4, 0, 3, 3];
+let numbers2 = [2, -7, -4, 0, 3, 3];
 console.log(maxProductSubArray(numbers2));

src/javascript/algorithms/array/8.maxProductSubarray/maxProductSubarray.md

@@ -7,35 +7,51 @@ Input: nums = [6, 7,-4, 5, 8, ]
 Output: 6
 
 Example 2:
-Input: nums = [-2,0,-2]
+Input: nums = [-2, 0, -2]
 Output: 0
 
-**Algorithmic Steps:**
+## Algorithmic Steps
 
-This problem is solved with the help of **Kadane's algorithm**(dynamic programming technique). The algorithmic approach can be summarized as follows:
+This problem is efficiently solved using a variation of **Kadane's Algorithm** tailored for products. It tracks both the **maximum** and **minimum** product ending at each position, due to the behavior of negative numbers.
 
-1. Initialize the maximum product subarray(`result`) with a first number. 
+1. **Initialize** three variables with the first element of the array `nums[0]`:
+   - `result`: Holds the maximum product found so far.
+   - `currentMax`: Tracks the maximum product ending at the current index.
+   - `currentMin`: Tracks the minimum product ending at the current index.
 
- **Note:** It is not suggested to assign the value to either 0 or 1 because the maximum value can be less than or equal to 0.
+   > **Note:** We initialize all three with the first element instead of 1 or 0 to properly account for arrays with negative or single values.
 
-2. Initialize two variables named `currentMax` and `currentMin` to `1`. They are used to keep track of the running maximum and minimum products.
+2. **Iterate** over the array starting from the second element to last element:
 
-3. Iterate over the entire input array using for-of loop
+3. For each element `num`:
+   - Compute temporary products using the previous `currentMax` and `currentMin`:
+     - `tempMax = currentMax * num`
+     - `tempMin = currentMin * num`
 
-4. Find the temporary maximum and minimum products for each current element.
+4. **Update** `currentMax` by taking the maximum among:
+   - `num` (start new subarray)
+   - `tempMax`
+   - `tempMin`  
+   This ensures that the current maximum product is correctly tracked.
 
-5. Calculate the maximum value between maximum and minimum values of step4, and this calculated maximum result needs to be compared with current element to find the final current maximum product.
+5. **Update** `currentMin` by taking the minimum among:
+   - `num`
+   - `tempMax`
+   - `tempMin`  
+   This is crucial for handling negative values, which could turn a future product into a maximum.
 
-  **Note:** Since an array contain both positive and negative integers, the product of current element with minimum product calculated so far may result into maximum value. That is the reason why we took maximum of current maximum and current minimum proucts.
+6. **Update** the global `result` by taking the maximum of:
+   - `result`
+   - `currentMax`  
+   This ensures the highest product is captured across the entire array.
 
-6. Calculate the minimum value between maximum and minimum values of step4, and this calculated minimum result needs to be compared with current element to find the final current minimum product. This current minimum product is useful to calculate the maximum value for the next iteration.
+7. After the loop completes, **return** the `result`, which contains the maximum product of any contiguous subarray.
 
-7. Update the global maximum product by taking the maximum of current maximum product and global maximum product of previous iteration.
+---
 
-8. Return the global maximum `result` after the end of for-each iteration.
+## Time and Space Complexity
 
-**Time and Space complexity:**
+- **Time Complexity**: `O(n)` — We traverse the input array once.
+- **Space Complexity**: `O(1)` — No extra space is used except for a few variables.
 
-This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because we iterate the array at most once. 
-
-Here, we don't use any additional datastructure other than the two sum variables. Hence, the space complexity will be O(1).
+---

src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.js

@@ -1,29 +1,32 @@
-function minRotatedSortedArray(nums) {
-    let result = nums[0];
+function minRotatedSortedarray(nums) {
     if(nums.length === 1) return nums[0];
     if(nums.length === 2) return Math.min(nums[0], nums[1]);
 
-    let left = 0, right = nums.length - 1;     
+    let left = 0;
+    let right = nums.length - 1;
 
-    while(left < right) {
-        if(nums[left] < nums[right]) {
-            result = nums[left];
-            break;
-        }
+    while (left < right) {
+        // If the array is already sorted
+        if (nums[left] < nums[right]) return nums[left];
 
-        let mid = left + (right - left)/2;
+        const mid = Math.floor((left + right) / 2);
 
-        if(nums[mid] > nums[right]) {
+        if (nums[mid] > nums[right]) {
+            // Minimum is in the right half
             left = mid + 1;
         } else {
+            // Minimum is in the left half (including mid)
             right = mid;
         }
     }
-    return result;
+
+    return nums[left]; // or arr[right], both are the same here
 }
 
+
+
 let sortedArray = [3, 4, 5, 6, 7, 1, 2];
-console.log(minRotatedSortedArray(sortedArray));
+console.log(minRotatedSortedarray(sortedArray));
 
 let sortedArray1 = [0, 1, 2, 4, 5, 6, 7, 8];
-console.log(minRotatedSortedArray(sortedArray1));
+console.log(minRotatedSortedarray(sortedArray1));

src/javascript/algorithms/array/9.minRotatedSortedarray/minRotatedSortedarray.md

@@ -1,7 +1,7 @@
 **Description:**
 Given a sorted array `nums` of length `n` with all unique elements, in which the array is rotated between 1 and n times. Return the minimum element of this array.
 
-**Note:** You need to write an algorithm that runs in O(log n) time.
+**Note:** You need to write an algorithm that runs in `O(log n)` time.
 
 ### Examples
 Example 1:
@@ -14,27 +14,36 @@ Output: 0
 
 **Algorithmic Steps:**
 
-This problem is solved with the help of **binary search** technique. Since it is a rotated sorted array, there will be two subararys of elements in an ascending order. Once you find the correct subarray, the left most element is the minimum value. The algorithmic approach can be summarized as follows:
+This problem can be efficiently solved using the **binary search** technique. Because the array is a rotated version of a sorted array, it consists of two ascending subarrays. By identifying which subarray contains the minimum element, we can narrow down the search. The minimum value will always be the leftmost element of the correctly identified subarray. The algorithmic approach can be summarized as follows:
 
-1. Initialize the minimum value(`result`) to first element of an array.
 
-2. Add preliminary checks by returning the first element if the length of array is one, or minimum of first two values if the length of an array is two.
+1. **Initialize the Result:**
+   - Set the initial minimum value `result` to the first element of the array.
 
-3. Initialize left and right pointers(`left` and `right`) to first index and last index of an array.
+2. **Handle Base Cases:**
+   - If the array length is `1`, return the only element.
+   - If the array length is `2`, return the smaller of the two elements.
 
-4. Iterate over an input array using while loop with the condition of left pointer is less than or equal to right pointer.
+3. **Set Search Boundaries:**
+   - Initialize two pointers: `left` at the start (index 0), and `right` at the end (index `n - 1`) of the array.
 
-5. If the left element is less than or equal to right element, update the result value and break the while loop to return the minimum value.
+4. **Iterate Using Binary Search:**
+   - While `left < right`:
+     - Check if the subarray between `left` and `right` is already sorted:
+       - If `nums[left] < nums[right]`, return `nums[left]` as the minimum.
+     - Compute the middle index: `mid = Math.floor((left + right) / 2)`.
 
-6. Calculate the middle index of an array to separate the sorted subarrays.
+5. **Decide Which Half to Search:**
+   - If `nums[mid] > nums[right]`:
+     - The minimum lies in the **right half**.
+     - Move `left` pointer to `mid + 1`.
+   - Otherwise:
+     - The minimum lies in the **left half** (including `mid`).
+     - Move `right` pointer to `mid`.
 
-7. If the middle value is greater than right most element, the minimum value exists with in the right side subarray. So the left pointer will be updated to next element of middle element.
+6. **Return Minimum:**
+   - After the loop ends, `nums[left]` holds the minimum element in the rotated sorted array.
 
-8. If the middle value is less than or equal to left most element, the minimum value exists with in the left side subarray. So the right pointer will be updated to the middle element.
-
-9. Repeat steps 4-7 until you find the left most value which is minimum in the entire input array.
-
-10. Return the result element after the end of an iteration.
 
 **Time and Space complexity:**