Merge branch 'master' into greedy-set-cover

benchaddha · web-flow · commit c5d0461b752f · 2026-02-11T20:13:20.000-05:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - run: sudo apt-get update && sudo apt-get install -y libhdf5-dev
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
         with:
           enable-cache: true
diff --git a/.github/workflows/devcontainer_ci.yml b/.github/workflows/devcontainer_ci.yml
@@ -12,7 +12,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: devcontainers/ci@v0.3
         with:
           push: never
diff --git a/.github/workflows/directory_writer.yml b/.github/workflows/directory_writer.yml
@@ -6,7 +6,7 @@ jobs:
   directory_writer:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - uses: actions/setup-python@v6
diff --git a/.github/workflows/project_euler.yml b/.github/workflows/project_euler.yml
@@ -21,7 +21,7 @@ jobs:
           libxml2-dev libxslt-dev
           libhdf5-dev
           libopenblas-dev
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
       - uses: actions/setup-python@v6
         with:
@@ -39,7 +39,7 @@ jobs:
           libxml2-dev libxslt-dev
           libhdf5-dev
           libopenblas-dev
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
       - uses: actions/setup-python@v6
         with:
diff --git a/.github/workflows/ruff.yml b/.github/workflows/ruff.yml
@@ -11,6 +11,6 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
       - run: uvx ruff check --output-format=github .
diff --git a/.github/workflows/sphinx.yml b/.github/workflows/sphinx.yml
@@ -32,7 +32,7 @@ jobs:
           libxml2-dev libxslt-dev
           libhdf5-dev
           libopenblas-dev
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - uses: astral-sh/setup-uv@v7
       - uses: actions/setup-python@v6
         with:
diff --git a/.pre-commit-config.yaml b/.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.3
+    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.0
+    rev: v2.12.1
     hooks:
       - id: pyproject-fmt
 
@@ -50,7 +50,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.18.2
+    rev: v1.19.1
     hooks:
       - id: mypy
         args:
diff --git a/DIRECTORY.md b/DIRECTORY.md
@@ -398,6 +398,7 @@
   * [Minimum Squares To Represent A Number](dynamic_programming/minimum_squares_to_represent_a_number.py)
   * [Minimum Steps To One](dynamic_programming/minimum_steps_to_one.py)
   * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
+  * [Narcissistic Number](dynamic_programming/narcissistic_number.py)
   * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
   * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
   * [Range Sum Query](dynamic_programming/range_sum_query.py)
@@ -880,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)
 
diff --git a/ciphers/caesar_cipher.py b/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).
 
diff --git a/dynamic_programming/narcissistic_number.py b/dynamic_programming/narcissistic_number.py
@@ -0,0 +1,103 @@
+"""
+Find all narcissistic numbers up to a given limit using dynamic programming.
+
+A narcissistic number (also known as an Armstrong number or plus perfect number)
+is a number that is the sum of its own digits each raised to the power of the
+number of digits.
+
+For example, 153 is a narcissistic number because 153 = 1^3 + 5^3 + 3^3.
+
+This implementation uses dynamic programming with memoization to efficiently
+compute digit powers and find all narcissistic numbers up to a specified limit.
+
+The DP optimization caches digit^power calculations. When searching through many
+numbers, the same digit power calculations occur repeatedly (e.g., 153, 351, 135
+all need 1^3, 5^3, 3^3). Memoization avoids these redundant calculations.
+
+Examples of narcissistic numbers:
+    Single digit: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+    Three digit: 153, 370, 371, 407
+    Four digit: 1634, 8208, 9474
+    Five digit: 54748, 92727, 93084
+
+Reference: https://en.wikipedia.org/wiki/Narcissistic_number
+"""
+
+
+def find_narcissistic_numbers(limit: int) -> list[int]:
+    """
+    Find all narcissistic numbers up to the given limit using dynamic programming.
+
+    This function uses memoization to cache digit power calculations, avoiding
+    redundant computations across different numbers with the same digit count.
+
+    Args:
+        limit: The upper bound for searching narcissistic numbers (exclusive)
+
+    Returns:
+        list[int]: A sorted list of all narcissistic numbers below the limit
+
+    Examples:
+        >>> find_narcissistic_numbers(10)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+        >>> find_narcissistic_numbers(160)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153]
+        >>> find_narcissistic_numbers(400)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371]
+        >>> find_narcissistic_numbers(1000)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407]
+        >>> find_narcissistic_numbers(10000)
+        [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 153, 370, 371, 407, 1634, 8208, 9474]
+        >>> find_narcissistic_numbers(1)
+        [0]
+        >>> find_narcissistic_numbers(0)
+        []
+    """
+    if limit <= 0:
+        return []
+
+    narcissistic_nums = []
+
+    # Memoization: cache[(power, digit)] = digit^power
+    # This avoids recalculating the same power for different numbers
+    power_cache: dict[tuple[int, int], int] = {}
+
+    def get_digit_power(digit: int, power: int) -> int:
+        """Get digit^power using memoization (DP optimization)."""
+        if (power, digit) not in power_cache:
+            power_cache[(power, digit)] = digit**power
+        return power_cache[(power, digit)]
+
+    # Check each number up to the limit
+    for number in range(limit):
+        # Count digits
+        num_digits = len(str(number))
+
+        # Calculate sum of powered digits using memoized powers
+        remaining = number
+        digit_sum = 0
+        while remaining > 0:
+            digit = remaining % 10
+            digit_sum += get_digit_power(digit, num_digits)
+            remaining //= 10
+
+        # Check if narcissistic
+        if digit_sum == number:
+            narcissistic_nums.append(number)
+
+    return narcissistic_nums
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    # Demonstrate the dynamic programming approach
+    print("Finding all narcissistic numbers up to 10000:")
+    print("(Using memoization to cache digit power calculations)")
+    print()
+
+    narcissistic_numbers = find_narcissistic_numbers(10000)
+    print(f"Found {len(narcissistic_numbers)} narcissistic numbers:")
+    print(narcissistic_numbers)
diff --git a/other/sliding_window_maximum.py b/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
diff --git a/searches/binary_search.py b/searches/binary_search.py
@@ -243,6 +243,81 @@ def binary_search_std_lib(sorted_collection: list[int], item: int) -> int:
     return -1
 
 
