diff --git a/data_structures/arrays/fruit_into_baskets.py b/data_structures/arrays/fruit_into_baskets.py
new file mode 100644
index 000000000000..a2b5b2554e30
--- /dev/null
+++ b/data_structures/arrays/fruit_into_baskets.py
@@ -0,0 +1,38 @@
+from collections import defaultdict
+
+
+class FruitIntoBaskets:
+    """
+    Problem:
+    Given an array of integers representing types of fruit, pick a contiguous
+    subarray containing at most two different types of fruit. Return the maximum
+    number of fruits you can collect.
+
+    Example:
+    >>> solver = FruitIntoBaskets()
+    >>> solver.total_fruit([1, 2, 1, 2, 3])
+    4
+    """
+
+    def total_fruit(self, fruits: list[int]) -> int:
+        count = defaultdict(int)
+        left = 0
+        max_fruit = 0
+
+        for right, fruit in enumerate(fruits):
+            count[fruit] += 1
+
+            while len(count) > 2:
+                count[fruits[left]] -= 1
+                if count[fruits[left]] == 0:
+                    del count[fruits[left]]
+                left += 1
+
+            max_fruit = max(max_fruit, right - left + 1)
+
+        return max_fruit
+
+
+if __name__ == "__main__":
+    solver = FruitIntoBaskets()
+    print("Maximum Fruits Collected:", solver.total_fruit([1, 2, 1, 2, 3]))
diff --git a/data_structures/arrays/longest_ones_after_replacement.py b/data_structures/arrays/longest_ones_after_replacement.py
new file mode 100644
index 000000000000..a88d3b090c46
--- /dev/null
+++ b/data_structures/arrays/longest_ones_after_replacement.py
@@ -0,0 +1,38 @@
+class LongestOnesAfterReplacement:
+    """
+    Problem:
+    Given a binary array and an integer max_zero_flips, find the length of the
+    longest subarray containing only 1s after flipping at most max_zero_flips
+    zeros.
+
+    Example:
+    >>> solver = LongestOnesAfterReplacement()
+    >>> solver.longest_ones([1, 0, 1, 1, 0, 1], 1)
+    4
+    """
+
+    def longest_ones(self, nums: list[int], max_zero_flips: int) -> int:
+        left = 0
+        max_len = 0
+        zeros_count = 0
+
+        for right in range(len(nums)):
+            if nums[right] == 0:
+                zeros_count += 1
+
+            while zeros_count > max_zero_flips:
+                if nums[left] == 0:
+                    zeros_count -= 1
+                left += 1
+
+            max_len = max(max_len, right - left + 1)
+
+        return max_len
+
+
+if __name__ == "__main__":
+    solver = LongestOnesAfterReplacement()
+    print(
+        "Longest Ones After Replacement:",
+        solver.longest_ones([1, 0, 1, 1, 0, 1], 1),
+    )
diff --git a/data_structures/arrays/sliding_window_maximum.py b/data_structures/arrays/sliding_window_maximum.py
new file mode 100644
index 000000000000..4287f4e9af5f
--- /dev/null
+++ b/data_structures/arrays/sliding_window_maximum.py
@@ -0,0 +1,43 @@
+from collections import deque
+
+
+class SlidingWindowMaximum:
+    """
+    Problem:
+    Given an integer array and a window_size, return the maximum value in each
+    sliding window of that size.
+
+    Example:
+    >>> solver = SlidingWindowMaximum()
+    >>> solver.max_sliding_window([1, 3, -1, -3, 5, 3, 6, 7], 3)
+    [3, 3, 5, 5, 6, 7]
+    """
+
+    def max_sliding_window(self, nums: list[int], window_size: int) -> list[int]:
+        if not nums:
+            return []
+
+        result = []
+        window = deque()
+
+        for i, num in enumerate(nums):
+            while window and window[0] <= i - window_size:
+                window.popleft()
+
+            while window and nums[window[-1]] < num:
+                window.pop()
+
+            window.append(i)
+
+            if i >= window_size - 1:
+                result.append(nums[window[0]])
+
+        return result
+
+
+if __name__ == "__main__":
+    solver = SlidingWindowMaximum()
+    print(
+        "Sliding Window Maximum:",
+        solver.max_sliding_window([1, 3, -1, -3, 5, 3, 6, 7], 3),
+    )