sync fork

bit_manipulation/binary_shifts.py

@@ -0,0 +1,111 @@
+# Information on binary shifts:
+# https://docs.python.org/3/library/stdtypes.html#bitwise-operations-on-integer-types
+# https://www.interviewcake.com/concept/java/bit-shift
+
+
+def logical_left_shift(number: int, shift_amount: int) -> str:
+    """
+    Take in 2 positive integers.
+    'number' is the integer to be logically left shifted 'shift_amount' times.
+    i.e. (number << shift_amount)
+    Return the shifted binary representation.
+
+    >>> logical_left_shift(0, 1)
+    '0b00'
+    >>> logical_left_shift(1, 1)
+    '0b10'
+    >>> logical_left_shift(1, 5)
+    '0b100000'
+    >>> logical_left_shift(17, 2)
+    '0b1000100'
+    >>> logical_left_shift(1983, 4)
+    '0b111101111110000'
+    >>> logical_left_shift(1, -1)
+    Traceback (most recent call last):
+        ...
+    ValueError: both inputs must be positive integers
+    """
+    if number < 0 or shift_amount < 0:
+        raise ValueError("both inputs must be positive integers")
+
+    binary_number = str(bin(number))
+    binary_number += "0" * shift_amount
+    return binary_number
+
+
+def logical_right_shift(number: int, shift_amount: int) -> str:
+    """
+    Take in positive 2 integers.
+    'number' is the integer to be logically right shifted 'shift_amount' times.
+    i.e. (number >>> shift_amount)
+    Return the shifted binary representation.
+
+    >>> logical_right_shift(0, 1)
+    '0b0'
+    >>> logical_right_shift(1, 1)
+    '0b0'
+    >>> logical_right_shift(1, 5)
+    '0b0'
+    >>> logical_right_shift(17, 2)
+    '0b100'
+    >>> logical_right_shift(1983, 4)
+    '0b1111011'
+    >>> logical_right_shift(1, -1)
+    Traceback (most recent call last):
+        ...
+    ValueError: both inputs must be positive integers
+    """
+    if number < 0 or shift_amount < 0:
+        raise ValueError("both inputs must be positive integers")
+
+    binary_number = str(bin(number))[2:]
+    if shift_amount >= len(binary_number):
+        return "0b0"
+    shifted_binary_number = binary_number[: len(binary_number) - shift_amount]
+    return "0b" + shifted_binary_number
+
+
+def arithmetic_right_shift(number: int, shift_amount: int) -> str:
+    """
+    Take in 2 integers.
+    'number' is the integer to be arithmetically right shifted 'shift_amount' times.
+    i.e. (number >> shift_amount)
+    Return the shifted binary representation.
+
+    >>> arithmetic_right_shift(0, 1)
+    '0b00'
+    >>> arithmetic_right_shift(1, 1)
+    '0b00'
+    >>> arithmetic_right_shift(-1, 1)
+    '0b11'
+    >>> arithmetic_right_shift(17, 2)
+    '0b000100'
+    >>> arithmetic_right_shift(-17, 2)
+    '0b111011'
+    >>> arithmetic_right_shift(-1983, 4)
+    '0b111110000100'
+    """
+    if number >= 0:  # Get binary representation of positive number
+        binary_number = "0" + str(bin(number)).strip("-")[2:]
+    else:  # Get binary (2's complement) representation of negative number
+        binary_number_length = len(bin(number)[3:])  # Find 2's complement of number
+        binary_number = bin(abs(number) - (1 << binary_number_length))[3:]
+        binary_number = (
+            ("1" + "0" * (binary_number_length - len(binary_number)) + binary_number)
+            if number < 0
+            else "0"
+        )
+
+    if shift_amount >= len(binary_number):
+        return "0b" + binary_number[0] * len(binary_number)
+    return (
+        "0b"
+        + binary_number[0] * shift_amount
+        + binary_number[: len(binary_number) - shift_amount]
+    )
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/binary_twos_complement.py

