diff --git a/DIRECTORY.md b/DIRECTORY.md
index 01667c9feee8..f6d6cb463faa 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -351,7 +351,7 @@
   * [Longest Common Subsequence](dynamic_programming/longest_common_subsequence.py)
   * [Longest Common Substring](dynamic_programming/longest_common_substring.py)
   * [Longest Increasing Subsequence](dynamic_programming/longest_increasing_subsequence.py)
-  * [Longest Increasing Subsequence O(Nlogn)](dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
+  * [Longest Increasing Subsequence O Nlogn](dynamic_programming/longest_increasing_subsequence_o_nlogn.py)
   * [Longest Palindromic Subsequence](dynamic_programming/longest_palindromic_subsequence.py)
   * [Matrix Chain Multiplication](dynamic_programming/matrix_chain_multiplication.py)
   * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
@@ -465,7 +465,7 @@
   * [Dijkstra Alternate](graphs/dijkstra_alternate.py)
   * [Dijkstra Binary Grid](graphs/dijkstra_binary_grid.py)
   * [Dinic](graphs/dinic.py)
-  * [Directed And Undirected (Weighted) Graph](graphs/directed_and_undirected_(weighted)_graph.py)
+  * [Directed And Undirected Weighted Graph](graphs/directed_and_undirected_weighted_graph.py)
   * [Edmonds Karp Multiple Source And Sink](graphs/edmonds_karp_multiple_source_and_sink.py)
   * [Eulerian Path And Circuit For Undirected Graph](graphs/eulerian_path_and_circuit_for_undirected_graph.py)
   * [Even Tree](graphs/even_tree.py)
@@ -792,7 +792,6 @@
   * [Minimum Cut](networking_flow/minimum_cut.py)
 
 ## Neural Network
-  * [2 Hidden Layers Neural Network](neural_network/2_hidden_layers_neural_network.py)
   * Activation Functions
     * [Binary Step](neural_network/activation_functions/binary_step.py)
     * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
@@ -809,6 +808,7 @@
   * [Convolution Neural Network](neural_network/convolution_neural_network.py)
   * [Input Data](neural_network/input_data.py)
   * [Simple Neural Network](neural_network/simple_neural_network.py)
+  * [Two Hidden Layers Neural Network](neural_network/two_hidden_layers_neural_network.py)
 
 ## Other
   * [Activity Selection](other/activity_selection.py)
diff --git a/backtracking/crossword_puzzle_solver.py b/backtracking/crossword_puzzle_solver.py
index b9c01c4efea9..e702c7e52153 100644
--- a/backtracking/crossword_puzzle_solver.py
+++ b/backtracking/crossword_puzzle_solver.py
@@ -28,9 +28,8 @@ def is_valid(
         if vertical:
             if row + i >= len(puzzle) or puzzle[row + i][col] != "":
                 return False
-        else:
-            if col + i >= len(puzzle[0]) or puzzle[row][col + i] != "":
-                return False
+        elif col + i >= len(puzzle[0]) or puzzle[row][col + i] != "":
+            return False
     return True
 
 
diff --git a/cellular_automata/game_of_life.py b/cellular_automata/game_of_life.py
index 67e647d6475b..76276b272d65 100644
--- a/cellular_automata/game_of_life.py
+++ b/cellular_automata/game_of_life.py
@@ -101,9 +101,8 @@ def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:
             state = True
         elif alive > 3:
             state = False
-    else:
-        if alive == 3:
-            state = True
+    elif alive == 3:
+        state = True
 
     return state
 
diff --git a/ciphers/decrypt_caesar_with_chi_squared.py b/ciphers/decrypt_caesar_with_chi_squared.py
index 6c36860207cd..10832203e531 100644
--- a/ciphers/decrypt_caesar_with_chi_squared.py
+++ b/ciphers/decrypt_caesar_with_chi_squared.py
@@ -206,20 +206,19 @@ def decrypt_caesar_with_chi_squared(
 
                     # Add the margin of error to the total chi squared statistic
                     chi_squared_statistic += chi_letter_value
-            else:
-                if letter.lower() in frequencies:
-                    # Get the amount of times the letter occurs in the message
-                    occurrences = decrypted_with_shift.count(letter)
+            elif letter.lower() in frequencies:
+                # Get the amount of times the letter occurs in the message
+                occurrences = decrypted_with_shift.count(letter)
 
-                    # Get the excepcted amount of times the letter should appear based
-                    # on letter frequencies
-                    expected = frequencies[letter] * occurrences
+                # Get the excepcted amount of times the letter should appear based
+                # on letter frequencies
+                expected = frequencies[letter] * occurrences
 
-                    # Complete the chi squared statistic formula
-                    chi_letter_value = ((occurrences - expected) ** 2) / expected
+                # Complete the chi squared statistic formula
+                chi_letter_value = ((occurrences - expected) ** 2) / expected
 
-                    # Add the margin of error to the total chi squared statistic
-                    chi_squared_statistic += chi_letter_value
+                # Add the margin of error to the total chi squared statistic
+                chi_squared_statistic += chi_letter_value
 
         # Add the data to the chi_squared_statistic_values dictionary
         chi_squared_statistic_values[shift] = (
diff --git a/ciphers/hill_cipher.py b/ciphers/hill_cipher.py
index ea337a72dc04..33b2529f017b 100644
--- a/ciphers/hill_cipher.py
+++ b/ciphers/hill_cipher.py
@@ -38,7 +38,7 @@
 
 import string
 
-import numpy
+import numpy as np
 
 from maths.greatest_common_divisor import greatest_common_divisor
 
@@ -49,11 +49,11 @@ class HillCipher:
     # i.e. a total of 36 characters
 
     # take x and return x % len(key_string)
-    modulus = numpy.vectorize(lambda x: x % 36)
+    modulus = np.vectorize(lambda x: x % 36)
 
-    to_int = numpy.vectorize(round)
+    to_int = np.vectorize(round)
 
-    def __init__(self, encrypt_key: numpy.ndarray) -> None:
+    def __init__(self, encrypt_key: np.ndarray) -> None:
         """
         encrypt_key is an NxN numpy array
         """
@@ -63,7 +63,7 @@ def __init__(self, encrypt_key: numpy.ndarray) -> None:
 
     def replace_letters(self, letter: str) -> int:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.replace_letters('T')
         19
         >>> hill_cipher.replace_letters('0')
@@ -73,7 +73,7 @@ def replace_letters(self, letter: str) -> int:
 
     def replace_digits(self, num: int) -> str:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.replace_digits(19)
         'T'
         >>> hill_cipher.replace_digits(26)
@@ -83,10 +83,10 @@ def replace_digits(self, num: int) -> str:
 
     def check_determinant(self) -> None:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.check_determinant()
         """
-        det = round(numpy.linalg.det(self.encrypt_key))
+        det = round(np.linalg.det(self.encrypt_key))
 
         if det < 0:
             det = det % len(self.key_string)
@@ -101,7 +101,7 @@ def check_determinant(self) -> None:
 
     def process_text(self, text: str) -> str:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.process_text('Testing Hill Cipher')
         'TESTINGHILLCIPHERR'
         >>> hill_cipher.process_text('hello')
@@ -117,7 +117,7 @@ def process_text(self, text: str) -> str:
 
     def encrypt(self, text: str) -> str:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.encrypt('testing hill cipher')
         'WHXYJOLM9C6XT085LL'
         >>> hill_cipher.encrypt('hello')
@@ -129,7 +129,7 @@ def encrypt(self, text: str) -> str:
         for i in range(0, len(text) - self.break_key + 1, self.break_key):
             batch = text[i : i + self.break_key]
             vec = [self.replace_letters(char) for char in batch]
-            batch_vec = numpy.array([vec]).T
+            batch_vec = np.array([vec]).T
             batch_encrypted = self.modulus(self.encrypt_key.dot(batch_vec)).T.tolist()[
                 0
             ]
@@ -140,14 +140,14 @@ def encrypt(self, text: str) -> str:
 
         return encrypted
 
-    def make_decrypt_key(self) -> numpy.ndarray:
+    def make_decrypt_key(self) -> np.ndarray:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.make_decrypt_key()
         array([[ 6, 25],
                [ 5, 26]])
         """
-        det = round(numpy.linalg.det(self.encrypt_key))
+        det = round(np.linalg.det(self.encrypt_key))
 
         if det < 0:
             det = det % len(self.key_string)
@@ -158,16 +158,14 @@ def make_decrypt_key(self) -> numpy.ndarray:
                 break
 
         inv_key = (
-            det_inv
-            * numpy.linalg.det(self.encrypt_key)
-            * numpy.linalg.inv(self.encrypt_key)
+            det_inv * np.linalg.det(self.encrypt_key) * np.linalg.inv(self.encrypt_key)
         )
 
         return self.to_int(self.modulus(inv_key))
 
     def decrypt(self, text: str) -> str:
         """
-        >>> hill_cipher = HillCipher(numpy.array([[2, 5], [1, 6]]))
+        >>> hill_cipher = HillCipher(np.array([[2, 5], [1, 6]]))
         >>> hill_cipher.decrypt('WHXYJOLM9C6XT085LL')
         'TESTINGHILLCIPHERR'
         >>> hill_cipher.decrypt('85FF00')
@@ -180,7 +178,7 @@ def decrypt(self, text: str) -> str:
         for i in range(0, len(text) - self.break_key + 1, self.break_key):
             batch = text[i : i + self.break_key]
             vec = [self.replace_letters(char) for char in batch]
-            batch_vec = numpy.array([vec]).T
+            batch_vec = np.array([vec]).T
             batch_decrypted = self.modulus(decrypt_key.dot(batch_vec)).T.tolist()[0]
             decrypted_batch = "".join(
                 self.replace_digits(num) for num in batch_decrypted
@@ -199,7 +197,7 @@ def main() -> None:
         row = [int(x) for x in input().split()]
         hill_matrix.append(row)
 
-    hc = HillCipher(numpy.array(hill_matrix))
+    hc = HillCipher(np.array(hill_matrix))
 
     print("Would you like to encrypt or decrypt some text? (1 or 2)")
     option = input("\n1. Encrypt\n2. Decrypt\n")
diff --git a/data_structures/binary_tree/avl_tree.py b/data_structures/binary_tree/avl_tree.py
index 041ed7e36d16..9fca7237404c 100644
--- a/data_structures/binary_tree/avl_tree.py
+++ b/data_structures/binary_tree/avl_tree.py
@@ -215,11 +215,11 @@ def del_node(root: MyNode, data: Any) -> MyNode | None:
             return root
         else:
             root.set_left(del_node(left_child, data))
-    else:  # root.get_data() < data
-        if right_child is None:
-            return root
-        else:
-            root.set_right(del_node(right_child, data))
+    # root.get_data() < data
+    elif right_child is None:
+        return root
+    else:
+        root.set_right(del_node(right_child, data))
 
     if get_height(right_child) - get_height(left_child) == 2:
         assert right_child is not None
diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index 08a60a12065d..090e3e25fe6d 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -185,12 +185,11 @@ def __insert(self, value) -> None:
                         break
                     else:
                         parent_node = parent_node.left
+                elif parent_node.right is None:
+                    parent_node.right = new_node
+                    break
                 else:
-                    if parent_node.right is None:
-                        parent_node.right = new_node
-                        break
-                    else:
-                        parent_node = parent_node.right
+                    parent_node = parent_node.right
             new_node.parent = parent_node
 
     def insert(self, *values) -> Self:
diff --git a/data_structures/binary_tree/binary_search_tree_recursive.py b/data_structures/binary_tree/binary_search_tree_recursive.py
index 6af1b053f42c..d94ac5253360 100644
--- a/data_structures/binary_tree/binary_search_tree_recursive.py
+++ b/data_structures/binary_tree/binary_search_tree_recursive.py
@@ -74,14 +74,13 @@ def put(self, label: int) -> None:
     def _put(self, node: Node | None, label: int, parent: Node | None = None) -> Node:
         if node is None:
             node = Node(label, parent)
+        elif label < node.label:
+            node.left = self._put(node.left, label, node)
+        elif label > node.label:
+            node.right = self._put(node.right, label, node)
         else:
-            if label < node.label:
-                node.left = self._put(node.left, label, node)
-            elif label > node.label:
-                node.right = self._put(node.right, label, node)
-            else:
-                msg = f"Node with label {label} already exists"
-                raise ValueError(msg)
+            msg = f"Node with label {label} already exists"
+            raise ValueError(msg)
 
         return node
 
@@ -106,11 +105,10 @@ def _search(self, node: Node | None, label: int) -> Node:
         if node is None:
             msg = f"Node with label {label} does not exist"
             raise ValueError(msg)
-        else:
-            if label < node.label:
-                node = self._search(node.left, label)
-            elif label > node.label:
-                node = self._search(node.right, label)
+        elif label < node.label:
+            node = self._search(node.left, label)
+        elif label > node.label:
+            node = self._search(node.right, label)
 
         return node
 
diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 2b33cdca4fed..49c208335b2c 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -97,6 +97,8 @@ def level_order(root: Node | None) -> Generator[int, None, None]:
     """
     Returns a list of nodes value from a whole binary tree in Level Order Traverse.
     Level Order traverse: Visit nodes of the tree level-by-level.
+    >>> list(level_order(make_tree()))
+    [1, 2, 3, 4, 5]
     """
 
     if root is None:
@@ -120,6 +122,10 @@ def get_nodes_from_left_to_right(
     """
     Returns a list of nodes value from a particular level:
     Left to right direction of the binary tree.
+    >>> list(get_nodes_from_left_to_right(make_tree(), 1))
+    [1]
+    >>> list(get_nodes_from_left_to_right(make_tree(), 2))
+    [2, 3]
     """
 
     def populate_output(root: Node | None, level: int) -> Generator[int, None, None]:
@@ -140,10 +146,14 @@ def get_nodes_from_right_to_left(
     """
     Returns a list of nodes value from a particular level:
     Right to left direction of the binary tree.
+    >>> list(get_nodes_from_right_to_left(make_tree(), 1))
+    [1]
+    >>> list(get_nodes_from_right_to_left(make_tree(), 2))
+    [3, 2]
     """
 
     def populate_output(root: Node | None, level: int) -> Generator[int, None, None]:
-        if root is None:
+        if not root:
             return
         if level == 1:
             yield root.data
@@ -158,6 +168,8 @@ def zigzag(root: Node | None) -> Generator[int, None, None]:
     """
     ZigZag traverse:
     Returns a list of nodes value from left to right and right to left, alternatively.
+    >>> list(zigzag(make_tree()))
+    [1, 3, 2, 4, 5]
     """
     if root is None:
         return
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index 3b5845cd957b..bdd808c828e0 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -107,12 +107,11 @@ def insert(self, label: int) -> RedBlackTree:
             else:
                 self.left = RedBlackTree(label, 1, self)
                 self.left._insert_repair()
+        elif self.right:
+            self.right.insert(label)
         else:
-            if self.right:
-                self.right.insert(label)
-            else:
-                self.right = RedBlackTree(label, 1, self)
-                self.right._insert_repair()
+            self.right = RedBlackTree(label, 1, self)
+            self.right._insert_repair()
         return self.parent or self
 
     def _insert_repair(self) -> None:
@@ -178,36 +177,34 @@ def remove(self, label: int) -> RedBlackTree:  # noqa: PLR0912
                             self.parent.left = None
                         else:
                             self.parent.right = None
-                else:
-                    # The node is black
-                    if child is None:
-                        # This node and its child are black
-                        if self.parent is None:
-                            # The tree is now empty
-                            return RedBlackTree(None)
-                        else:
-                            self._remove_repair()
-                            if self.is_left():
-                                self.parent.left = None
-                            else:
-                                self.parent.right = None
-                            self.parent = None
+                # The node is black
+                elif child is None:
+                    # This node and its child are black
+                    if self.parent is None:
+                        # The tree is now empty
+                        return RedBlackTree(None)
                     else:
-                        # This node is black and its child is red
-                        # Move the child node here and make it black
-                        self.label = child.label
-                        self.left = child.left
-                        self.right = child.right
-                        if self.left:
-                            self.left.parent = self
-                        if self.right:
-                            self.right.parent = self
+                        self._remove_repair()
+                        if self.is_left():
+                            self.parent.left = None
+                        else:
+                            self.parent.right = None
+                        self.parent = None
+                else:
+                    # This node is black and its child is red
+                    # Move the child node here and make it black
+                    self.label = child.label
+                    self.left = child.left
+                    self.right = child.right
+                    if self.left:
+                        self.left.parent = self
+                    if self.right:
+                        self.right.parent = self
         elif self.label is not None and self.label > label:
             if self.left:
                 self.left.remove(label)
-        else:
-            if self.right:
-                self.right.remove(label)
+        elif self.right:
+            self.right.remove(label)
         return self.parent or self
 
     def _remove_repair(self) -> None:
@@ -369,11 +366,10 @@ def search(self, label: int) -> RedBlackTree | None:
                 return None
             else:
                 return self.right.search(label)
+        elif self.left is None:
+            return None
         else:
-            if self.left is None:
-                return None
-            else:
-                return self.left.search(label)
+            return self.left.search(label)
 
     def floor(self, label: int) -> int | None:
         """Returns the largest element in this tree which is at most label.
diff --git a/data_structures/binary_tree/treap.py b/data_structures/binary_tree/treap.py
index a53ac566ed54..e7ddf931b83a 100644
--- a/data_structures/binary_tree/treap.py
+++ b/data_structures/binary_tree/treap.py
@@ -43,22 +43,21 @@ def split(root: Node | None, value: int) -> tuple[Node | None, Node | None]:
         return None, None
     elif root.value is None:
         return None, None
+    elif value < root.value:
+        """
+        Right tree's root will be current node.
+        Now we split(with the same value) current node's left son
+        Left tree: left part of that split
+        Right tree's left son: right part of that split
+        """
+        left, root.left = split(root.left, value)
+        return left, root
     else:
-        if value < root.value:
-            """
-            Right tree's root will be current node.
-            Now we split(with the same value) current node's left son
-            Left tree: left part of that split
-            Right tree's left son: right part of that split
-            """
-            left, root.left = split(root.left, value)
-            return left, root
-        else:
-            """
-            Just symmetric to previous case
-            """
-            root.right, right = split(root.right, value)
-            return root, right
+        """
+        Just symmetric to previous case
+        """
+        root.right, right = split(root.right, value)
+        return root, right
 
 
 def merge(left: Node | None, right: Node | None) -> Node | None:
diff --git a/data_structures/heap/max_heap.py b/data_structures/heap/max_heap.py
index fbc8eed09226..5a9f9cf88433 100644
--- a/data_structures/heap/max_heap.py
+++ b/data_structures/heap/max_heap.py
@@ -40,11 +40,10 @@ def __swap_down(self, i: int) -> None:
         while self.__size >= 2 * i:
             if 2 * i + 1 > self.__size:
                 bigger_child = 2 * i
+            elif self.__heap[2 * i] > self.__heap[2 * i + 1]:
+                bigger_child = 2 * i
             else:
-                if self.__heap[2 * i] > self.__heap[2 * i + 1]:
-                    bigger_child = 2 * i
-                else:
-                    bigger_child = 2 * i + 1
+                bigger_child = 2 * i + 1
             temporary = self.__heap[i]
             if self.__heap[i] < self.__heap[bigger_child]:
                 self.__heap[i] = self.__heap[bigger_child]
diff --git a/data_structures/stacks/infix_to_prefix_conversion.py b/data_structures/stacks/infix_to_prefix_conversion.py
index beff421c0cfa..878473b93c19 100644
--- a/data_structures/stacks/infix_to_prefix_conversion.py
+++ b/data_structures/stacks/infix_to_prefix_conversion.py
@@ -95,13 +95,12 @@ def infix_2_postfix(infix: str) -> str:
             while stack[-1] != "(":
                 post_fix.append(stack.pop())  # Pop stack & add the content to Postfix
             stack.pop()
-        else:
-            if len(stack) == 0:
-                stack.append(x)  # If stack is empty, push x to stack
-            else:  # while priority of x is not > priority of element in the stack
-                while stack and stack[-1] != "(" and priority[x] <= priority[stack[-1]]:
-                    post_fix.append(stack.pop())  # pop stack & add to Postfix
-                stack.append(x)  # push x to stack
+        elif len(stack) == 0:
+            stack.append(x)  # If stack is empty, push x to stack
+        else:  # while priority of x is not > priority of element in the stack
+            while stack and stack[-1] != "(" and priority[x] <= priority[stack[-1]]:
+                post_fix.append(stack.pop())  # pop stack & add to Postfix
+            stack.append(x)  # push x to stack
 
         print(
             x.center(8),
diff --git a/data_structures/trie/radix_tree.py b/data_structures/trie/radix_tree.py
index fadc50cb49a7..caf566a6ce30 100644
--- a/data_structures/trie/radix_tree.py
+++ b/data_structures/trie/radix_tree.py
@@ -153,31 +153,30 @@ def delete(self, word: str) -> bool:
             # We have word remaining so we check the next node
             elif remaining_word != "":
                 return incoming_node.delete(remaining_word)
+            # If it is not a leaf, we don't have to delete
+            elif not incoming_node.is_leaf:
+                return False
             else:
-                # If it is not a leaf, we don't have to delete
-                if not incoming_node.is_leaf:
-                    return False
+                # We delete the nodes if no edges go from it
+                if len(incoming_node.nodes) == 0:
+                    del self.nodes[word[0]]
+                    # We merge the current node with its only child
+                    if len(self.nodes) == 1 and not self.is_leaf:
+                        merging_node = next(iter(self.nodes.values()))
+                        self.is_leaf = merging_node.is_leaf
+                        self.prefix += merging_node.prefix
+                        self.nodes = merging_node.nodes
+                # If there is more than 1 edge, we just mark it as non-leaf
+                elif len(incoming_node.nodes) > 1:
+                    incoming_node.is_leaf = False
+                # If there is 1 edge, we merge it with its child
                 else:
-                    # We delete the nodes if no edges go from it
-                    if len(incoming_node.nodes) == 0:
-                        del self.nodes[word[0]]
-                        # We merge the current node with its only child
-                        if len(self.nodes) == 1 and not self.is_leaf:
-                            merging_node = next(iter(self.nodes.values()))
-                            self.is_leaf = merging_node.is_leaf
-                            self.prefix += merging_node.prefix
-                            self.nodes = merging_node.nodes
-                    # If there is more than 1 edge, we just mark it as non-leaf
-                    elif len(incoming_node.nodes) > 1:
-                        incoming_node.is_leaf = False
-                    # If there is 1 edge, we merge it with its child
-                    else:
-                        merging_node = next(iter(incoming_node.nodes.values()))
-                        incoming_node.is_leaf = merging_node.is_leaf
-                        incoming_node.prefix += merging_node.prefix
-                        incoming_node.nodes = merging_node.nodes
-
-                    return True
+                    merging_node = next(iter(incoming_node.nodes.values()))
+                    incoming_node.is_leaf = merging_node.is_leaf
+                    incoming_node.prefix += merging_node.prefix
+                    incoming_node.nodes = merging_node.nodes
+
+                return True
 
     def print_tree(self, height: int = 0) -> None:
         """Print the tree
diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index a5d8b713bdbc..93f6daf1f88c 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -274,14 +274,13 @@ def convex_hull_bf(points: list[Point]) -> list[Point]:
                         points_left_of_ij = True
                     elif det_k < 0:
                         points_right_of_ij = True
-                    else:
-                        # point[i], point[j], point[k] all lie on a straight line
-                        # if point[k] is to the left of point[i] or it's to the
-                        # right of point[j], then point[i], point[j] cannot be
-                        # part of the convex hull of A
-                        if points[k] < points[i] or points[k] > points[j]:
-                            ij_part_of_convex_hull = False
-                            break
+                    # point[i], point[j], point[k] all lie on a straight line
+                    # if point[k] is to the left of point[i] or it's to the
+                    # right of point[j], then point[i], point[j] cannot be
+                    # part of the convex hull of A
+                    elif points[k] < points[i] or points[k] > points[j]:
+                        ij_part_of_convex_hull = False
+                        break
 
                 if points_left_of_ij and points_right_of_ij:
                     ij_part_of_convex_hull = False
diff --git a/dynamic_programming/longest_increasing_subsequence_o(nlogn).py b/dynamic_programming/longest_increasing_subsequence_o_nlogn.py
similarity index 100%
rename from dynamic_programming/longest_increasing_subsequence_o(nlogn).py
rename to dynamic_programming/longest_increasing_subsequence_o_nlogn.py
diff --git a/fractals/julia_sets.py b/fractals/julia_sets.py
index 482e1eddfecc..1eef4573ba19 100644
--- a/fractals/julia_sets.py
+++ b/fractals/julia_sets.py
@@ -25,8 +25,8 @@
 from collections.abc import Callable
 from typing import Any
 
-import numpy
-from matplotlib import pyplot
+import matplotlib.pyplot as plt
+import numpy as np
 
 c_cauliflower = 0.25 + 0.0j
 c_polynomial_1 = -0.4 + 0.6j
@@ -37,22 +37,20 @@
 nb_pixels = 666
 
 
-def eval_exponential(c_parameter: complex, z_values: numpy.ndarray) -> numpy.ndarray:
+def eval_exponential(c_parameter: complex, z_values: np.ndarray) -> np.ndarray:
     """
     Evaluate $e^z + c$.
     >>> eval_exponential(0, 0)
     1.0
-    >>> abs(eval_exponential(1, numpy.pi*1.j)) < 1e-15
+    >>> abs(eval_exponential(1, np.pi*1.j)) < 1e-15
     True
     >>> abs(eval_exponential(1.j, 0)-1-1.j) < 1e-15
     True
     """
-    return numpy.exp(z_values) + c_parameter
+    return np.exp(z_values) + c_parameter
 
 
-def eval_quadratic_polynomial(
-    c_parameter: complex, z_values: numpy.ndarray
-) -> numpy.ndarray:
+def eval_quadratic_polynomial(c_parameter: complex, z_values: np.ndarray) -> np.ndarray:
     """
     >>> eval_quadratic_polynomial(0, 2)
     4
@@ -66,7 +64,7 @@ def eval_quadratic_polynomial(
     return z_values * z_values + c_parameter
 
 
-def prepare_grid(window_size: float, nb_pixels: int) -> numpy.ndarray:
+def prepare_grid(window_size: float, nb_pixels: int) -> np.ndarray:
     """
     Create a grid of complex values of size nb_pixels*nb_pixels with real and
      imaginary parts ranging from -window_size to window_size (inclusive).
@@ -77,20 +75,20 @@ def prepare_grid(window_size: float, nb_pixels: int) -> numpy.ndarray:
            [ 0.-1.j,  0.+0.j,  0.+1.j],
            [ 1.-1.j,  1.+0.j,  1.+1.j]])
     """
-    x = numpy.linspace(-window_size, window_size, nb_pixels)
+    x = np.linspace(-window_size, window_size, nb_pixels)
     x = x.reshape((nb_pixels, 1))
-    y = numpy.linspace(-window_size, window_size, nb_pixels)
+    y = np.linspace(-window_size, window_size, nb_pixels)
     y = y.reshape((1, nb_pixels))
     return x + 1.0j * y
 
 
 def iterate_function(
-    eval_function: Callable[[Any, numpy.ndarray], numpy.ndarray],
+    eval_function: Callable[[Any, np.ndarray], np.ndarray],
     function_params: Any,
     nb_iterations: int,
-    z_0: numpy.ndarray,
+    z_0: np.ndarray,
     infinity: float | None = None,
-) -> numpy.ndarray:
+) -> np.ndarray:
     """
     Iterate the function "eval_function" exactly nb_iterations times.
     The first argument of the function is a parameter which is contained in
@@ -98,22 +96,22 @@ def iterate_function(
     values to iterate from.
     This function returns the final iterates.
 
-    >>> iterate_function(eval_quadratic_polynomial, 0, 3, numpy.array([0,1,2])).shape
+    >>> iterate_function(eval_quadratic_polynomial, 0, 3, np.array([0,1,2])).shape
     (3,)
-    >>> numpy.round(iterate_function(eval_quadratic_polynomial,
+    >>> np.round(iterate_function(eval_quadratic_polynomial,
     ... 0,
     ... 3,
-    ... numpy.array([0,1,2]))[0])
+    ... np.array([0,1,2]))[0])
     0j
-    >>> numpy.round(iterate_function(eval_quadratic_polynomial,
+    >>> np.round(iterate_function(eval_quadratic_polynomial,
     ... 0,
     ... 3,
-    ... numpy.array([0,1,2]))[1])
+    ... np.array([0,1,2]))[1])
     (1+0j)
-    >>> numpy.round(iterate_function(eval_quadratic_polynomial,
+    >>> np.round(iterate_function(eval_quadratic_polynomial,
     ... 0,
     ... 3,
-    ... numpy.array([0,1,2]))[2])
+    ... np.array([0,1,2]))[2])
     (256+0j)
     """
 
@@ -121,8 +119,8 @@ def iterate_function(
     for _ in range(nb_iterations):
         z_n = eval_function(function_params, z_n)
         if infinity is not None:
-            numpy.nan_to_num(z_n, copy=False, nan=infinity)
-            z_n[abs(z_n) == numpy.inf] = infinity
+            np.nan_to_num(z_n, copy=False, nan=infinity)
+            z_n[abs(z_n) == np.inf] = infinity
     return z_n
 
 
@@ -130,21 +128,21 @@ def show_results(
     function_label: str,
     function_params: Any,
     escape_radius: float,
-    z_final: numpy.ndarray,
+    z_final: np.ndarray,
 ) -> None:
     """
     Plots of whether the absolute value of z_final is greater than
     the value of escape_radius. Adds the function_label and function_params to
     the title.
 
-    >>> show_results('80', 0, 1, numpy.array([[0,1,.5],[.4,2,1.1],[.2,1,1.3]]))
+    >>> show_results('80', 0, 1, np.array([[0,1,.5],[.4,2,1.1],[.2,1,1.3]]))
     """
 
     abs_z_final = (abs(z_final)).transpose()
     abs_z_final[:, :] = abs_z_final[::-1, :]
-    pyplot.matshow(abs_z_final < escape_radius)
-    pyplot.title(f"Julia set of ${function_label}$, $c={function_params}$")
-    pyplot.show()
+    plt.matshow(abs_z_final < escape_radius)
+    plt.title(f"Julia set of ${function_label}$, $c={function_params}$")
+    plt.show()
 
 
 def ignore_overflow_warnings() -> None:
diff --git a/fractals/koch_snowflake.py b/fractals/koch_snowflake.py
index 30cd4b39c7c1..724b78f41a69 100644
--- a/fractals/koch_snowflake.py
+++ b/fractals/koch_snowflake.py
@@ -22,25 +22,25 @@
 
 from __future__ import annotations
 
-import matplotlib.pyplot as plt  # type: ignore
-import numpy
+import matplotlib.pyplot as plt
+import numpy as np
 
 # initial triangle of Koch snowflake
-VECTOR_1 = numpy.array([0, 0])
-VECTOR_2 = numpy.array([0.5, 0.8660254])
-VECTOR_3 = numpy.array([1, 0])
+VECTOR_1 = np.array([0, 0])
+VECTOR_2 = np.array([0.5, 0.8660254])
+VECTOR_3 = np.array([1, 0])
 INITIAL_VECTORS = [VECTOR_1, VECTOR_2, VECTOR_3, VECTOR_1]
 
 # uncomment for simple Koch curve instead of Koch snowflake
 # INITIAL_VECTORS = [VECTOR_1, VECTOR_3]
 
 
-def iterate(initial_vectors: list[numpy.ndarray], steps: int) -> list[numpy.ndarray]:
+def iterate(initial_vectors: list[np.ndarray], steps: int) -> list[np.ndarray]:
     """
     Go through the number of iterations determined by the argument "steps".
     Be careful with high values (above 5) since the time to calculate increases
     exponentially.
-    >>> iterate([numpy.array([0, 0]), numpy.array([1, 0])], 1)
+    >>> iterate([np.array([0, 0]), np.array([1, 0])], 1)
     [array([0, 0]), array([0.33333333, 0.        ]), array([0.5       , \
 0.28867513]), array([0.66666667, 0.        ]), array([1, 0])]
     """
@@ -50,13 +50,13 @@ def iterate(initial_vectors: list[numpy.ndarray], steps: int) -> list[numpy.ndar
     return vectors
 
 
-def iteration_step(vectors: list[numpy.ndarray]) -> list[numpy.ndarray]:
+def iteration_step(vectors: list[np.ndarray]) -> list[np.ndarray]:
     """
     Loops through each pair of adjacent vectors. Each line between two adjacent
     vectors is divided into 4 segments by adding 3 additional vectors in-between
     the original two vectors. The vector in the middle is constructed through a
     60 degree rotation so it is bent outwards.
-    >>> iteration_step([numpy.array([0, 0]), numpy.array([1, 0])])
+    >>> iteration_step([np.array([0, 0]), np.array([1, 0])])
     [array([0, 0]), array([0.33333333, 0.        ]), array([0.5       , \
 0.28867513]), array([0.66666667, 0.        ]), array([1, 0])]
     """
@@ -74,22 +74,22 @@ def iteration_step(vectors: list[numpy.ndarray]) -> list[numpy.ndarray]:
     return new_vectors
 
 
-def rotate(vector: numpy.ndarray, angle_in_degrees: float) -> numpy.ndarray:
+def rotate(vector: np.ndarray, angle_in_degrees: float) -> np.ndarray:
     """
     Standard rotation of a 2D vector with a rotation matrix
     (see https://en.wikipedia.org/wiki/Rotation_matrix )
-    >>> rotate(numpy.array([1, 0]), 60)
+    >>> rotate(np.array([1, 0]), 60)
     array([0.5      , 0.8660254])
-    >>> rotate(numpy.array([1, 0]), 90)
+    >>> rotate(np.array([1, 0]), 90)
     array([6.123234e-17, 1.000000e+00])
     """
-    theta = numpy.radians(angle_in_degrees)
-    c, s = numpy.cos(theta), numpy.sin(theta)
-    rotation_matrix = numpy.array(((c, -s), (s, c)))
-    return numpy.dot(rotation_matrix, vector)
+    theta = np.radians(angle_in_degrees)
+    c, s = np.cos(theta), np.sin(theta)
+    rotation_matrix = np.array(((c, -s), (s, c)))
+    return np.dot(rotation_matrix, vector)
 
 
-def plot(vectors: list[numpy.ndarray]) -> None:
+def plot(vectors: list[np.ndarray]) -> None:
     """
     Utility function to plot the vectors using matplotlib.pyplot
     No doctest was implemented since this function does not have a return value
diff --git a/graphics/bezier_curve.py b/graphics/bezier_curve.py
index 7c22329ad8b4..6eeb89da6bdf 100644
--- a/graphics/bezier_curve.py
+++ b/graphics/bezier_curve.py
@@ -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  # type: ignore
+        from matplotlib import pyplot as plt
 
         to_plot_x: list[float] = []  # x coordinates of points to plot
         to_plot_y: list[float] = []  # y coordinates of points to plot
diff --git a/graphs/directed_and_undirected_(weighted)_graph.py b/graphs/directed_and_undirected_weighted_graph.py
similarity index 100%
rename from graphs/directed_and_undirected_(weighted)_graph.py
rename to graphs/directed_and_undirected_weighted_graph.py
diff --git a/graphs/graph_list.py b/graphs/graph_list.py
index e871f3b8a9d6..6563cbb76132 100644
--- a/graphs/graph_list.py
+++ b/graphs/graph_list.py
@@ -120,29 +120,29 @@ def add_edge(
             else:
                 self.adj_list[source_vertex] = [destination_vertex]
                 self.adj_list[destination_vertex] = [source_vertex]
-        else:  # For directed graphs
-            # if both source vertex and destination vertex are present in adjacency
-            # list, add destination vertex to source vertex list of adjacent vertices.
-            if source_vertex in self.adj_list and destination_vertex in self.adj_list:
-                self.adj_list[source_vertex].append(destination_vertex)
-            # if only source vertex is present in adjacency list, add destination
-            # vertex to source vertex list of adjacent vertices and create a new vertex
-            # with destination vertex as key, which has no adjacent vertex
-            elif source_vertex in self.adj_list:
-                self.adj_list[source_vertex].append(destination_vertex)
-                self.adj_list[destination_vertex] = []
-            # if only destination vertex is present in adjacency list, create a new
-            # vertex with source vertex as key and assign a list containing destination
-            # vertex as first adjacent vertex
-            elif destination_vertex in self.adj_list:
-                self.adj_list[source_vertex] = [destination_vertex]
-            # if both source vertex and destination vertex are not present in adjacency
-            # list, create a new vertex with source vertex as key and a list containing
-            # destination vertex as it's first adjacent vertex. Then create a new vertex
-            # with destination vertex as key, which has no adjacent vertex
-            else:
-                self.adj_list[source_vertex] = [destination_vertex]
-                self.adj_list[destination_vertex] = []
+        # For directed graphs
+        # if both source vertex and destination vertex are present in adjacency
+        # list, add destination vertex to source vertex list of adjacent vertices.
+        elif source_vertex in self.adj_list and destination_vertex in self.adj_list:
+            self.adj_list[source_vertex].append(destination_vertex)
+        # if only source vertex is present in adjacency list, add destination
+        # vertex to source vertex list of adjacent vertices and create a new vertex
+        # with destination vertex as key, which has no adjacent vertex
+        elif source_vertex in self.adj_list:
+            self.adj_list[source_vertex].append(destination_vertex)
+            self.adj_list[destination_vertex] = []
+        # if only destination vertex is present in adjacency list, create a new
+        # vertex with source vertex as key and assign a list containing destination
+        # vertex as first adjacent vertex
+        elif destination_vertex in self.adj_list:
+            self.adj_list[source_vertex] = [destination_vertex]
+        # if both source vertex and destination vertex are not present in adjacency
+        # list, create a new vertex with source vertex as key and a list containing
+        # destination vertex as it's first adjacent vertex. Then create a new vertex
+        # with destination vertex as key, which has no adjacent vertex
+        else:
+            self.adj_list[source_vertex] = [destination_vertex]
+            self.adj_list[destination_vertex] = []
 
         return self
 
diff --git a/graphs/minimum_spanning_tree_prims.py b/graphs/minimum_spanning_tree_prims.py
index 5a08ec57ff4d..90c9f4c91e86 100644
--- a/graphs/minimum_spanning_tree_prims.py
+++ b/graphs/minimum_spanning_tree_prims.py
@@ -18,11 +18,10 @@ def top_to_bottom(self, heap, start, size, positions):
         else:
             if 2 * start + 2 >= size:
                 smallest_child = 2 * start + 1
+            elif heap[2 * start + 1] < heap[2 * start + 2]:
+                smallest_child = 2 * start + 1
             else:
-                if heap[2 * start + 1] < heap[2 * start + 2]:
-                    smallest_child = 2 * start + 1
-                else:
-                    smallest_child = 2 * start + 2
+                smallest_child = 2 * start + 2
             if heap[smallest_child] < heap[start]:
                 temp, temp1 = heap[smallest_child], positions[smallest_child]
                 heap[smallest_child], positions[smallest_child] = (
diff --git a/graphs/multi_heuristic_astar.py b/graphs/multi_heuristic_astar.py
index 0a18ede6ed41..6af9a187a4e9 100644
--- a/graphs/multi_heuristic_astar.py
+++ b/graphs/multi_heuristic_astar.py
@@ -270,24 +270,23 @@ def multi_a_star(start: TPos, goal: TPos, n_heuristic: int):
                         back_pointer,
                     )
                     close_list_inad.append(get_s)
+            elif g_function[goal] <= open_list[0].minkey():
+                if g_function[goal] < float("inf"):
+                    do_something(back_pointer, goal, start)
             else:
-                if g_function[goal] <= open_list[0].minkey():
-                    if g_function[goal] < float("inf"):
-                        do_something(back_pointer, goal, start)
-                else:
-                    get_s = open_list[0].top_show()
-                    visited.add(get_s)
-                    expand_state(
-                        get_s,
-                        0,
-                        visited,
-                        g_function,
-                        close_list_anchor,
-                        close_list_inad,
-                        open_list,
-                        back_pointer,
-                    )
-                    close_list_anchor.append(get_s)
+                get_s = open_list[0].top_show()
+                visited.add(get_s)
+                expand_state(
+                    get_s,
+                    0,
+                    visited,
+                    g_function,
+                    close_list_anchor,
+                    close_list_inad,
+                    open_list,
+                    back_pointer,
+                )
+                close_list_anchor.append(get_s)
     print("No path found to goal")
     print()
     for i in range(n - 1, -1, -1):
diff --git a/machine_learning/forecasting/run.py b/machine_learning/forecasting/run.py
index 64e719daacc2..dbb86caf8568 100644
--- a/machine_learning/forecasting/run.py
+++ b/machine_learning/forecasting/run.py
@@ -113,11 +113,10 @@ def data_safety_checker(list_vote: list, actual_result: float) -> bool:
     for i in list_vote:
         if i > actual_result:
             safe = not_safe + 1
+        elif abs(abs(i) - abs(actual_result)) <= 0.1:
+            safe += 1
         else:
-            if abs(abs(i) - abs(actual_result)) <= 0.1:
-                safe += 1
-            else:
-                not_safe += 1
+            not_safe += 1
     return safe > not_safe
 
 
diff --git a/machine_learning/gradient_descent.py b/machine_learning/gradient_descent.py
index db38b3c95b52..95463faf5635 100644
--- a/machine_learning/gradient_descent.py
+++ b/machine_learning/gradient_descent.py
@@ -3,7 +3,7 @@
 function.
 """
 
-import numpy
+import numpy as np
 
 # List of input, output pairs
 train_data = (
@@ -116,7 +116,7 @@ def run_gradient_descent():
             temp_parameter_vector[i] = (
                 parameter_vector[i] - LEARNING_RATE * cost_derivative
             )
-        if numpy.allclose(
+        if np.allclose(
             parameter_vector,
             temp_parameter_vector,
             atol=absolute_error_limit,
diff --git a/maths/largest_of_very_large_numbers.py b/maths/largest_of_very_large_numbers.py
index eb5c121fd262..edee50371e02 100644
--- a/maths/largest_of_very_large_numbers.py
+++ b/maths/largest_of_very_large_numbers.py
@@ -20,11 +20,10 @@ def res(x, y):
     if 0 not in (x, y):
         # We use the relation x^y = y*log10(x), where 10 is the base.
         return y * math.log10(x)
-    else:
-        if x == 0:  # 0 raised to any number is 0
-            return 0
-        elif y == 0:
-            return 1  # any number raised to 0 is 1
+    elif x == 0:  # 0 raised to any number is 0
+        return 0
+    elif y == 0:
+        return 1  # any number raised to 0 is 1
     raise AssertionError("This should never happen")
 
 
diff --git a/maths/pollard_rho.py b/maths/pollard_rho.py
index 5082f54f71a8..e8bc89cef6c5 100644
--- a/maths/pollard_rho.py
+++ b/maths/pollard_rho.py
@@ -94,14 +94,13 @@ def rand_fn(value: int, step: int, modulus: int) -> int:
             if divisor == 1:
                 # No common divisor yet, just keep searching.
                 continue
+            # We found a common divisor!
+            elif divisor == num:
+                # Unfortunately, the divisor is ``num`` itself and is useless.
+                break
             else:
-                # We found a common divisor!
-                if divisor == num:
-                    # Unfortunately, the divisor is ``num`` itself and is useless.
-                    break
-                else:
-                    # The divisor is a nontrivial factor of ``num``!
-                    return divisor
+                # The divisor is a nontrivial factor of ``num``!
+                return divisor
 
         # If we made it here, then this attempt failed.
         # We need to pick a new starting seed for the tortoise and hare
diff --git a/matrix/cramers_rule_2x2.py b/matrix/cramers_rule_2x2.py
index 4f52dbe646ad..081035bec002 100644
--- a/matrix/cramers_rule_2x2.py
+++ b/matrix/cramers_rule_2x2.py
@@ -73,12 +73,11 @@ def cramers_rule_2x2(equation1: list[int], equation2: list[int]) -> tuple[float,
             raise ValueError("Infinite solutions. (Consistent system)")
         else:
             raise ValueError("No solution. (Inconsistent system)")
+    elif determinant_x == determinant_y == 0:
+        # Trivial solution (Inconsistent system)
+        return (0.0, 0.0)
     else:
-        if determinant_x == determinant_y == 0:
-            # Trivial solution (Inconsistent system)
-            return (0.0, 0.0)
-        else:
-            x = determinant_x / determinant
-            y = determinant_y / determinant
-            # Non-Trivial Solution (Consistent system)
-            return (x, y)
+        x = determinant_x / determinant
+        y = determinant_y / determinant
+        # Non-Trivial Solution (Consistent system)
+        return (x, y)
diff --git a/neural_network/input_data.py b/neural_network/input_data.py
index f7ae86b48e65..9d4195487dbb 100644
--- a/neural_network/input_data.py
+++ b/neural_network/input_data.py
@@ -22,7 +22,7 @@
 import typing
 import urllib
 
-import numpy
+import numpy as np
 from tensorflow.python.framework import dtypes, random_seed
 from tensorflow.python.platform import gfile
 from tensorflow.python.util.deprecation import deprecated
@@ -39,8 +39,8 @@ class _Datasets(typing.NamedTuple):
 
 
 def _read32(bytestream):
-    dt = numpy.dtype(numpy.uint32).newbyteorder(">")
-    return numpy.frombuffer(bytestream.read(4), dtype=dt)[0]
+    dt = np.dtype(np.uint32).newbyteorder(">")
+    return np.frombuffer(bytestream.read(4), dtype=dt)[0]
 
 
 @deprecated(None, "Please use tf.data to implement this functionality.")
@@ -68,7 +68,7 @@ def _extract_images(f):
         rows = _read32(bytestream)
         cols = _read32(bytestream)
         buf = bytestream.read(rows * cols * num_images)
-        data = numpy.frombuffer(buf, dtype=numpy.uint8)
+        data = np.frombuffer(buf, dtype=np.uint8)
         data = data.reshape(num_images, rows, cols, 1)
         return data
 
@@ -77,8 +77,8 @@ def _extract_images(f):
 def _dense_to_one_hot(labels_dense, num_classes):
     """Convert class labels from scalars to one-hot vectors."""
     num_labels = labels_dense.shape[0]
-    index_offset = numpy.arange(num_labels) * num_classes
-    labels_one_hot = numpy.zeros((num_labels, num_classes))
+    index_offset = np.arange(num_labels) * num_classes
+    labels_one_hot = np.zeros((num_labels, num_classes))
     labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1
     return labels_one_hot
 
@@ -107,7 +107,7 @@ def _extract_labels(f, one_hot=False, num_classes=10):
             )
         num_items = _read32(bytestream)
         buf = bytestream.read(num_items)
-        labels = numpy.frombuffer(buf, dtype=numpy.uint8)
+        labels = np.frombuffer(buf, dtype=np.uint8)
         if one_hot:
             return _dense_to_one_hot(labels, num_classes)
         return labels
@@ -153,7 +153,7 @@ def __init__(
         """
         seed1, seed2 = random_seed.get_seed(seed)
         # If op level seed is not set, use whatever graph level seed is returned
-        numpy.random.seed(seed1 if seed is None else seed2)
+        np.random.seed(seed1 if seed is None else seed2)
         dtype = dtypes.as_dtype(dtype).base_dtype
         if dtype not in (dtypes.uint8, dtypes.float32):
             raise TypeError("Invalid image dtype %r, expected uint8 or float32" % dtype)
@@ -175,8 +175,8 @@ def __init__(
                 )
             if dtype == dtypes.float32:
                 # Convert from [0, 255] -> [0.0, 1.0].
-                images = images.astype(numpy.float32)
-                images = numpy.multiply(images, 1.0 / 255.0)
+                images = images.astype(np.float32)
+                images = np.multiply(images, 1.0 / 255.0)
         self._images = images
         self._labels = labels
         self._epochs_completed = 0
@@ -210,8 +210,8 @@ def next_batch(self, batch_size, fake_data=False, shuffle=True):
         start = self._index_in_epoch
         # Shuffle for the first epoch
         if self._epochs_completed == 0 and start == 0 and shuffle:
-            perm0 = numpy.arange(self._num_examples)
-            numpy.random.shuffle(perm0)
+            perm0 = np.arange(self._num_examples)
+            np.random.shuffle(perm0)
             self._images = self.images[perm0]
             self._labels = self.labels[perm0]
         # Go to the next epoch
@@ -224,8 +224,8 @@ def next_batch(self, batch_size, fake_data=False, shuffle=True):
             labels_rest_part = self._labels[start : self._num_examples]
             # Shuffle the data
             if shuffle:
-                perm = numpy.arange(self._num_examples)
-                numpy.random.shuffle(perm)
+                perm = np.arange(self._num_examples)
+                np.random.shuffle(perm)
                 self._images = self.images[perm]
                 self._labels = self.labels[perm]
             # Start next epoch
@@ -235,8 +235,8 @@ def next_batch(self, batch_size, fake_data=False, shuffle=True):
             images_new_part = self._images[start:end]
             labels_new_part = self._labels[start:end]
             return (
-                numpy.concatenate((images_rest_part, images_new_part), axis=0),
-                numpy.concatenate((labels_rest_part, labels_new_part), axis=0),
+                np.concatenate((images_rest_part, images_new_part), axis=0),
+                np.concatenate((labels_rest_part, labels_new_part), axis=0),
             )
         else:
             self._index_in_epoch += batch_size
diff --git a/neural_network/2_hidden_layers_neural_network.py b/neural_network/two_hidden_layers_neural_network.py
similarity index 80%
rename from neural_network/2_hidden_layers_neural_network.py
rename to neural_network/two_hidden_layers_neural_network.py
index 7b374a93d039..dea7e2342d9f 100644
--- a/neural_network/2_hidden_layers_neural_network.py
+++ b/neural_network/two_hidden_layers_neural_network.py
@@ -5,11 +5,11 @@
     - https://en.wikipedia.org/wiki/Feedforward_neural_network (Feedforward)
 """
 
-import numpy
+import numpy as np
 
 
 class TwoHiddenLayerNeuralNetwork:
-    def __init__(self, input_array: numpy.ndarray, output_array: numpy.ndarray) -> None:
+    def __init__(self, input_array: np.ndarray, output_array: np.ndarray) -> None:
         """
         This function initializes the TwoHiddenLayerNeuralNetwork class with random
         weights for every layer and initializes predicted output with zeroes.
@@ -28,30 +28,28 @@ def __init__(self, input_array: numpy.ndarray, output_array: numpy.ndarray) -> N
         # Random initial weights are assigned.
         # self.input_array.shape[1] is used to represent number of nodes in input layer.
         # First hidden layer consists of 4 nodes.
-        self.input_layer_and_first_hidden_layer_weights = numpy.random.rand(
+        self.input_layer_and_first_hidden_layer_weights = np.random.rand(
             self.input_array.shape[1], 4
         )
 
         # Random initial values for the first hidden layer.
         # First hidden layer has 4 nodes.
         # Second hidden layer has 3 nodes.
-        self.first_hidden_layer_and_second_hidden_layer_weights = numpy.random.rand(
-            4, 3
-        )
+        self.first_hidden_layer_and_second_hidden_layer_weights = np.random.rand(4, 3)
 
         # Random initial values for the second hidden layer.
         # Second hidden layer has 3 nodes.
         # Output layer has 1 node.
-        self.second_hidden_layer_and_output_layer_weights = numpy.random.rand(3, 1)
+        self.second_hidden_layer_and_output_layer_weights = np.random.rand(3, 1)
 
         # Real output values provided.
         self.output_array = output_array
 
         # Predicted output values by the neural network.
         # Predicted_output array initially consists of zeroes.
-        self.predicted_output = numpy.zeros(output_array.shape)
+        self.predicted_output = np.zeros(output_array.shape)
 
-    def feedforward(self) -> numpy.ndarray:
+    def feedforward(self) -> np.ndarray:
         """
         The information moves in only one direction i.e. forward from the input nodes,
         through the two hidden nodes and to the output nodes.
@@ -60,24 +58,24 @@ def feedforward(self) -> numpy.ndarray:
         Return layer_between_second_hidden_layer_and_output
             (i.e the last layer of the neural network).
 
-        >>> input_val = numpy.array(([0, 0, 0], [0, 0, 0], [0, 0, 0]), dtype=float)
-        >>> output_val = numpy.array(([0], [0], [0]), dtype=float)
+        >>> input_val = np.array(([0, 0, 0], [0, 0, 0], [0, 0, 0]), dtype=float)
+        >>> output_val = np.array(([0], [0], [0]), dtype=float)
         >>> nn = TwoHiddenLayerNeuralNetwork(input_val, output_val)
         >>> res = nn.feedforward()
-        >>> array_sum = numpy.sum(res)
-        >>> numpy.isnan(array_sum)
+        >>> array_sum = np.sum(res)
+        >>> np.isnan(array_sum)
         False
         """
         # Layer_between_input_and_first_hidden_layer is the layer connecting the
         # input nodes with the first hidden layer nodes.
         self.layer_between_input_and_first_hidden_layer = sigmoid(
-            numpy.dot(self.input_array, self.input_layer_and_first_hidden_layer_weights)
+            np.dot(self.input_array, self.input_layer_and_first_hidden_layer_weights)
         )
 
         # layer_between_first_hidden_layer_and_second_hidden_layer is the layer
         # connecting the first hidden set of nodes with the second hidden set of nodes.
         self.layer_between_first_hidden_layer_and_second_hidden_layer = sigmoid(
-            numpy.dot(
+            np.dot(
                 self.layer_between_input_and_first_hidden_layer,
                 self.first_hidden_layer_and_second_hidden_layer_weights,
             )
@@ -86,7 +84,7 @@ def feedforward(self) -> numpy.ndarray:
         # layer_between_second_hidden_layer_and_output is the layer connecting
         # second hidden layer with the output node.
         self.layer_between_second_hidden_layer_and_output = sigmoid(
-            numpy.dot(
+            np.dot(
                 self.layer_between_first_hidden_layer_and_second_hidden_layer,
                 self.second_hidden_layer_and_output_layer_weights,
             )
@@ -100,8 +98,8 @@ def back_propagation(self) -> None:
         error rate obtained in the previous epoch (i.e., iteration).
         Updation is done using derivative of sogmoid activation function.
 
-        >>> input_val = numpy.array(([0, 0, 0], [0, 0, 0], [0, 0, 0]), dtype=float)
-        >>> output_val = numpy.array(([0], [0], [0]), dtype=float)
+        >>> input_val = np.array(([0, 0, 0], [0, 0, 0], [0, 0, 0]), dtype=float)
+        >>> output_val = np.array(([0], [0], [0]), dtype=float)
         >>> nn = TwoHiddenLayerNeuralNetwork(input_val, output_val)
         >>> res = nn.feedforward()
         >>> nn.back_propagation()
@@ -110,15 +108,15 @@ def back_propagation(self) -> None:
         False
         """
 
-        updated_second_hidden_layer_and_output_layer_weights = numpy.dot(
+        updated_second_hidden_layer_and_output_layer_weights = np.dot(
             self.layer_between_first_hidden_layer_and_second_hidden_layer.T,
             2
             * (self.output_array - self.predicted_output)
             * sigmoid_derivative(self.predicted_output),
         )
-        updated_first_hidden_layer_and_second_hidden_layer_weights = numpy.dot(
+        updated_first_hidden_layer_and_second_hidden_layer_weights = np.dot(
             self.layer_between_input_and_first_hidden_layer.T,
-            numpy.dot(
+            np.dot(
                 2
                 * (self.output_array - self.predicted_output)
                 * sigmoid_derivative(self.predicted_output),
@@ -128,10 +126,10 @@ def back_propagation(self) -> None:
                 self.layer_between_first_hidden_layer_and_second_hidden_layer
             ),
         )
-        updated_input_layer_and_first_hidden_layer_weights = numpy.dot(
+        updated_input_layer_and_first_hidden_layer_weights = np.dot(
             self.input_array.T,
-            numpy.dot(
-                numpy.dot(
+            np.dot(
+                np.dot(
                     2
                     * (self.output_array - self.predicted_output)
                     * sigmoid_derivative(self.predicted_output),
@@ -155,7 +153,7 @@ def back_propagation(self) -> None:
             updated_second_hidden_layer_and_output_layer_weights
         )
 
-    def train(self, output: numpy.ndarray, iterations: int, give_loss: bool) -> None:
+    def train(self, output: np.ndarray, iterations: int, give_loss: bool) -> None:
         """
         Performs the feedforwarding and back propagation process for the
         given number of iterations.
@@ -166,8 +164,8 @@ def train(self, output: numpy.ndarray, iterations: int, give_loss: bool) -> None
         give_loss : boolean value, If True then prints loss for each iteration,
                     If False then nothing is printed
 
-        >>> input_val = numpy.array(([0, 0, 0], [0, 1, 0], [0, 0, 1]), dtype=float)
-        >>> output_val = numpy.array(([0], [1], [1]), dtype=float)
+        >>> input_val = np.array(([0, 0, 0], [0, 1, 0], [0, 0, 1]), dtype=float)
+        >>> output_val = np.array(([0], [1], [1]), dtype=float)
         >>> nn = TwoHiddenLayerNeuralNetwork(input_val, output_val)
         >>> first_iteration_weights = nn.feedforward()
         >>> nn.back_propagation()
@@ -179,10 +177,10 @@ def train(self, output: numpy.ndarray, iterations: int, give_loss: bool) -> None
             self.output = self.feedforward()
             self.back_propagation()
             if give_loss:
-                loss = numpy.mean(numpy.square(output - self.feedforward()))
+                loss = np.mean(np.square(output - self.feedforward()))
                 print(f"Iteration {iteration} Loss: {loss}")
 
-    def predict(self, input_arr: numpy.ndarray) -> int:
+    def predict(self, input_arr: np.ndarray) -> int:
         """
         Predict's the output for the given input values using
         the trained neural network.
@@ -192,8 +190,8 @@ def predict(self, input_arr: numpy.ndarray) -> int:
         than the threshold value else returns 0,
         as the real output values are in binary.
 
-        >>> input_val = numpy.array(([0, 0, 0], [0, 1, 0], [0, 0, 1]), dtype=float)
-        >>> output_val = numpy.array(([0], [1], [1]), dtype=float)
+        >>> input_val = np.array(([0, 0, 0], [0, 1, 0], [0, 0, 1]), dtype=float)
+        >>> output_val = np.array(([0], [1], [1]), dtype=float)
         >>> nn = TwoHiddenLayerNeuralNetwork(input_val, output_val)
         >>> nn.train(output_val, 1000, False)
         >>> nn.predict([0, 1, 0]) in (0, 1)
@@ -204,18 +202,18 @@ def predict(self, input_arr: numpy.ndarray) -> int:
         self.array = input_arr
 
         self.layer_between_input_and_first_hidden_layer = sigmoid(
-            numpy.dot(self.array, self.input_layer_and_first_hidden_layer_weights)
+            np.dot(self.array, self.input_layer_and_first_hidden_layer_weights)
         )
 
         self.layer_between_first_hidden_layer_and_second_hidden_layer = sigmoid(
-            numpy.dot(
+            np.dot(
                 self.layer_between_input_and_first_hidden_layer,
                 self.first_hidden_layer_and_second_hidden_layer_weights,
             )
         )
 
         self.layer_between_second_hidden_layer_and_output = sigmoid(
-            numpy.dot(
+            np.dot(
                 self.layer_between_first_hidden_layer_and_second_hidden_layer,
                 self.second_hidden_layer_and_output_layer_weights,
             )
@@ -224,26 +222,26 @@ def predict(self, input_arr: numpy.ndarray) -> int:
         return int((self.layer_between_second_hidden_layer_and_output > 0.6)[0])
 
 
-def sigmoid(value: numpy.ndarray) -> numpy.ndarray:
+def sigmoid(value: np.ndarray) -> np.ndarray:
     """
     Applies sigmoid activation function.
 
     return normalized values
 
-    >>> sigmoid(numpy.array(([1, 0, 2], [1, 0, 0]), dtype=numpy.float64))
+    >>> sigmoid(np.array(([1, 0, 2], [1, 0, 0]), dtype=np.float64))
     array([[0.73105858, 0.5       , 0.88079708],
            [0.73105858, 0.5       , 0.5       ]])
     """
-    return 1 / (1 + numpy.exp(-value))
+    return 1 / (1 + np.exp(-value))
 
 
-def sigmoid_derivative(value: numpy.ndarray) -> numpy.ndarray:
+def sigmoid_derivative(value: np.ndarray) -> np.ndarray:
     """
     Provides the derivative value of the sigmoid function.
 
     returns derivative of the sigmoid value
 
-    >>> sigmoid_derivative(numpy.array(([1, 0, 2], [1, 0, 0]), dtype=numpy.float64))
+    >>> sigmoid_derivative(np.array(([1, 0, 2], [1, 0, 0]), dtype=np.float64))
     array([[ 0.,  0., -2.],
            [ 0.,  0.,  0.]])
     """
@@ -264,7 +262,7 @@ def example() -> int:
     True
     """
     # Input values.
-    test_input = numpy.array(
+    test_input = np.array(
         (
             [0, 0, 0],
             [0, 0, 1],
@@ -275,11 +273,11 @@ def example() -> int:
             [1, 1, 0],
             [1, 1, 1],
         ),
-        dtype=numpy.float64,
+        dtype=np.float64,
     )
 
     # True output values for the given input values.
-    output = numpy.array(([0], [1], [1], [0], [1], [0], [0], [1]), dtype=numpy.float64)
+    output = np.array(([0], [1], [1], [0], [1], [0], [0], [1]), dtype=np.float64)
 
     # Calling neural network class.
     neural_network = TwoHiddenLayerNeuralNetwork(
@@ -290,7 +288,7 @@ def example() -> int:
     # Set give_loss to True if you want to see loss in every iteration.
     neural_network.train(output=output, iterations=10, give_loss=False)
 
-    return neural_network.predict(numpy.array(([1, 1, 1]), dtype=numpy.float64))
+    return neural_network.predict(np.array(([1, 1, 1]), dtype=np.float64))
 
 
 if __name__ == "__main__":
diff --git a/project_euler/problem_019/sol1.py b/project_euler/problem_019/sol1.py
index 0e38137d4f01..656f104c390d 100644
--- a/project_euler/problem_019/sol1.py
+++ b/project_euler/problem_019/sol1.py
@@ -46,10 +46,9 @@ def solution():
             elif day > 29 and month == 2:
                 month += 1
                 day = day - 29
-        else:
-            if day > days_per_month[month - 1]:
-                month += 1
-                day = day - days_per_month[month - 2]
+        elif day > days_per_month[month - 1]:
+            month += 1
+            day = day - days_per_month[month - 2]
 
         if month > 12:
             year += 1
diff --git a/pyproject.toml b/pyproject.toml
index 5187491e5ee7..22da7cb777b5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,14 +6,10 @@ lint.ignore = [    # `ruff rule S101` for a description of that rule
   "EM101",    # Exception must not use a string literal, assign to variable first
   "EXE001",   # Shebang is present but file is not executable" -- FIX ME
   "G004",     # Logging statement uses f-string
-  "ICN001",   # `matplotlib.pyplot` should be imported as `plt` -- FIX ME
   "INP001",   # File `x/y/z.py` is part of an implicit namespace package. Add an `__init__.py`. -- FIX ME
-  "N999",     # Invalid module name -- FIX ME
   "NPY002",   # Replace legacy `np.random.choice` call with `np.random.Generator` -- FIX ME
   "PGH003",   # Use specific rule codes when ignoring type issues -- FIX ME
   "PLC1901",  # `{}` can be simplified to `{}` as an empty string is falsey
-  "PLR5501",  # Consider using `elif` instead of `else` -- FIX ME
-  "PLW0120",  # `else` clause on loop without a `break` statement -- FIX ME
   "PLW060",   # Using global for `{name}` but no assignment is done -- DO NOT FIX
   "PLW2901",  # PLW2901: Redefined loop variable -- FIX ME
   "PT011",    # `pytest.raises(Exception)` is too broad, set the `match` parameter or use a more specific exception
diff --git a/searches/fibonacci_search.py b/searches/fibonacci_search.py
index ec3dfa7f30f6..7b2252a68be2 100644
--- a/searches/fibonacci_search.py
+++ b/searches/fibonacci_search.py
@@ -123,8 +123,7 @@ def fibonacci_search(arr: list, val: int) -> int:
         elif val > item_k_1:
             offset += fibonacci(fibb_k - 1)
             fibb_k -= 2
-    else:
-        return -1
+    return -1
 
 
 if __name__ == "__main__":
diff --git a/searches/hill_climbing.py b/searches/hill_climbing.py
index 83a3b8b74e27..689b7e5cca8f 100644
--- a/searches/hill_climbing.py
+++ b/searches/hill_climbing.py
@@ -137,11 +137,10 @@ def hill_climbing(
                 if change > max_change and change > 0:
                     max_change = change
                     next_state = neighbor
-            else:  # finding min
+            elif change < min_change and change < 0:  # finding min
                 # to direction with greatest descent
-                if change < min_change and change < 0:
-                    min_change = change
-                    next_state = neighbor
+                min_change = change
+                next_state = neighbor
         if next_state is not None:
             # we found at least one neighbor which improved the current state
             current_state = next_state
diff --git a/searches/interpolation_search.py b/searches/interpolation_search.py
index 49194c2600a0..0591788aa40b 100644
--- a/searches/interpolation_search.py
+++ b/searches/interpolation_search.py
@@ -33,18 +33,16 @@ def interpolation_search(sorted_collection, item):
         current_item = sorted_collection[point]
         if current_item == item:
             return point
+        elif point < left:
+            right = left
+            left = point
+        elif point > right:
+            left = right
+            right = point
+        elif item < current_item:
+            right = point - 1
         else:
-            if point < left:
-                right = left
-                left = point
-            elif point > right:
-                left = right
-                right = point
-            else:
-                if item < current_item:
-                    right = point - 1
-                else:
-                    left = point + 1
+            left = point + 1
     return None
 
 
@@ -79,15 +77,14 @@ def interpolation_search_by_recursion(sorted_collection, item, left, right):
         return interpolation_search_by_recursion(sorted_collection, item, point, left)
     elif point > right:
         return interpolation_search_by_recursion(sorted_collection, item, right, left)
+    elif sorted_collection[point] > item:
+        return interpolation_search_by_recursion(
+            sorted_collection, item, left, point - 1
+        )
     else:
-        if sorted_collection[point] > item:
-            return interpolation_search_by_recursion(
-                sorted_collection, item, left, point - 1
-            )
-        else:
-            return interpolation_search_by_recursion(
-                sorted_collection, item, point + 1, right
-            )
+        return interpolation_search_by_recursion(
+            sorted_collection, item, point + 1, right
+        )
 
 
 def __assert_sorted(collection):
diff --git a/searches/ternary_search.py b/searches/ternary_search.py
index 8dcd6b5bde2e..73e4b1ddc68b 100644
--- a/searches/ternary_search.py
+++ b/searches/ternary_search.py
@@ -106,8 +106,7 @@ def ite_ternary_search(array: list[int], target: int) -> int:
         else:
             left = one_third + 1
             right = two_third - 1
-    else:
-        return -1
+    return -1
 
 
 def rec_ternary_search(left: int, right: int, array: list[int], target: int) -> int:
diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py
index 0fad0b88c370..d147a9d7954c 100644
--- a/strings/min_cost_string_conversion.py
+++ b/strings/min_cost_string_conversion.py
@@ -60,19 +60,18 @@ def compute_transform_tables(
 def assemble_transformation(ops: list[list[str]], i: int, j: int) -> list[str]:
     if i == 0 and j == 0:
         return []
+    elif ops[i][j][0] in {"C", "R"}:
+        seq = assemble_transformation(ops, i - 1, j - 1)
+        seq.append(ops[i][j])
+        return seq
+    elif ops[i][j][0] == "D":
+        seq = assemble_transformation(ops, i - 1, j)
+        seq.append(ops[i][j])
+        return seq
     else:
-        if ops[i][j][0] in {"C", "R"}:
-            seq = assemble_transformation(ops, i - 1, j - 1)
-            seq.append(ops[i][j])
-            return seq
-        elif ops[i][j][0] == "D":
-            seq = assemble_transformation(ops, i - 1, j)
-            seq.append(ops[i][j])
-            return seq
-        else:
-            seq = assemble_transformation(ops, i, j - 1)
-            seq.append(ops[i][j])
-            return seq
+        seq = assemble_transformation(ops, i, j - 1)
+        seq.append(ops[i][j])
+        return seq
 
 
 if __name__ == "__main__":