+def binary_search_with_duplicates(sorted_collection: list[int], item: int) -> list[int]:
+    """Pure implementation of a binary search algorithm in Python that supports
+    duplicates.
+
+    Resources used:
+    https://stackoverflow.com/questions/13197552/using-binary-search-with-sorted-array-with-duplicates
+
+    The collection must be sorted in ascending order; otherwise the result will be
+    unpredictable. If the target appears multiple times, this function returns a
+    list of all indexes where the target occurs. If the target is not found,
+    this function returns an empty list.
+
+    :param sorted_collection: some ascending sorted collection with comparable items
+    :param item: item value to search for
+    :return: a list of indexes where the item is found (empty list if not found)
+
+    Examples:
+    >>> binary_search_with_duplicates([0, 5, 7, 10, 15], 0)
+    [0]
+    >>> binary_search_with_duplicates([0, 5, 7, 10, 15], 15)
+    [4]
+    >>> binary_search_with_duplicates([1, 2, 2, 2, 3], 2)
+    [1, 2, 3]
+    >>> binary_search_with_duplicates([1, 2, 2, 2, 3], 4)
+    []
+    """
+    if list(sorted_collection) != sorted(sorted_collection):
+        raise ValueError("sorted_collection must be sorted in ascending order")
+
+    def lower_bound(sorted_collection: list[int], item: int) -> int:
+        """
+        Returns the index of the first element greater than or equal to the item.
+
+        :param sorted_collection: The sorted list to search.
+        :param item: The item to find the lower bound for.
+        :return: The index where the item can be inserted while maintaining order.
+        """
+        left = 0
+        right = len(sorted_collection)
+        while left < right:
+            midpoint = left + (right - left) // 2
+            current_item = sorted_collection[midpoint]
+            if current_item < item:
+                left = midpoint + 1
+            else:
+                right = midpoint
+        return left
+
+    def upper_bound(sorted_collection: list[int], item: int) -> int:
+        """
+        Returns the index of the first element strictly greater than the item.
+
+        :param sorted_collection: The sorted list to search.
+        :param item: The item to find the upper bound for.
+        :return: The index where the item can be inserted after all existing instances.
+        """
+        left = 0
+        right = len(sorted_collection)
+        while left < right:
+            midpoint = left + (right - left) // 2
+            current_item = sorted_collection[midpoint]
+            if current_item <= item:
+                left = midpoint + 1
+            else:
+                right = midpoint
+        return left
+
+    left = lower_bound(sorted_collection, item)
+    right = upper_bound(sorted_collection, item)
+
+    if left == len(sorted_collection) or sorted_collection[left] != item:
+        return []
+    return list(range(left, right))
+
+
 def binary_search_by_recursion(
     sorted_collection: list[int], item: int, left: int = 0, right: int = -1
 ) -> int:
diff --git a/strings/reverse_words.py b/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__":