@@ -0,0 +1,43 @@
+# Information on 2's complement: https://en.wikipedia.org/wiki/Two%27s_complement
+
+
+def twos_complement(number: int) -> str:
+    """
+    Take in a negative integer 'number'.
+    Return the two's complement representation of 'number'.
+
+    >>> twos_complement(0)
+    '0b0'
+    >>> twos_complement(-1)
+    '0b11'
+    >>> twos_complement(-5)
+    '0b1011'
+    >>> twos_complement(-17)
+    '0b101111'
+    >>> twos_complement(-207)
+    '0b100110001'
+    >>> twos_complement(1)
+    Traceback (most recent call last):
+        ...
+    ValueError: input must be a negative integer
+    """
+    if number > 0:
+        raise ValueError("input must be a negative integer")
+    binary_number_length = len(bin(number)[3:])
+    twos_complement_number = bin(abs(number) - (1 << binary_number_length))[3:]
+    twos_complement_number = (
+        (
+            "1"
+            + "0" * (binary_number_length - len(twos_complement_number))
+            + twos_complement_number
+        )
+        if number < 0
+        else "0"
+    )
+    return "0b" + twos_complement_number
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

ciphers/rsa_cipher.py

@@ -118,7 +118,7 @@ def encryptAndWriteToFile(
     for i in range(len(encryptedBlocks)):
         encryptedBlocks[i] = str(encryptedBlocks[i])
     encryptedContent = ",".join(encryptedBlocks)
-    encryptedContent = "{}_{}_{}".format(len(message), blockSize, encryptedContent)
+    encryptedContent = f"{len(message)}_{blockSize}_{encryptedContent}"
     with open(messageFilename, "w") as fo:
         fo.write(encryptedContent)
     return encryptedContent

ciphers/rsa_key_generator.py

@@ -49,11 +49,11 @@ def makeKeyFiles(name: int, keySize: int) -> None:
     publicKey, privateKey = generateKey(keySize)
     print("\nWriting public key to file %s_pubkey.txt..." % name)
     with open("%s_pubkey.txt" % name, "w") as out_file:
-        out_file.write("{},{},{}".format(keySize, publicKey[0], publicKey[1]))
+        out_file.write(f"{keySize},{publicKey[0]},{publicKey[1]}")
 
     print("Writing private key to file %s_privkey.txt..." % name)
     with open("%s_privkey.txt" % name, "w") as out_file:
-        out_file.write("{},{},{}".format(keySize, privateKey[0], privateKey[1]))
+        out_file.write(f"{keySize},{privateKey[0]},{privateKey[1]}")
 
 
 if __name__ == "__main__":

compression/burrows_wheeler.py

@@ -157,11 +157,12 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
     entry_msg = "Provide a string that I will generate its BWT transform: "
     s = input(entry_msg).strip()
     result = bwt_transform(s)
-    bwt_output_msg = "Burrows Wheeler transform for string '{}' results in '{}'"
-    print(bwt_output_msg.format(s, result["bwt_string"]))
+    print(
+        f"Burrows Wheeler transform for string '{s}' results "
+        f"in '{result['bwt_string']}'"
+    )
     original_string = reverse_bwt(result["bwt_string"], result["idx_original_string"])
-    fmt = (
-        "Reversing Burrows Wheeler transform for entry '{}' we get original"
-        " string '{}'"
+    print(
+        f"Reversing Burrows Wheeler transform for entry '{result['bwt_string']}' "
+        f"we get original string '{original_string}'"
     )
-    print(fmt.format(result["bwt_string"], original_string))

data_structures/binary_tree/non_recursive_segment_tree.py

@@ -49,7 +49,7 @@ def __init__(self, arr: list[T], fnc: Callable[[T, T], T]) -> None:
         :param arr: list of elements for the segment tree
         :param fnc: commutative function for combine two elements
 
-        >>> SegmentTree(['a', 'b', 'c'], lambda a, b: '{}{}'.format(a, b)).query(0, 2)
+        >>> SegmentTree(['a', 'b', 'c'], lambda a, b: f'{a}{b}').query(0, 2)
         'abc'
         >>> SegmentTree([(1, 2), (2, 3), (3, 4)],
         ...             lambda a, b: (a[0] + b[0], a[1] + b[1])).query(0, 2)

data_structures/binary_tree/red_black_tree.py

@@ -475,11 +475,13 @@ def __repr__(self) -> str:
         from pprint import pformat
 
         if self.left is None and self.right is None:
-            return "'{} {}'".format(self.label, (self.color and "red") or "blk")
+            return f"'{self.label} {(self.color and 'red') or 'blk'}'"
         return pformat(
             {
-                "%s %s"
-                % (self.label, (self.color and "red") or "blk"): (self.left, self.right)
+                f"{self.label} {(self.color and 'red') or 'blk'}": (
+                    self.left,
+                    self.right,
+                )
             },
             indent=1,
         )

data_structures/linked_list/deque_doubly.py

@@ -20,8 +20,8 @@ def __init__(self, link_p, element, link_n):
             self._next = link_n
 
         def has_next_and_prev(self):
-            return " Prev -> {}, Next -> {}".format(
-                self._prev is not None, self._next is not None
+            return (
+                f" Prev -> {self._prev is not None}, Next -> {self._next is not None}"
             )
 
     def __init__(self):

dynamic_programming/climbing_stairs.py

@@ -25,8 +25,9 @@ def climb_stairs(n: int) -> int:
         ...
     AssertionError: n needs to be positive integer, your input -7
     """
-    fmt = "n needs to be positive integer, your input {}"
-    assert isinstance(n, int) and n > 0, fmt.format(n)
+    assert (
+        isinstance(n, int) and n > 0
+    ), f"n needs to be positive integer, your input {n}"
     if n == 1:
         return 1
     dp = [0] * (n + 1)

dynamic_programming/iterating_through_submasks.py

@@ -37,8 +37,9 @@ def list_of_submasks(mask: int) -> list[int]:
 
     """
 
-    fmt = "mask needs to be positive integer, your input {}"
-    assert isinstance(mask, int) and mask > 0, fmt.format(mask)
+    assert (
+        isinstance(mask, int) and mask > 0
+    ), f"mask needs to be positive integer, your input {mask}"
 
     """
     first submask iterated will be mask itself then operation will be performed

graphics/bezier_curve.py

@@ -2,7 +2,7 @@
 # https://www.tutorialspoint.com/computer_graphics/computer_graphics_curves.htm
 from __future__ import annotations
 
-from scipy.special import comb
+from scipy.special import comb  # type: ignore
 
 
 class BezierCurve:
@@ -78,7 +78,7 @@ def plot_curve(self, step_size: float = 0.01):
             step_size: defines the step(s) at which to evaluate the Bezier curve.
             The smaller the step size, the finer the curve produced.
         """
-        from matplotlib import pyplot as plt
+        from matplotlib import pyplot as plt  # type: ignore
 
         to_plot_x: list[float] = []  # x coordinates of points to plot
         to_plot_y: list[float] = []  # y coordinates of points to plot

machine_learning/knn_sklearn.py

@@ -26,6 +26,6 @@
 prediction = knn.predict(X_new)
 
 print(
-    "\nNew array: \n {}"
-    "\n\nTarget Names Prediction: \n {}".format(X_new, iris["target_names"][prediction])
+    f"\nNew array: \n {X_new}\n\nTarget Names Prediction: \n"
+    f" {iris['target_names'][prediction]}"
 )

maths/3n_plus_1.py

@@ -9,7 +9,7 @@ def n31(a: int) -> tuple[list[int], int]:
     """
 
     if not isinstance(a, int):
-        raise TypeError("Must be int, not {}".format(type(a).__name__))
+        raise TypeError(f"Must be int, not {type(a).__name__}")
     if a < 1:
         raise ValueError(f"Given integer must be greater than 1, not {a}")
 

maths/quadratic_equations_complex_numbers.py

@@ -30,8 +30,8 @@ def quadratic_roots(a: int, b: int, c: int) -> tuple[complex, complex]:
 
 
 def main():
-    solutions = quadratic_roots(a=5, b=6, c=1)
-    print("The solutions are: {} and {}".format(*solutions))
+    solution1, solution2 = quadratic_roots(a=5, b=6, c=1)
+    print(f"The solutions are: {solution1} and {solution2}")
 
 
 if __name__ == "__main__":

matrix/nth_fibonacci_using_matrix_exponentiation.py

@@ -71,13 +71,13 @@ def nth_fibonacci_bruteforce(n):
 
 
 def main():
-    fmt = (
-        "{} fibonacci number using matrix exponentiation is {} and using bruteforce "
-        "is {}\n"
-    )
     for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
         n = int("".join(c for c in ordinal if c in "0123456789"))  # 1000th --> 1000
-        print(fmt.format(ordinal, nth_fibonacci_matrix(n), nth_fibonacci_bruteforce(n)))
+        print(
+            f"{ordinal} fibonacci number using matrix exponentiation is "
+            f"{nth_fibonacci_matrix(n)} and using bruteforce is "
+            f"{nth_fibonacci_bruteforce(n)}\n"
+        )
     # from timeit import timeit
     # print(timeit("nth_fibonacci_matrix(1000000)",
     #              "from main import nth_fibonacci_matrix", number=5))

matrix/sherman_morrison.py

@@ -175,9 +175,7 @@ def __mul__(self, another):
                         result[r, c] += self[r, i] * another[i, c]
             return result
         else:
-            raise TypeError(
-                "Unsupported type given for another ({})".format(type(another))
-            )
+            raise TypeError(f"Unsupported type given for another ({type(another)})")
 
     def transpose(self):
         """
@@ -260,7 +258,7 @@ def test1():
         print(f"v is {v}")
         print("uv^T is %s" % (u * v.transpose()))
         # Sherman Morrison
-        print("(a + uv^T)^(-1) is {}".format(ainv.ShermanMorrison(u, v)))
+        print(f"(a + uv^T)^(-1) is {ainv.ShermanMorrison(u, v)}")
 
     def test2():
         import doctest

sorts/bucket_sort.py

@@ -27,6 +27,7 @@
 
 Source: https://en.wikipedia.org/wiki/Bucket_sort
 """
+from typing import List
 
 
 def bucket_sort(my_list: list) -> list:
@@ -51,7 +52,7 @@ def bucket_sort(my_list: list) -> list:
         return []
     min_value, max_value = min(my_list), max(my_list)
     bucket_count = int(max_value - min_value) + 1
-    buckets = [[] for _ in range(bucket_count)]
+    buckets: List[list] = [[] for _ in range(bucket_count)]
 
     for i in range(len(my_list)):
         buckets[(int(my_list[i] - min_value) // bucket_count)].append(my_list[i])

sorts/cocktail_shaker_sort.py

@@ -33,7 +33,8 @@ def cocktail_shaker_sort(unsorted: list) -> list:
                 swapped = True
 
         if not swapped:
-            return unsorted
+            break
+    return unsorted
 
 
 if __name__ == "__main__":

sorts/patience_sort.py

@@ -1,6 +1,7 @@
 from bisect import bisect_left
 from functools import total_ordering
 from heapq import merge
+from typing import List
 
 """
 A pure Python implementation of the patience sort algorithm
@@ -43,7 +44,7 @@ def patience_sort(collection: list) -> list:
     >>> patience_sort([-3, -17, -48])
     [-48, -17, -3]
     """
-    stacks = []
+    stacks: List[Stack] = []
     # sort into stacks
     for element in collection:
         new_stacks = Stack([element])

sorts/radix_sort.py

@@ -30,7 +30,7 @@ def radix_sort(list_of_ints: List[int]) -> List[int]:
     max_digit = max(list_of_ints)
     while placement <= max_digit:
         # declare and initialize empty buckets
-        buckets = [list() for _ in range(RADIX)]
+        buckets: List[list] = [list() for _ in range(RADIX)]
         # split list_of_ints between the buckets
         for i in list_of_ints:
             tmp = int((i / placement) % RADIX)