Merge branch 'master' into use-deque-in-BFS-shortest-path

Author: MaximSmolskiy

.github/workflows/build.yml

@@ -9,7 +9,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true

.github/workflows/devcontainer_ci.yml

@@ -12,7 +12,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: devcontainers/[email protected]
         with:
           push: never

.github/workflows/directory_writer.yml

@@ -6,7 +6,7 @@ jobs:
   directory_writer:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - uses: actions/setup-python@v5

.github/workflows/project_euler.yml

@@ -14,7 +14,7 @@ jobs:
   project-euler:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v6
       - uses: actions/setup-python@v5
         with:
@@ -24,7 +24,7 @@ jobs:
   validate-solutions:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v6
       - uses: actions/setup-python@v5
         with:

.github/workflows/ruff.yml

@@ -11,6 +11,6 @@ jobs:
   ruff:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v6
       - run: uvx ruff check --output-format=github .

.github/workflows/sphinx.yml

@@ -25,7 +25,7 @@ jobs:
   build_docs:
     runs-on: ubuntu-24.04-arm
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
       - uses: astral-sh/setup-uv@v6
       - uses: actions/setup-python@v5
         with:
@@ -34,7 +34,7 @@ jobs:
       - run: uv sync --group=docs
       - uses: actions/configure-pages@v5
       - run: uv run sphinx-build -c docs . docs/_build/html
-      - uses: actions/upload-pages-artifact@v3
+      - uses: actions/upload-pages-artifact@v4
         with:
           path: docs/_build/html
 

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-executables-have-shebangs
       - id: check-toml
@@ -16,7 +16,7 @@ repos:
       - id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.5
+    rev: v0.12.9
     hooks:
       - id: ruff-check
       - id: ruff-format

README.md

@@ -27,8 +27,8 @@
   <a href="https://github.com/pre-commit/pre-commit">
     <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" height="20" alt="pre-commit">
   </a>
-  <a href="https://github.com/psf/black">
-    <img src="https://img.shields.io/static/v1?label=code%20style&message=black&color=black&style=flat-square" height="20" alt="code style: black">
+  <a href="https://docs.astral.sh/ruff/formatter/">
+    <img src="https://img.shields.io/static/v1?label=code%20style&message=ruff&color=black&style=flat-square" height="20" alt="code style: black">
   </a>
 <!-- Short description: -->
   <h3>All algorithms implemented in Python - for education</h3>

bit_manipulation/reverse_bits.py

@@ -1,83 +1,83 @@
 def get_reverse_bit_string(number: int) -> str:
     """
-    return the bit string of an integer
+    Return the reverse bit string of a 32 bit integer
 
     >>> get_reverse_bit_string(9)
     '10010000000000000000000000000000'
     >>> get_reverse_bit_string(43)
     '11010100000000000000000000000000'
     >>> get_reverse_bit_string(2873)
     '10011100110100000000000000000000'
+    >>> get_reverse_bit_string(2550136832)
+    '00000000000000000000000000011001'
     >>> get_reverse_bit_string("this is not a number")
     Traceback (most recent call last):
         ...
-    TypeError: operation can not be conducted on a object of type str
+    TypeError: operation can not be conducted on an object of type str
     """
     if not isinstance(number, int):
         msg = (
-            "operation can not be conducted on a object of type "
+            "operation can not be conducted on an object of type "
             f"{type(number).__name__}"
         )
         raise TypeError(msg)
     bit_string = ""
     for _ in range(32):
         bit_string += str(number % 2)
-        number = number >> 1
+        number >>= 1
     return bit_string
 
 
