ref(chore): make code more readable

Author: sozelfist

backtracking/knight_tour.py

@@ -26,35 +26,43 @@ def __init__(self, board_size: int):
         self.board_size = board_size
         self.board = [[0 for _ in range(board_size)] for _ in range(board_size)]
 
-    def get_valid_moves(self, position: tuple[int, int]) -> list[tuple[int, int]]:
+    def _is_valid_move(self, position: tuple[int, int], move: tuple[int, int]) -> bool:
         """
-        Find all the valid positions a knight can move to from the current position.
-
-        >>> solver = KnightTourSolver(4)
-        >>> solver.get_valid_moves((1, 3))
-        [(2, 1), (0, 1), (3, 2)]
+        Checks if a move is valid from the current position.
         """
         y, x = position
+        dy, dx = move
+        new_y, new_x = y + dy, x + dx
+        return 0 <= new_y < self.board_size and 0 <= new_x < self.board_size
+
+    def _get_valid_moves(self, position: tuple[int, int]) -> list[tuple[int, int]]:
+        """
+        Find all the valid positions a knight can move to from the current position.
+        """
         return [
-            (y + dy, x + dx)
+            (position[0] + dy, position[1] + dx)
             for dy, dx in self.MOVES
-            if 0 <= y + dy < self.board_size and 0 <= x + dx < self.board_size
+            if self._is_valid_move(position, (dy, dx))
         ]
 
-    def solve_knight_tour(self, position: tuple[int, int], move_number: int) -> bool:
+    def _solve_knight_tour(self, position: tuple[int, int], move_number: int) -> bool:
         """
         Helper function to solve the Knight's Tour problem recursively.
         """
         if move_number == self.board_size * self.board_size + 1:
+            # Base case: all cells visited
             return True
 
-        for next_position in self.get_valid_moves(position):
-            ny, nx = next_position
-            if self.board[ny][nx] == 0:
-                self.board[ny][nx] = move_number
-                if self.solve_knight_tour(next_position, move_number + 1):
+        for next_position in self._get_valid_moves(position):
+            # Move is valid and cell is not visited yet
+            new_y, new_x = next_position
+            if self.board[new_y][new_x] == 0:
+                self.board[new_y][new_x] = move_number
+                if self._solve_knight_tour(next_position, move_number + 1):
+                    # Recursive call for the next move
                     return True
-                self.board[ny][nx] = 0
+                # Backtrack if no solution found
+                self.board[new_y][new_x] = 0
 
         return False
 
@@ -75,7 +83,7 @@ def find_knight_tour(self) -> list[list[int]]:
         for i in range(self.board_size):
             for j in range(self.board_size):
                 self.board[i][j] = 1
-                if self.solve_knight_tour((i, j), 2):
+                if self._solve_knight_tour((i, j), 2):
                     return self.board
                 self.board[i][j] = 0
         error_message = (