Merge branch 'master' into feat/recursive-list-imply

Author: MaximSmolskiy

.github/workflows/sphinx.yml

@@ -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
 

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__":

scripts/build_directory_md.py

@@ -18,8 +18,20 @@ def good_file_paths(top_dir: str = ".") -> Iterator[str]:
                 yield os.path.join(dir_path, filename).lstrip("./")
 
 
-def md_prefix(i):
-    return f"{i * '  '}*" if i else "\n##"
+def md_prefix(indent: int) -> str:
+    """
+    Markdown prefix based on indent for bullet points
+
+    >>> md_prefix(0)
+    '\\n##'
+    >>> md_prefix(1)
+    '  *'
+    >>> md_prefix(2)
+    '    *'
+    >>> md_prefix(3)
+    '      *'
+    """
+    return f"{indent * '  '}*" if indent else "\n##"
 
 
 def print_path(old_path: str, new_path: str) -> str:

strings/capitalize.py

@@ -1,6 +1,3 @@
-from string import ascii_lowercase, ascii_uppercase
-
-
 def capitalize(sentence: str) -> str:
     """
     Capitalizes the first letter of a sentence or word.
@@ -19,11 +16,9 @@ def capitalize(sentence: str) -> str:
     if not sentence:
         return ""
 
-    # Create a dictionary that maps lowercase letters to uppercase letters
     # Capitalize the first character if it's a lowercase letter
     # Concatenate the capitalized character with the rest of the string
-    lower_to_upper = dict(zip(ascii_lowercase, ascii_uppercase))
-    return lower_to_upper.get(sentence[0], sentence[0]) + sentence[1:]
+    return sentence[0].upper() + sentence[1:]
 
 
 if __name__ == "__main__":