-def reverse_bit(number: int) -> str:
+def reverse_bit(number: int) -> int:
     """
-    Take in an 32 bit integer, reverse its bits,
-    return a string of reverse bits
-
-    result of a reverse_bit and operation on the integer provided.
+    Take in a 32 bit integer, reverse its bits, return a 32 bit integer result
 
     >>> reverse_bit(25)
-    '00000000000000000000000000011001'
+    2550136832
     >>> reverse_bit(37)
-    '00000000000000000000000000100101'
+    2751463424
     >>> reverse_bit(21)
-    '00000000000000000000000000010101'
+    2818572288
     >>> reverse_bit(58)
-    '00000000000000000000000000111010'
+    1543503872
     >>> reverse_bit(0)
-    '00000000000000000000000000000000'
+    0
     >>> reverse_bit(256)
-    '00000000000000000000000100000000'
+    8388608
+    >>> reverse_bit(2550136832)
+    25
     >>> reverse_bit(-1)
     Traceback (most recent call last):
         ...
-    ValueError: the value of input must be positive
+    ValueError: The value of input must be non-negative
 
     >>> reverse_bit(1.1)
     Traceback (most recent call last):
         ...
-    TypeError: Input value must be a 'int' type
+    TypeError: Input value must be an 'int' type
 
     >>> reverse_bit("0")
     Traceback (most recent call last):
         ...
-    TypeError: '<' not supported between instances of 'str' and 'int'
+    TypeError: Input value must be an 'int' type
     """
+    if not isinstance(number, int):
+        raise TypeError("Input value must be an 'int' type")
     if number < 0:
-        raise ValueError("the value of input must be positive")
-    elif isinstance(number, float):
-        raise TypeError("Input value must be a 'int' type")
-    elif isinstance(number, str):
-        raise TypeError("'<' not supported between instances of 'str' and 'int'")
+        raise ValueError("The value of input must be non-negative")
+
     result = 0
-    # iterator over [1 to 32],since we are dealing with 32 bit integer
-    for _ in range(1, 33):
+    # iterator over [0 to 31], since we are dealing with a 32 bit integer
+    for _ in range(32):
         # left shift the bits by unity
-        result = result << 1
+        result <<= 1
         # get the end bit
-        end_bit = number % 2
+        end_bit = number & 1
         # right shift the bits by unity
-        number = number >> 1
-        # add that bit to our ans
-        result = result | end_bit
-    return get_reverse_bit_string(result)
+        number >>= 1
+        # add that bit to our answer
+        result |= end_bit
+    return result
 
 
 if __name__ == "__main__":

boolean_algebra/imply_gate.py

@@ -33,6 +33,58 @@ def imply_gate(input_1: int, input_2: int) -> int:
     return int(input_1 == 0 or input_2 == 1)
 
 
+def recursive_imply_list(input_list: list[int]) -> int:
+    """
+    Recursively calculates the implication of a list.
+    Strictly the implication is applied consecutively left to right:
+    ( (a -> b) -> c ) -> d ...
+
+    >>> recursive_imply_list([])
+    Traceback (most recent call last):
+        ...
+    ValueError: Input list must contain at least two elements
+    >>> recursive_imply_list([0])
+    Traceback (most recent call last):
+        ...
+    ValueError: Input list must contain at least two elements
+    >>> recursive_imply_list([1])
+    Traceback (most recent call last):
+        ...
+    ValueError: Input list must contain at least two elements
+    >>> recursive_imply_list([0, 0])
+    1
+    >>> recursive_imply_list([0, 1])
+    1
+    >>> recursive_imply_list([1, 0])
+    0
+    >>> recursive_imply_list([1, 1])
+    1
+    >>> recursive_imply_list([0, 0, 0])
+    0
+    >>> recursive_imply_list([0, 0, 1])
+    1
+    >>> recursive_imply_list([0, 1, 0])
+    0
+    >>> recursive_imply_list([0, 1, 1])
+    1
+    >>> recursive_imply_list([1, 0, 0])
+    1
+    >>> recursive_imply_list([1, 0, 1])
+    1
+    >>> recursive_imply_list([1, 1, 0])
+    0
+    >>> recursive_imply_list([1, 1, 1])
+    1
+    """
+    if len(input_list) < 2:
+        raise ValueError("Input list must contain at least two elements")
+    first_implication = imply_gate(input_list[0], input_list[1])
+    if len(input_list) == 2:
+        return first_implication
+    new_list = [first_implication, *input_list[2:]]
+    return recursive_imply_list(new_list)
+
+
 if __name__ == "__main__":
     import doctest