Merge branch 'master' into fix/binary-search-duplicates-13840

Author: adityarohatgi11

.pre-commit-config.yaml

@@ -14,12 +14,12 @@ repos:
       - id: requirements-txt-fixer
 
   - repo: https://github.com/MarcoGorelli/auto-walrus
-    rev: 0.3.4
+    rev: 0.4.1
     hooks:
       - id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.10
+    rev: v0.14.14
     hooks:
       - id: ruff-check
       - id: ruff-format
@@ -32,7 +32,7 @@ repos:
           - tomli
 
   - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: v2.11.1
+    rev: v2.12.1
     hooks:
       - id: pyproject-fmt
 

DIRECTORY.md

@@ -881,6 +881,7 @@
   * [Quine](other/quine.py)
   * [Scoring Algorithm](other/scoring_algorithm.py)
   * [Sdes](other/sdes.py)
+  * [Sliding Window Maximum](other/sliding_window_maximum.py)
   * [Tower Of Hanoi](other/tower_of_hanoi.py)
   * [Word Search](other/word_search.py)
 

ciphers/caesar_cipher.py

@@ -45,7 +45,7 @@ def encrypt(input_string: str, key: int, alphabet: str | None = None) -> str:
     And our shift is ``2``
 
     We can then encode the message, one letter at a time. ``H`` would become ``J``,
-    since ``J`` is two letters away, and so on. If the shift is ever two large, or
+    since ``J`` is two letters away, and so on. If the shift is ever too large, or
     our letter is at the end of the alphabet, we just start at the beginning
     (``Z`` would shift to ``a`` then ``b`` and so on).
 

other/sliding_window_maximum.py

@@ -0,0 +1,58 @@
+from collections import deque
+
+
+def sliding_window_maximum(numbers: list[int], window_size: int) -> list[int]:
+    """
+    Return a list containing the maximum of each sliding window of size window_size.
+
+    This implementation uses a monotonic deque to achieve O(n) time complexity.
+
+    Args:
+        numbers: List of integers representing the input array.
+        window_size: Size of the sliding window (must be positive).
+
+    Returns:
+        List of maximum values for each valid window.
+
+    Raises:
+        ValueError: If window_size is not a positive integer.
+
+    Time Complexity: O(n) - each element is added and removed at most once
+    Space Complexity: O(k) - deque stores at most window_size indices
+
+    Examples:
+    >>> sliding_window_maximum([1, 3, -1, -3, 5, 3, 6, 7], 3)
+    [3, 3, 5, 5, 6, 7]
+    >>> sliding_window_maximum([9, 11], 2)
+    [11]
+    >>> sliding_window_maximum([], 3)
+    []
+    >>> sliding_window_maximum([4, 2, 12, 3], 1)
+    [4, 2, 12, 3]
+    >>> sliding_window_maximum([1], 1)
+    [1]
+    """
+    if window_size <= 0:
+        raise ValueError("Window size must be a positive integer")
+    if not numbers:
+        return []
+
+    result: list[int] = []
+    index_deque: deque[int] = deque()
+
+    for current_index, current_value in enumerate(numbers):
+        # Remove the element which is out of this window
+        if index_deque and index_deque[0] == current_index - window_size:
+            index_deque.popleft()
+
+        # Remove useless elements (smaller than current) from back
+        while index_deque and numbers[index_deque[-1]] < current_value:
+            index_deque.pop()
+
+        index_deque.append(current_index)
+
+        # Start adding to result once we have a full window
+        if current_index >= window_size - 1:
+            result.append(numbers[index_deque[0]])
+
+    return result

strings/reverse_words.py

@@ -1,12 +1,14 @@
-def reverse_words(input_str: str) -> str:
-    """
-    Reverses words in a given string
+def reverse_words(sentence: str) -> str:
+    """Reverse the order of words in a given string.
+
+    Extra whitespace between words is ignored.
+
     >>> reverse_words("I love Python")
     'Python love I'
     >>> reverse_words("I     Love          Python")
     'Python Love I'
     """
-    return " ".join(input_str.split()[::-1])
+    return " ".join(sentence.split()[::-1])
 
 
 if __name__ == "__main__":