add python solutions for sliding window pattern

Author: ashishps1

python/longest-substring-without-repeating-characters.md

@@ -0,0 +1,155 @@
+# Longest Substring Without Repeating Characters
+Given a string s, find the length of the longest substring without repeating characters.
+
+### Constraints:
+- 0 <= s.length <= 5 * 10^4
+- s consists of English letters, digits, symbols, and spaces.
+
+### Examples
+```javascript
+Input: s = "abcabcbb"
+Output: 3
+Explanation: The answer is "abc", with the length of 3.
+
+Input: s = "bbbbb"
+Output: 1
+Explanation: The answer is "b", with the length of 1.
+
+Input: s = "pwwkew"
+Output: 3
+Explanation: The answer is "wke", with the length of 3. 
+Notice that the answer must be a substring, "pwke" is a subsequence and not a substring.
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+A simple brute-force solution is to check every possible substring, and for each substring, check if it contains duplicate characters. The maximum length of a substring without repeating characters is tracked.
+
+Steps:
+1. Use two nested loops to generate all possible substrings.
+2. For each substring, check if it contains duplicate characters by using a set or dictionary.
+3. Track the maximum length of substrings without duplicates.
+##### Time Complexity:
+O(n²) for checking all substrings and validating each one.
+##### Space Complexity:
+O(n) for storing characters in a set or dictionary while checking each substring.
+##### Python Code:
+```python
+def lengthOfLongestSubstring(s: str) -> int:
+    max_len = 0
+    n = len(s)
+    
+    for i in range(n):
+        seen = set()
+        for j in range(i, n):
+            if s[j] in seen:
+                break
+            seen.add(s[j])
+            max_len = max(max_len, j - i + 1)
+    
+    return max_len
+```
+### Approach 2: Sliding Window with Hash Set (Optimal)
+##### Intuition: 
+The brute-force approach is inefficient because it recalculates the substring from scratch each time. We can improve this by using a sliding window technique, where we keep track of the current substring using two pointers, left and right, and adjust the window as necessary. A hash set is used to track characters in the current window, allowing us to efficiently check for duplicates.
+
+1. Use two pointers (left and right) to create a window of characters.
+2. Expand the window by moving the right pointer.
+3. If a duplicate character is found, shrink the window from the left by moving the left pointer until the duplicate is removed.
+4. Track the maximum length of the window during this process.
+
+Steps:
+1. Initialize a set to store the characters in the current window.
+2. Move the right pointer to expand the window.
+3. If the character at right is already in the set, move the left pointer to shrink the window until the character is removed.
+4. Keep updating the maximum length of the window.
+##### Visualization:
+```perl
+For s = "abcabcbb":
+
+Initial state: left = 0, right = 0, window = ""
+Step 1: Expand window to "a"
+Step 2: Expand window to "ab"
+Step 3: Expand window to "abc" (max_len = 3)
+Step 4: Encounter duplicate 'a', move left to 1 (window = "bca")
+Step 5: Expand window to "bcab" → encounter duplicate 'b', move left to 2 (window = "cab")
+Continue until the entire string is processed.
+```
+##### Time Complexity:
+O(n), where n is the length of the string. We traverse the string once with the sliding window.
+##### Space Complexity:
+O(min(n, m)), where n is the length of the string and m is the size of the character set (e.g., 26 for lowercase English letters).
+##### Python Code:
+```python
+def lengthOfLongestSubstring(s: str) -> int:
+    char_set = set()
+    left = 0
+    max_len = 0
+    
+    for right in range(len(s)):
+        # Shrink the window if we encounter a duplicate character
+        while s[right] in char_set:
+            char_set.remove(s[left])
+            left += 1
+        
+        # Add the current character to the window
+        char_set.add(s[right])
+        
+        # Update the maximum length
+        max_len = max(max_len, right - left + 1)
+    
+    return max_len
+```
+### Approach 3: Sliding Window with Hash Map
+##### Intuition: 
+A further optimization can be made by using a hash map to store the last index of each character. This allows us to move the left pointer directly to the position after the last occurrence of the duplicate character, rather than shrinking the window one character at a time.
+
+Steps:
+1. Initialize a hash map to store the last index of each character.
+2. Move the right pointer to expand the window.
+3. If a duplicate character is found, move the left pointer directly to the position after the last occurrence of the duplicate.
+4. Track the maximum length of the window.
+##### Visualization:
+```perl
+For s = "abcabcbb":
+
+Initial state: left = 0, right = 0, window = "", last_occurrence = {}
+Step 1: Expand window to "a" → last_occurrence['a'] = 0
+Step 2: Expand window to "ab" → last_occurrence['b'] = 1
+Step 3: Expand window to "abc" → last_occurrence['c'] = 2
+Step 4: Encounter duplicate 'a', move left to 1 (after last 'a')
+Continue until the entire string is processed.
+```
+##### Time Complexity:
+O(n), as we still traverse the string once, but this time we move the left pointer more efficiently.
+##### Space Complexity:
+O(min(n, m)), where n is the length of the string and m is the size of the character set.
+##### Python Code:
+```python
+def lengthOfLongestSubstring(s: str) -> int:
+    char_index_map = {}
+    left = 0
+    max_len = 0
+    
+    for right in range(len(s)):
+        # If the character is already in the map, move the left pointer
+        if s[right] in char_index_map:
+            left = max(left, char_index_map[s[right]] + 1)
+        
+        # Update the last occurrence of the current character
+        char_index_map[s[right]] = right
+        
+        # Update the maximum length of the window
+        max_len = max(max_len, right - left + 1)
+    
+    return max_len
+```
+## Summary
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force	                    | 	O(n²)      | O(n)             |
+| Sliding Window with Hash Set		                   | O(n)            | O(min(n, m))             |
+| Sliding Window with Hash Map		                   | O(n)            | O(min(n, m))             |
+
+The Sliding Window with Hash Map is the most efficient approach because it uses a single pass over the string and minimizes the movement of the left pointer by jumping directly to the correct position.

python/maximum-average-subarray-1.md

@@ -0,0 +1,93 @@
+# Maximum Average Subarray I 
+You are given an integer array nums consisting of n elements, and an integer k. Find the contiguous subarray of length k that has the maximum average value and return this value.
+
+### Constraints:
+- n == nums.length
+- 1 <= k <= n <= 10^5
+- -10^4 <= nums[i] <= 10^4
+
+### Examples
+```javascript
+Input: nums = [1,12,-5,-6,50,3], k = 4
+Output: 12.75
+Explanation: Maximum average is (12 - 5 - 6 + 50) / 4 = 12.75
+
+Input: nums = [5], k = 1
+Output: 5.0
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+A brute force approach would involve checking all possible subarrays of length k and calculating their averages. This can be done by looping over each possible starting index, calculating the sum of the subarray, and keeping track of the maximum sum.
+
+Steps:
+1. Loop through the array from index 0 to n - k.
+2. For each index i, calculate the sum of the subarray starting at i and ending at i + k - 1.
+3. Track the maximum sum.
+4. Return the maximum sum divided by k as the maximum average.
+##### Time Complexity:
+O(n * k), where n is the length of the array. For each element, we compute the sum of a subarray of length k.
+##### Space Complexity:
+O(1), as no extra space is used beyond the variables.
+##### Python Code:
+```python
+def findMaxAverage(nums: List[int], k: int) -> float:
+    max_sum = float('-inf')
+    n = len(nums)
+    
+    for i in range(n - k + 1):
+        current_sum = sum(nums[i:i+k])
+        max_sum = max(max_sum, current_sum)
+    
+    return max_sum / k
+```
+### Approach 2: Sliding Window (Optimal Solution)
+##### Intuition: 
+The brute force approach is inefficient because we are recalculating the sum of each subarray from scratch. Instead, we can use the sliding window technique to optimize this. The sliding window technique allows us to update the sum of the subarray by subtracting the element that is sliding out of the window and adding the element that is sliding into the window.
+
+Steps:
+1. Calculate the sum of the first k elements.
+2. For each subsequent subarray, update the sum by subtracting the element that is leaving the window (at index i - k) and adding the element that is entering the window (at index i).
+3. Track the maximum sum.
+4. Return the maximum sum divided by k as the maximum average.
+##### Visualization:
+```perl
+For nums = [1,12,-5,-6,50,3] and k = 4:
+
+Initial window: [1, 12, -5, -6], sum = 2
+Move window:
+New window: [12, -5, -6, 50], sum = 51 (max updated)
+Move window:
+New window: [-5, -6, 50, 3], sum = 42 (max stays 51)
+```
+##### Time Complexity:
+O(n), where n is the length of the array. We calculate the sum for each subarray by adjusting the previous sum in constant time.
+##### Space Complexity:
+O(1), as no extra space is used beyond the variables for the sliding window.
+##### Python Code:
+```python
+def findMaxAverage(nums: List[int], k: int) -> float:
+    # Step 1: Calculate the sum of the first k elements
+    current_sum = sum(nums[:k])
+    max_sum = current_sum
+    
+    # Step 2: Slide the window over the array
+    for i in range(k, len(nums)):
+        current_sum += nums[i] - nums[i - k]  # Slide the window
+        max_sum = max(max_sum, current_sum)    # Update max sum
+    
+    # Step 3: Return the maximum average
+    return max_sum / k
+```
+#### Edge Cases:
+1. Single element array: If k == 1 and the array has only one element, the result is just that element.
+2. All elements are the same: The sliding window will return the average of any subarray, as all values are the same.
+3. Negative numbers: The solution should correctly handle arrays with negative numbers and return the correct maximum average.
+## Summary
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force	                    | O(n * k)      | O(1)             |
+| Sliding Window (Optimal)	                          | O(n)            | O(1)             |
+
+The Sliding Window approach is the most efficient solution, allowing us to find the maximum average subarray in O(n) time. It leverages the fact that we can update the sum incrementally rather than recalculating it from scratch.

