Enable ruff PLR5501 rule (TheAlgorithms#11332)

* Enable ruff PLR5501 rule

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: MaximSmolskiy

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
 
 

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
 

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] = (

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

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:

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
 

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.

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:

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]

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),

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

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

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
 

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] = (

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):

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
 
 

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

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

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)

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

pyproject.toml

@@ -12,7 +12,6 @@ lint.ignore = [    # `ruff rule S101` for a description of that rule
   "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

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

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):

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