Merge branch 'master' into feature/14-longest-common-prefix

Author: nishithadaryn

Arrays & Strings/#15 - 3 Sum - Medium/Explanation.md

@@ -0,0 +1,133 @@
+# 15. 3Sum 
+
+**Difficulty:** Medium  
+**Category:** Arrays, Two Pointers, Hashing  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/3sum)
+
+---
+
+## 📝 Introduction
+
+Given an integer array `nums`, return all the unique triplets `[nums[i], nums[j], nums[k]]` such that:
+- `i != j`, `i != k`, and `j != k`,
+- `nums[i] + nums[j] + nums[k] == 0`
+
+The solution must not contain duplicate triplets.
+
+---
+
+## 💡 Approach & Key Insights
+
+The main idea is to find all unique triplets in the array that sum to zero. Since the problem demands uniqueness and excludes repeated indices, care must be taken in how the triplets are collected. We can go from a brute force solution using three nested loops to a highly optimized two-pointer strategy that leverages sorting and duplicate skipping.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:**  
+  Iterate through all combinations of three distinct indices using three nested loops. For each combination, check if the sum is zero. Use a set to store sorted triplets to avoid duplicates.
+
+- **Time Complexity:** O(N³ * log M)  
+  Where `N` is the length of the array and `M` is the number of unique triplets (for insertion into the set).
+
+- **Space Complexity:** O(M)  
+  For storing unique triplets in a set.
+
+- **Example/Dry Run:**
+
+  Input: `[-1, 0, 1, 2, -1, -4]`  
+  Valid triplets (after sorting): `[-1, -1, 2]`, `[-1, 0, 1]`  
+  Output: `[[-1, -1, 2], [-1, 0, 1]]`
+
+---
+
+### 2️⃣ Better Approach (Using HashSet)
+
+- **Explanation:**  
+  Fix two elements using nested loops and calculate the third element required to make the sum zero. Use a HashSet to check if this third element has already been seen. Ensure only elements between the second loop's index range are included in the HashSet to prevent using the same element multiple times.
+
+- **Time Complexity:** O(N² * log M)  
+  Due to two loops and set insertions.
+
+- **Space Complexity:** O(M + N)  
+  For storing unique triplets and temporary HashSet.
+
+- **Example/Dry Run:**
+
+  Input: `[-1, 0, 1, 2, -1, -4]`  
+  Valid triplets: `[-1, -1, 2]`, `[-1, 0, 1]`  
+  Output: `[[-1, -1, 2], [-1, 0, 1]]`
+
+---
+
+### 3️⃣ Best / Final Optimized Approach (Two Pointers + Sorting)
+
+- **Explanation:**  
+  Sort the array first. Use one fixed pointer `i`, and two moving pointers `j` and `k` (`j = i+1`, `k = n-1`). Move the pointers inward while skipping duplicates. If the sum is zero, store the triplet. If the sum is too small, increment `j`; if too large, decrement `k`.
+
+- **Time Complexity:** O(N²)  
+  Due to one fixed pointer and a linear scan with two pointers.
+
+- **Space Complexity:** O(M)  
+  Only for storing the result triplets.
+
+- **Example/Dry Run:**
+
+  Sorted Input: `[-4, -1, -1, 0, 1, 2]`  
+  i = 0 → j = 1, k = 5 → `-4 + (-1) + 2 = -3` → j++  
+  ...  
+  Found: `[-1, -1, 2]` and `[-1, 0, 1]`
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach         | Time Complexity         | Space Complexity       |
+| ---------------- | ----------------------- | ---------------------- |
+| Brute Force      | O(N³ * log M)           | O(M)                   |
+| Better Approach  | O(N² * log M)           | O(M + N)               |
+| Best Approach    | O(N²)                   | O(M)                   |
+
+---
+
+## 📉 Optimization Ideas
+
+- Sorting the array simplifies duplicate management.
+- Using two pointers eliminates the need for a HashSet and reduces time complexity.
+- Skipping duplicates on the fly avoids unnecessary checks and result post-processing.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+plaintext
+Example:
+Input: [-1, 0, 1, 2, -1, -4]
+Sorted: [-4, -1, -1, 0, 1, 2]
+
+Iteration:
+i = 0 → arr[i] = -4, j = 1, k = 5
+Sum = -4 + (-1) + 2 = -3 → j++
+
+i = 1 → arr[i] = -1, j = 2, k = 5
+Sum = -1 + (-1) + 2 = 0 → Store triplet [-1, -1, 2], j++, k--
+
+i = 1, j = 3, k = 4
+Sum = -1 + 0 + 1 = 0 → Store triplet [-1, 0, 1], j++, k--
+
+Duplicates skipped using while loops
+
+Output: [[-1, -1, 2], [-1, 0, 1]]
+
+---
+
+## 🔗 Additional Resources
+
+- [GeeksForGeeks Explanation](https://www.geeksforgeeks.org/find-triplets-array-whose-sum-equal-zero/)
+
+---
+
+Author: Abdul Wahab 
+Date: 19/07/2025

Arrays & Strings/R G VVV - 3SUM.java renamed to Arrays & Strings/#15 - 3 Sum - Medium/R G VVV - 3SUM.java

@@ -0,0 +1,30 @@
+class Solution {
+public:
+    vector<vector<int>> threeSum(vector<int>& nums) {
+        vector<vector<int>> ans;
+        int n = nums.size();
+        sort(nums.begin(), nums.end());
+        for (int i = 0; i < n; i++) {
+            // Skip duplicates for first element
+            if (i != 0 && nums[i] == nums[i - 1]) continue;
+            int j = i + 1, k = n - 1;
+            while (j < k) {
+                int sum = nums[i] + nums[j] + nums[k];
+                if (sum < 0) {
+                    j++;
+                } else if (sum > 0) {
+                    k--;
+                } else {
+                    ans.push_back({nums[i], nums[j], nums[k]});
+                    j++;
+                    k--;
+                    // Skip duplicates for second element
+                    while (j < k && nums[j] == nums[j - 1]) j++;
+                    // Skip duplicates for third element
+                    while (j < k && nums[k] == nums[k + 1]) k--;
+                }
+            }
+        }
+        return ans;
+    }
+};

Arrays & Strings/#15 - 3 Sum - Medium/threeSum.cpp

@@ -0,0 +1,24 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        nums.sort()
+        n = len(nums)
+        ans = []
+        for i in range(n):
+            if i != 0 and nums[i] == nums[i - 1]:
+                continue
+            j, k = i + 1, n - 1
+            while j < k:
+                s = nums[i] + nums[j] + nums[k]
+                if s < 0:
+                    j += 1
+                elif s > 0:
+                    k -= 1
+                else:
+                    ans.append([nums[i], nums[j], nums[k]])
+                    j += 1
+                    k -= 1
+                    while j < k and nums[j] == nums[j - 1]:
+                        j += 1
+                    while j < k and nums[k] == nums[k + 1]:
+                        k -= 1
+        return ans

Arrays & Strings/#15 - 3 Sum - Medium/threeSum.py

@@ -0,0 +1,161 @@
+# 152. Maximum Product Subarray
+
+**Difficulty:** Medium  
+**Category:** Arrays, Dynamic Programming  
+**Leetcode Link:** [Problem Link](https://leetcode.com/problems/maximum-product-subarray/)
+
+---
+
+## 📝 Introduction
+
+Given an integer array `nums`, find a contiguous non-empty subarray within the array that has the largest product, and return the product.
+
+The problem requires handling negative numbers and zeros, which can disrupt the product and reset subarrays. A subarray must be contiguous, and the result must be the largest product among all possible subarrays.
+
+Constraints:
+- 1 <= nums.length <= 2 * 10⁴  
+- -10 ≤ nums[i] ≤ 10  
+- The product of any prefix or suffix of nums is guaranteed to fit in a 32-bit integer.
+
+---
+
+## 💡 Approach & Key Insights
+
+To solve this problem, we evaluate various approaches:
+
+- Brute-force: Try all subarrays and compute their products.
+- Optimized: Observe properties of negative numbers and zeros.
+- Best: Use a modified version of Kadane’s algorithm that tracks both max and min products to handle sign flips.
+
+Key observations:
+- Positive product → Keep multiplying.
+- Negative product → Might become maximum when multiplied with another negative.
+- Zeros → Break the subarray and reset.
+
+---
+
+## 🛠️ Breakdown of Approaches
+
+### 1️⃣ Brute Force / Naive Approach
+
+- **Explanation:**  
+  Generate all possible subarrays using two nested loops. For each subarray, calculate the product of its elements. Keep track of the maximum product seen so far.
+
+- **Time Complexity:** O(N²) - N starting points and N subarray lengths  
+- **Space Complexity:** O(1) - No extra space used beyond variables
+
+- **Example/Dry Run:**
+
+Example input: [2, 3, -2, 4]  
+Subarrays:
+- [2] → 2
+- [2, 3] → 6
+- [2, 3, -2] → -12
+- [3, -2] → -6
+- [-2, 4] → -8  
+Max = 6
+
+---
+
+### 2️⃣ Optimized Approach
+
+- **Explanation:**  
+  Based on the number of negative elements:
+  - If all positives → result is the product of entire array.
+  - If even number of negatives → product of entire array is positive.
+  - If odd number of negatives → remove one negative (either from start or end) to make the product positive.
+
+  Handle 0s by splitting the array into subarrays and applying the above logic on each.
+
+- **Algorithm:**
+  - Loop through the array, tracking prefix and suffix products.
+  - Reset the prefix/suffix product to 1 when hitting zero.
+  - Track the maximum of all such segment products.
+
+- **Time Complexity:** O(N) - Single pass  
+- **Space Complexity:** O(1) - Only scalar variables used
+
+- **Example/Dry Run:**
+
+Input: [-2, 3, 4, -1, 0, -2, 3, 1, 4, 0, 4, 6, -1, 4]  
+Break on zeros → {[−2,3,4,−1], [−2,3,1,4], [4,6,−1,4]}  
+Apply logic on each subarray  
+Answer = max of all segment max products
+
+---
+
+### 3️⃣ Best / Final Optimized Approach (Kadane-style)
+
+- **Explanation:**  
+  Track the maximum and minimum product ending at the current index. Negative numbers can flip max to min and vice versa. This ensures handling of alternating signs.
+
+- **Algorithm:**
+  - Initialize prod1 = prod2 = result = nums[0]
+  - Traverse the array from index 1:
+    - temp = max(current, current × prod1, current × prod2)
+    - prod2 = min(current, current × prod1, current × prod2)
+    - prod1 = temp
+    - result = max(result, prod1)
+
+- **Time Complexity:** O(N) - Single loop  
+- **Space Complexity:** O(1) - Constant number of variables
+
+- **Example/Dry Run:**
+
+Input: [1, 2, -3, 0, -4, -5]  
+Step 1: prod1 = prod2 = result = 1  
+i = 1: nums[i] = 2 → temp = max(2, 2×1, 2×1) = 2  
+→ prod1 = 2, prod2 = 2, result = 2  
+i = 2: nums[i] = -3 → temp = max(-3, -6, -6) = -3  
+→ prod1 = -3, prod2 = -6, result = 2  
+i = 3: nums[i] = 0 → temp = 0 → reset  
+i = 4: nums[i] = -4 → etc.  
+Final result: 20
+
+---
+
+## 📊 Complexity Analysis
+
+| Approach      | Time Complexity | Space Complexity |
+| ------------- | --------------- | ---------------- |
+| Brute Force   | O(N²)           | O(1)             |
+| Optimized     | O(N)            | O(1)             |
+| Best Approach | O(N)            | O(1)             |
+
+---
+
+## 📉 Optimization Ideas
+
+- Use rolling variables instead of arrays to track max/min products.
+- Restart subarray product after encountering 0 to ensure correct segmentation.
+- Can further optimize by using prefix/suffix scans with early exits.
+
+---
+
+## 📌 Example Walkthroughs & Dry Runs
+
+plaintext
+Example:
+Input: [2, 3, -2, 4]
+Process:
+→ 2 → max = 2
+→ 2×3 = 6 → max = 6
+→ 6×(-2) = -12 → becomes min
+→ restart with 4 → max = 6
+Output: 6
+
+Another:
+Input: [1, 2, -3, 0, -4, -5]
+→ Subarray after 0 = [-4, -5] → product = 20
+Output: 20
+
+---
+
+## 🔗 Additional Resources
+
+- [Kadane’s Algorithm for Maximum Sum](https://en.wikipedia.org/wiki/Maximum_subarray_problem)
+
+---
+
+Author: Abdul Wahab  
+Date: 19/07/2025

Arrays & Strings/#152 - Max Product Sub Array - Medium/Explanation.md

@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int maxProduct(vector<int>& nums) {
+        int prod1 = nums[0];  // max product ending here
+        int prod2 = nums[0];  // min product ending here
+        int result = nums[0];
+        
+        for (int i = 1; i < nums.size(); i++) {
+            int temp = max({nums[i], prod1 * nums[i], prod2 * nums[i]});
+            prod2 = min({nums[i], prod1 * nums[i], prod2 * nums[i]});
+            prod1 = temp;
+            
+            result = max(result, prod1);
+        }
+        
+        return result;
+    }
+};

Arrays & Strings/#152 - Max Product Sub Array - Medium/maxProduct.cpp

@@ -0,0 +1,17 @@
+class Solution {
+    public int maxProduct(int[] nums) {
+        int prod1 = nums[0];  // max product ending here
+        int prod2 = nums[0];  // min product ending here
+        int result = nums[0];
+        
+        for (int i = 1; i < nums.length; i++) {
+            int temp = Math.max(nums[i], Math.max(prod1 * nums[i], prod2 * nums[i]));
+            prod2 = Math.min(nums[i], Math.min(prod1 * nums[i], prod2 * nums[i]));
+            prod1 = temp;
+            
+            result = Math.max(result, prod1);
+        }
+        
+        return result;
+    }
+}