[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

project_euler/problem_145/sol1.py

@@ -17,94 +17,94 @@
 
 def solution(max_power: int = 9) -> int:
     """
-This solution counts reversible numbers below 10^max_power
-using mathematical patterns instead of brute force.
+    This solution counts reversible numbers below 10^max_power
+    using mathematical patterns instead of brute force.
 
-A reversible number is a number where:
-    n + reverse(n)
+    A reversible number is a number where:
+        n + reverse(n)
 
-contains only odd digits.
+    contains only odd digits.
 
-Example:
-    36 + 63 = 99
-    409 + 904 = 1313
+    Example:
+        36 + 63 = 99
+        409 + 904 = 1313
 
-Instead of checking every number one by one, we observe
-some repeating patterns based on the number of digits.
+    Instead of checking every number one by one, we observe
+    some repeating patterns based on the number of digits.
 
---------------------------------------------------------
-Main Observations
---------------------------------------------------------
+    --------------------------------------------------------
+    Main Observations
+    --------------------------------------------------------
 
-1. Numbers with length = 1 (mod 4)
-----------------------------------
-These lengths never work because the carry pattern becomes
-inconsistent while adding the number and its reverse.
+    1. Numbers with length = 1 (mod 4)
+    ----------------------------------
+    These lengths never work because the carry pattern becomes
+    inconsistent while adding the number and its reverse.
 
-Examples:
-    1 digit, 5 digits, 9 digits ...
+    Examples:
+        1 digit, 5 digits, 9 digits ...
 
-Count = 0
+    Count = 0
 
 
-2. Even length numbers
------------------------
-For numbers with even digits (2, 4, 6, 8 ...):
+    2. Even length numbers
+    -----------------------
+    For numbers with even digits (2, 4, 6, 8 ...):
 
-- Each pair of digits must produce an odd sum.
-- One digit in the pair must be even and the other odd.
-- The carry pattern stays consistent.
+    - Each pair of digits must produce an odd sum.
+    - One digit in the pair must be even and the other odd.
+    - The carry pattern stays consistent.
 
-Counting possibilities:
-    - First pair has 20 valid combinations
-      (leading digit cannot be zero)
+    Counting possibilities:
+        - First pair has 20 valid combinations
+          (leading digit cannot be zero)
 
-    - Every inner pair has 30 valid combinations
+        - Every inner pair has 30 valid combinations
 
-Formula:
-    20 * 30^(k-1)
+    Formula:
+        20 * 30^(k-1)
 
-where:
-    length = 2k
+    where:
+        length = 2k
 
-Examples:
-    2 digits  -> 20
-    4 digits  -> 600
-    6 digits  -> 18000
-    8 digits  -> 540000
+    Examples:
+        2 digits  -> 20
+        4 digits  -> 600
+        6 digits  -> 18000
+        8 digits  -> 540000
 
 
-3. Length = 3 (mod 4)
-----------------------
-These are lengths like:
-    3, 7, 11 ...
+    3. Length = 3 (mod 4)
+    ----------------------
+    These are lengths like:
+        3, 7, 11 ...
 
-Here the middle digit creates a special carry cycle,
-which only works for lengths of the form:
+    Here the middle digit creates a special carry cycle,
+    which only works for lengths of the form:
 
-    4j + 3
+        4j + 3
 
-Formula:
-    100 * 500^j
+    Formula:
+        100 * 500^j
 
-Examples:
-    3 digits -> 100
-    7 digits -> 50000
+    Examples:
+        3 digits -> 100
+        7 digits -> 50000
 
 
---------------------------------------------------------
-Complexity
---------------------------------------------------------
+    --------------------------------------------------------
+    Complexity
+    --------------------------------------------------------
 
-Time Complexity:
-    O(max_power)
+    Time Complexity:
+        O(max_power)
 
-Space Complexity:
-    O(1)
+    Space Complexity:
+        O(1)
 
-The algorithm is extremely fast because it only loops
-through digit lengths instead of checking every number.
-"""
+    The algorithm is extremely fast because it only loops
+    through digit lengths instead of checking every number.
+    """
     result = 0
     for length in range(1, max_power + 1):
         if length % 2 == 0:
@@ -114,7 +114,7 @@ def solution(max_power: int = 9) -> int:
         elif length % 4 == 3:
             # Odd length 4j+3 -> 100 x 500^j
             j = (length - 3) // 4
-            result += 100 * (500 ** j)
+            result += 100 * (500**j)
         # Lengths == 1 (mod 4) contribute 0 and are intentionally skipped.
 
     return result
@@ -132,4 +132,4 @@ def benchmark() -> None:
 
 if __name__ == "__main__":
     print(f"Solution : {solution()}")
-    benchmark()
+    benchmark()