python/minimum-size-subarray-sum.md

@@ -0,0 +1,126 @@
+# Minimum Size Subarray Sum 
+Given an array of positive integers nums and a positive integer target, return the minimal length of a contiguous subarray [nums[l], nums[l+1], ..., nums[r-1], nums[r]] of which the sum is greater than or equal to target. If there is no such subarray, return 0 instead.
+
+### Constraints:
+- 1 <= target <= 10^9
+- 1 <= nums.length <= 10^5
+- 1 <= nums[i] <= 10^5
+
+### Examples
+```javascript
+Input: target = 7, nums = [2,3,1,2,4,3]
+Output: 2
+Explanation: The subarray [4,3] has the minimal length under the problem constraint.
+
+Input: target = 4, nums = [1,4,4]
+Output: 1
+
+Input: target = 11, nums = [1,1,1,1,1,1,1,1]
+Output: 0
+```
+
+## Approaches to Solve the Problem
+### Approach 1: Brute Force (Inefficient)
+##### Intuition:
+In the brute-force approach, we consider every possible subarray in the array. For each subarray, we compute its sum and check if it meets or exceeds the target. We track the minimum subarray length.
+
+Steps:
+1. Use two nested loops to consider all subarrays.
+2. For each subarray, calculate its sum.
+3. If the sum is greater than or equal to the target, update the minimum subarray length.
+4. Return the minimum length found.
+##### Time Complexity:
+O(n²), where n is the length of the array. This approach checks every subarray.
+##### Space Complexity:
+O(1), as no extra space is used beyond variables for tracking the subarray sum and length.
+##### Python Code:
+```python
+def minSubArrayLen(target: int, nums: List[int]) -> int:
+    n = len(nums)
+    min_len = float('inf')
+    
+    for i in range(n):
+        current_sum = 0
+        for j in range(i, n):
+            current_sum += nums[j]
+            if current_sum >= target:
+                min_len = min(min_len, j - i + 1)
+                break
+    
+    return 0 if min_len == float('inf') else min_len
+```
+### Approach 2: Sliding Window (Optimal Solution)
+##### Intuition: 
+The brute-force approach is inefficient because we are recalculating the sum for every subarray from scratch. We can improve this by using the sliding window technique. The idea is to maintain a window (a subarray) with two pointers, left and right, and dynamically adjust the window size as we traverse the array.
+
+Start by expanding the window by moving the right pointer until the window’s sum is greater than or equal to the target.
+Once the window's sum is valid, shrink the window by moving the left pointer inward to minimize its size while keeping the sum greater than or equal to the target.
+
+Steps:
+1. Initialize two pointers left and right at the start of the array.
+2. Maintain a running sum of the elements in the window.
+3. Expand the window by moving right and adding the current element to the running sum.
+4. If the sum is greater than or equal to the target, update the minimum length and move the left pointer 5.inward to try and shrink the window.
+5. Repeat until right reaches the end of the array.
+##### Visualization:
+```perl
+For target = 7 and nums = [2,3,1,2,4,3]:
+
+Initial state: left = 0, right = 0, sum = 0
+
+Step 1: Expand the window
+    right = 0, sum = 2
+
+Step 2: Expand the window
+    right = 1, sum = 5
+
+Step 3: Expand the window
+    right = 2, sum = 6
+
+Step 4: Expand the window
+    right = 3, sum = 8 (valid window), update min_len = 4, shrink window from left
+
+Step 5: Shrink window
+    left = 1, sum = 6
+
+Step 6: Expand the window
+    right = 4, sum = 10 (valid window), update min_len = 2
+
+Step 7: Shrink window
+    left = 2, sum = 7 (valid window), update min_len = 2
+
+Step 8: Shrink window further until left = 3, then exit.
+```
+##### Time Complexity:
+O(n), where n is the length of the array. We traverse the array once with the sliding window.
+##### Space Complexity:
+O(1), as no extra space is used beyond the sliding window and a few variables.
+##### Python Code:
+```python
+def minSubArrayLen(target: int, nums: List[int]) -> int:
+    left = 0
+    current_sum = 0
+    min_len = float('inf')
+    
+    for right in range(len(nums)):
+        current_sum += nums[right]
+        
+        # Shrink the window while sum is greater than or equal to target
+        while current_sum >= target:
+            min_len = min(min_len, right - left + 1)
+            current_sum -= nums[left]
+            left += 1
+    
+    return 0 if min_len == float('inf') else min_len
+```
+#### Edge Cases:
+1. Target larger than the total sum: If the sum of all elements in nums is less than target, the function should return 0.
+2. Single element array: If the array has only one element, the function should handle this case properly by checking if the element is greater than or equal to the target.
+3. All elements are smaller than target: If all elements are smaller than the target, the algorithm should correctly identify the minimal subarray that meets the condition.
+## Summary
+| Approach                         | Time Complexity | Space Complexity |
+|-----------------------------------|-----------------|------------------|
+| Brute Force	                    | 	O(n²)      | O(1)             |
+| Sliding Window (Optimal)	                          | O(n)            | O(1)             |
+
+The Sliding Window approach is the most efficient solution. It processes the array in linear time and adjusts the window dynamically, making it the optimal solution for this problem.