add python solutions for prefix sum pattern

ashishps1 · ashishps1 · commit b19f68853b46 · 2024-09-27T19:30:13.000+05:30
diff --git a/python/contiguous-array.md b/python/contiguous-array.md
@@ -1 +1,139 @@
-Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0 and 1.
+
+# Contiguous Array
+Given a binary array nums, return the maximum length of a contiguous subarray with an equal number of 0 and 1.
+
+### Constraints:
+- 1 <= nums.length <= 10^5
+- nums[i] is either 0 or 1.
+
+### Examples
+```javascript
+Input: nums = [0,1]
+Output: 2
+Explanation: [0, 1] is the longest contiguous subarray with an equal number of 0 and 1.
+
+Input: nums = [0,1,0]
+Output: 2
+Explanation: [0, 1] (or [1, 0]) is a contiguous subarray with equal number of 0 and 1.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force
+##### Intuition:
+In the brute-force solution, we try every possible subarray and check if it has an equal number of 0s and 1s. For each subarray, count the number of 0s and 1s, and if they are equal, update the maximum length.
+
+- Loop over every subarray starting at each index.
+- For each subarray, count the number of 0s and 1s.
+- Update the maximum length if the number of 0s and 1s are equal.
+##### Time Complexity:
+O(n^2), where n is the length of the array. This is because we check every possible subarray.
+##### Space Complexity:
+O(1), no extra space is used.
+##### Python Code:
+```python
+def findMaxLength(nums: List[int]) -> int:
+    max_len = 0
+    n = len(nums)
+    
+    for i in range(n):
+        zeroes = ones = 0
+        for j in range(i, n):
+            if nums[j] == 0:
+                zeroes += 1
+            else:
+                ones += 1
+            if zeroes == ones:
+                max_len = max(max_len, j - i + 1)
+                
+    return max_len
+```
+### Approach 2: Prefix Sum with Hash Map
+##### Intuition: 
+To optimize the solution, we can use the prefix sum technique. The key observation is that if we treat 0 as -1, then finding a subarray with an equal number of 0s and 1s is equivalent to finding a subarray whose sum is 0. Using this insight:
+
+- Convert 0 to -1.
+- Use a hash map (sum_index) to store the first occurrence of each cumulative sum.
+- If the same sum appears again at a later index, it means the subarray between these two indices has a sum of 0.
+- Calculate the length of this subarray and update the maximum length.
+##### Visualization:
+For nums = [0, 1, 0]:
+
+- Convert nums to [-1, 1, -1].
+- Maintain a prefix_sum and check:
+   - At index 0: prefix_sum = -1, store it in the hash map.
+   - At index 1: prefix_sum = 0, subarray from index 0 to 1 has sum 0.
+   - At index 2: prefix_sum = -1, found the same sum at index 0, so the subarray from index 1 to 2 has sum 0.
+
+Steps:
+1. Initialize prefix_sum as 0 and store prefix_sum = 0 at index -1 in the hash map.
+2. Traverse through the array, updating prefix_sum by adding -1 for 0 and 1 for 1.
+3. Check if the current prefix_sum has been seen before:
+   - If yes, calculate the subarray length from the previous index to the current index and update the maximum length.
+   - If no, store the current prefix_sum and index in the hash map.
+##### Time Complexity:
+O(n), where n is the length of the array. We traverse the array once.
+##### Space Complexity:
+O(n), because we use a hash map to store the prefix sums.
+##### Python Code:
+```python
+def findMaxLength(nums: List[int]) -> int:
+    # Convert 0 to -1 and then find subarray with sum 0
+    sum_index = {0: -1}  # Store the first occurrence of each prefix_sum
+    prefix_sum = 0
+    max_len = 0
+    
+    for i, num in enumerate(nums):
+        # Convert 0 to -1
+        if num == 0:
+            prefix_sum += -1
+        else:
+            prefix_sum += 1
+        
+        if prefix_sum in sum_index:
+            # If the prefix_sum was seen before, calculate subarray length
+            max_len = max(max_len, i - sum_index[prefix_sum])
+        else:
+            # Store the index of the first occurrence of this prefix_sum
+            sum_index[prefix_sum] = i
+    
+    return max_len
+```
+### Approach 3: Optimized Prefix Sum with Early Exit
+##### Intuition: 
+This is an optimization over the previous approach, where we exit early if we find the maximum possible subarray (i.e., the array itself or the longest subarray so far). This approach doesn't improve time complexity in the worst case but can be useful in certain cases.
+
+1. As we build the prefix_sum, we track the length of the longest valid subarray.
+2. If the longest subarray already equals half of the current length, we can exit early.
+##### Time Complexity:
+O(n), since we still traverse the array once.
+##### Space Complexity:
+O(n), due to the hash map.
+##### Python Code:
+```python
+def findMaxLength(nums: List[int]) -> int:
+    sum_index = {0: -1}
+    prefix_sum = 0
+    max_len = 0
+    
+    for i, num in enumerate(nums):
+        prefix_sum += -1 if num == 0 else 1
+        
+        if prefix_sum in sum_index:
+            max_len = max(max_len, i - sum_index[prefix_sum])
+            # Early exit if the maximum possible subarray is found
+            if max_len == i + 1:
+                break
+        else:
+            sum_index[prefix_sum] = i
+    
+    return max_len
+```
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                    | O(n^2)      | O(1)             |
+| Prefix Sum with Hash Map                          | O(n)            | O(n)             |
+| Optimized Prefix Sum with Early Exit      | O(n)      | O(n)             |
+
+The Prefix Sum with Hash Map approach is the most efficient solution as it allows finding the maximum length subarray in linear time using constant updates to the prefix sum and hash map.
diff --git a/python/range-sum-query-immutable.md b/python/range-sum-query-immutable.md
@@ -0,0 +1,106 @@
+# Range Sum Query - Immutable
+Given an integer array nums, handle multiple queries of the following type:
+
+Calculate the sum of the elements of nums between indices left and right inclusive, where left <= right.
+Implement the NumArray class:
+
+NumArray(int[] nums) Initializes the object with the integer array nums.
+int sumRange(int left, int right) Returns the sum of the elements of nums between indices left and right inclusive (i.e., nums[left] + nums[left + 1] + ... + nums[right]).
+
+### Constraints:
+- 1 <= nums.length <= 10^4
+- -10^5 <= nums[i] <= 10^5
+- 0 <= left <= right < nums.length
+- At most 10^4 calls will be made to sumRange.
+
+### Examples
+```javascript
+Input:
+["NumArray", "sumRange", "sumRange", "sumRange"]
+[[[-2, 0, 3, -5, 2, -1]], [0, 2], [2, 5], [0, 5]]
+
+Output:
+[null, 1, -1, -3]
+
+Explanation:
+NumArray numArray = new NumArray([-2, 0, 3, -5, 2, -1]);
+numArray.sumRange(0, 2); // return 1 (-2 + 0 + 3 = 1)
+numArray.sumRange(2, 5); // return -1 (3 + -5 + 2 + -1 = -1)
+numArray.sumRange(0, 5); // return -3 (-2 + 0 + 3 + -5 + 2 + -1 = -3)
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Iterate Over Range)
+##### Intuition:
+The most straightforward approach is to iterate over the elements between indices left and right every time sumRange is called. This solution will work, but it may not be efficient if sumRange is called multiple times.
+
+Steps:
+1. Each time sumRange(left, right) is called, iterate over the elements from left to right and sum them.
+2. Return the sum after iterating over the range.
+##### Time Complexity:
+O(n) for each query, where n is the length of the range between left and right.
+##### Space Complexity:
+O(1), no extra space is used beyond a few variables for the sum.
+##### Python Code:
+```python
+class NumArray:
+
+    def __init__(self, nums: List[int]):
+        self.nums = nums  # Store the input array
+    
+    def sumRange(self, left: int, right: int) -> int:
+        # Calculate the sum by iterating over the range
+        return sum(self.nums[left:right + 1])
+```
+### Approach 2: Prefix Sum (Preprocessing)
+##### Intuition: 
+To optimize the sum range queries, we can use the concept of prefix sums. The idea is to preprocess the array and compute a cumulative sum array where each element at index i stores the sum of elements from the start of the array up to i. This allows us to compute any range sum in constant time.
+
+- Define prefix_sum[i] as the sum of elements nums[0] + nums[1] + ... + nums[i-1].
+- To find the sum of the range [left, right], we can calculate:
+```python
+sumRange(left, right) = prefix_sum[right + 1] - prefix_sum[left]
+```
+
+Steps:
+
+1. Precompute the cumulative sum array prefix_sum where each entry stores the sum of all elements before index i.
+2. Use this precomputed array to quickly answer range sum queries by subtracting two prefix sums.
+
+##### Why This Works:
+If a cycle exists, the fast pointer, moving twice as fast as the slow pointer, will "lap" the slow pointer and meet it again inside the cycle.
+##### Time Complexity:
+- O(n) for preprocessing the prefix sum array.
+- O(1) for each query, since we only perform subtraction of two values.
+##### Space Complexity:
+O(n), for storing the prefix sum array.
+##### Visualization:
+```rust
+For nums = [-2, 0, 3, -5, 2, -1], the prefix_sum array would be:
+prefix_sum = [0, -2, -2, 1, -4, -2, -3]
+
+To compute sumRange(0, 2), we do:
+sumRange(0, 2) = prefix_sum[3] - prefix_sum[0] = 1 - 0 = 1
+```
+##### Python Code:
+```python
+class NumArray:
+
+    def __init__(self, nums: List[int]):
+        # Create a prefix sum array
+        self.prefix_sum = [0] * (len(nums) + 1)
+        for i in range(1, len(self.prefix_sum)):
+            self.prefix_sum[i] = self.prefix_sum[i - 1] + nums[i - 1]
+
+    def sumRange(self, left: int, right: int) -> int:
+        # Calculate the sum for the range using the prefix sum
+        return self.prefix_sum[right + 1] - self.prefix_sum[left]
+```
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force (Iterate Over Range)	   | O(n) per query            | O(1)             |
+| Prefix Sum (Preprocessing)        | O(n) to preprocess, O(1) per query	            | O(n) for storing prefix sum             |
+
+The Prefix Sum approach is the most optimal solution as it allows querying the sum of any range in constant time after an initial preprocessing step.
diff --git a/python/subarray-sum-equals-k.md b/python/subarray-sum-equals-k.md
@@ -0,0 +1,108 @@
+
+# Subarray Sum Equals K
+Given an array of integers nums and an integer k, return the total number of continuous subarrays whose sum equals to k.
+
+### Constraints:
+- 1 <= nums.length <= 2 * 10^4
+- -1000 <= nums[i] <= 1000
+- -10^7 <= k <= 10^7
+
+### Examples
+```javascript
+Input: nums = [1,1,1], k = 2
+Output: 2
+Explanation: [1,1] and [1,1] are the two subarrays with a sum equal to 2.
+
+Input: nums = [1,2,3], k = 3
+Output: 2
+Explanation: [1, 2] and [3] are the two subarrays with a sum equal to 3.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force
+##### Intuition:
+A straightforward approach would be to iterate through every possible subarray in nums and check if the sum equals k. This solution works but is inefficient due to the repeated summation of subarray elements.
+
+1. Use a nested loop to consider every possible subarray in the array.
+2. For each subarray, calculate the sum.
+3. If the sum equals k, increment the count of valid subarrays.
+##### Time Complexity:
+O(n²), where n is the length of the array because we consider all subarrays.
+##### Space Complexity:
+O(1), no extra space is used beyond the variables for sum and count.
+##### Python Code:
+```python
+def subarraySum(nums: List[int], k: int) -> int:
+    count = 0
+    n = len(nums)
+    
+    for i in range(n):
+        current_sum = 0
+        for j in range(i, n):
+            current_sum += nums[j]
+            if current_sum == k:
+                count += 1
+                
+    return count
+```
+### Approach 2: Prefix Sum with Hash Map
+##### Intuition: 
+The key idea in optimizing the brute force approach is to use prefix sums. A prefix sum is the cumulative sum of elements from the start of the array to any index i. If the difference between two prefix sums equals k, then the subarray between these two indices has a sum of k.
+
+1. Define prefix_sum[i] as the cumulative sum of elements from the start of the array to index i.
+2. To find the number of subarrays with sum k, check if there is a previous prefix sum such that: ```current_prefix_sum - previous_prefix_sum = k```
+3. Rearranging this gives: ```previous_prefix_sum = current_prefix_sum - k```
+4. Use a hash map to store the frequency of each prefix sum as we iterate through the array.
+
+Steps:
+1. Initialize a prefix_sum as 0 and a hash map prefix_sum_count to store how often each prefix sum occurs.
+2. For each element in the array, update the prefix_sum.
+3. Check if prefix_sum - k exists in the hash map. If it does, the count of valid subarrays is incremented by the frequency of this sum.
+4. Add the current prefix_sum to the hash map.
+
+##### Visualization:
+For nums = [1, 1, 1], k = 2:
+
+```perl
+prefix_sum = 0 initially
+Iterating through the array:
+  At index 0, prefix_sum = 1, prefix_sum - k = 1 - 2 = -1 (not found in hash map)
+  At index 1, prefix_sum = 2, prefix_sum - k = 2 - 2 = 0 (found in hash map, count += 1)
+  At index 2, prefix_sum = 3, prefix_sum - k = 3 - 2 = 1 (found in hash map, count += 1)
+
+Total count = 2
+```
+##### Time Complexity:
+O(n), where n is the length of the array, since we traverse the array once and use hash map operations that are O(1) on average.
+##### Space Complexity:
+O(n), because we use a hash map to store prefix sums.
+##### Python Code:
+```python
+def subarraySum(nums: List[int], k: int) -> int:
+    prefix_sum_count = {0: 1}  # To handle the case when prefix_sum equals k
+    prefix_sum = 0
+    count = 0
+    
+    for num in nums:
+        prefix_sum += num
+        
+        # Check if there is a previous prefix_sum such that prefix_sum - k exists
+        if prefix_sum - k in prefix_sum_count:
+            count += prefix_sum_count[prefix_sum - k]
+        
+        # Add the current prefix_sum to the map
+        if prefix_sum in prefix_sum_count:
+            prefix_sum_count[prefix_sum] += 1
+        else:
+            prefix_sum_count[prefix_sum] = 1
+    
+    return count
+```
+## Summary
+
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force                    | O(n^2)      | O(1)             |
+| Prefix Sum with Hash Map                          | O(n)            | O(n)             |
+
+The Prefix Sum with Hash Map approach is the most efficient solution as it computes the number of valid subarrays in linear time, making use of cumulative sums and hash maps to store and check the required prefix sums.
