Merge pull request #1 from TheAlgorithms/master

Add Kadane's algorithm for maximum subarray sum

Author: iamdevdhanush

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
       - id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.7
+    rev: v0.14.10
     hooks:
       - id: ruff-check
       - id: ruff-format
@@ -50,7 +50,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.19.0
+    rev: v1.19.1
     hooks:
       - id: mypy
         args:

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)

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)

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