Adding sliding window algorithm

I added three Python examples that demonstrate the sliding window technique.

Author: lydia321

data_structures/sliding_window/longest_substring_two_distinct.py

@@ -0,0 +1,47 @@
+def length_of_longest_substring_two_distinct(s):
+    """
+    Finds the length of the longest substring with at most two distinct characters.
+
+    Args:
+    s (str): The input string.
+
+    Returns:
+    int: The length of the longest substring with at most two distinct characters.
+
+    Examples:
+    >>> length_of_longest_substring_two_distinct("eceba")
+    3
+    >>> length_of_longest_substring_two_distinct("ccaabbb")
+    5
+    >>> length_of_longest_substring_two_distinct("abcabcabc")
+    2
+    >>> length_of_longest_substring_two_distinct("")
+    0
+    """
+    n = len(s)
+    if n == 0:
+        return 0
+    
+    # Dictionary to store the last occurrence of each character
+    char_map = {}
+    left = 0
+    max_length = 0
+    
+    # Sliding window approach
+    for right in range(n):
+        char_map[s[right]] = right
+        
+        # If we have more than two distinct characters
+        if len(char_map) > 2:
+            # Remove the leftmost character
+            del_idx = min(char_map.values())
+            del char_map[s[del_idx]]
+            left = del_idx + 1
+        
+        max_length = max(max_length, right - left + 1)
+    
+    return max_length
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

data_structures/sliding_window/max_sum_subarray.py

@@ -0,0 +1,40 @@
+def max_sum_subarray(arr, k):
+    """
+    Finds the maximum sum of a subarray of length k within the given array.
+
+    Args:
+    arr (list): The input array.
+    k (int): The length of the subarray.
+
+    Returns:
+    int: The maximum sum of a subarray of length k.
+
+    Examples:
+    >>> max_sum_subarray([1, 2, 3, 4, 5], 2)
+    9
+    >>> max_sum_subarray([1, 2, 3, 4, 5], 3)
+    12
+    >>> max_sum_subarray([1, 2, 3, 4, 5], 6)
+    Invalid input: k is larger than the array size
+    >>> max_sum_subarray([], 1)
+    Invalid input: k is larger than the array size
+    """
+    n = len(arr)
+    if n < k or k <= 0:
+        print("Invalid input: k is larger than the array size or non-positive")
+        return None
+    
+    # Calculate the sum of the first window of size k
+    window_sum = sum(arr[:k])
+    max_sum = window_sum
+    
+    # Slide the window from start to end of the array
+    for i in range(n - k):
+        window_sum = window_sum - arr[i] + arr[i + k]
+        max_sum = max(max_sum, window_sum)
+    
+    return max_sum
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()

data_structures/sliding_window/min_subarray_len.py

@@ -0,0 +1,39 @@
+def min_subarray_len(target, nums):
+    """
+    Finds the minimal length of a contiguous subarray of which the sum is at least the target.
+
+    Args:
+    target (int): The target sum.
+    nums (list): The list of positive integers.
+
+    Returns:
+    int: The minimal length of a contiguous subarray with a sum at least equal to the target, or 0 if no such subarray exists.
+
+    Examples:
+    >>> min_subarray_len(7, [2,3,1,2,4,3])
+    2
+    >>> min_subarray_len(4, [1,4,4])
+    1
+    >>> min_subarray_len(11, [1,1,1,1,1,1,1,1])
+    0
+    >>> min_subarray_len(15, [5,1,3,5,10,7,4,9,2,8])
+    2
+    """
+    n = len(nums)
+    left = 0
+    current_sum = 0
+    min_length = float('inf')
+    
+    for right in range(n):
+        current_sum += nums[right]
+        
+        while current_sum >= target:
+            min_length = min(min_length, right - left + 1)
+            current_sum -= nums[left]
+            left += 1
+    
+    return min_length if min_length != float('inf') else 0
+
+if __name__ == "__main__":
+    import doctest
+    doctest.testmod()