Change occurrences of str.format to f-strings (TheAlgorithms#4118)

* f-string update rsa_cipher.py

* f-string update rsa_key_generator.py

* f-string update burrows_wheeler.py

* f-string update non_recursive_segment_tree.py

* f-string update red_black_tree.py

* f-string update deque_doubly.py

* f-string update climbing_stairs.py

* f-string update iterating_through_submasks.py

* f-string update knn_sklearn.py

* f-string update 3n_plus_1.py

* f-string update quadratic_equations_complex_numbers.py

* f-string update nth_fibonacci_using_matrix_exponentiation.py

* f-string update sherman_morrison.py

* f-string update levenshtein_distance.py

* fix lines that were too long

Author: CarsonHam

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

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}")