ref: update KnightTour implementation

- The `MOVES` list is declared as a class attribute since it does not change and is shared among all instances.
- The `board_size` is passed to the constructor, and `board` is initialized as an instance attribute.
- The `get_valid_moves` method now uses instance variables instead of relying on class variables.
- `solve_knight_tour` and `find_knight_tour` methods now directly access `self.board_size` and `self.board`.

Author: sozelfist

backtracking/knight_tour.py

@@ -1,92 +1,86 @@
 from __future__ import annotations
 
+from typing import ClassVar
 
-class KnightTour:
+
+class KnightTourSolver:
     """
-    Represents a Knight's Tour problem solver.
+    Represents a solver for the Knight's Tour problem.
     """
 
-    @staticmethod
-    def get_valid_moves(position: tuple[int, int], n: int) -> list[tuple[int, int]]:
+    MOVES: ClassVar[list[tuple[int, int]]] = [
+        (1, 2),
+        (-1, 2),
+        (1, -2),
+        (-1, -2),
+        (2, 1),
+        (-2, 1),
+        (2, -1),
+        (-2, -1),
+    ]
+
+    def __init__(self, board_size: int):
+        """
+        Initializes the KnightTourSolver with the specified board size.
+        """
+        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]]:
         """
         Find all the valid positions a knight can move to from the current position.
 
-        >>> KnightTour.get_valid_moves((1, 3), 4)
+        >>> solver = KnightTourSolver(4)
+        >>> solver.get_valid_moves((1, 3))
         [(2, 1), (0, 1), (3, 2)]
         """
         y, x = position
-        moves = [
-            (y + 1, x + 2),
-            (y - 1, x + 2),
-            (y + 1, x - 2),
-            (y - 1, x - 2),
-            (y + 2, x + 1),
-            (y + 2, x - 1),
-            (y - 2, x + 1),
-            (y - 2, x - 1),
+        return [
+            (y + dy, x + dx)
+            for dy, dx in self.MOVES
+            if 0 <= y + dy < self.board_size and 0 <= x + dx < self.board_size
         ]
-        valid_moves = [(y, x) for y, x in moves if 0 <= y < n and 0 <= x < n]
-        return valid_moves
 
-    @staticmethod
-    def is_board_complete(board: list[list[int]]) -> bool:
+    def solve_knight_tour(self, position: tuple[int, int], move_number: int) -> bool:
         """
-        Check if the board (matrix) has been completely filled with non-zero values.
-
-        >>> KnightTour.is_board_complete([[1]])
-        True
-        >>> KnightTour.is_board_complete([[1, 2], [3, 0]])
-        False
+        Helper function to solve the Knight's Tour problem recursively.
         """
-        return not any(elem == 0 for row in board for elem in row)
-
-    @staticmethod
-    def solve_knight_tour(
-        board: list[list[int]], pos: tuple[int, int], curr: int
-    ) -> bool:
-        """
-        Helper function to solve knight tour problem.
-        """
-
-        if KnightTour.is_board_complete(board):
+        if move_number == self.board_size * self.board_size + 1:
             return True
 
-        n = len(board)
-        for move in KnightTour.get_valid_moves(pos, n):
-            y, x = move
-            if board[y][x] == 0:
-                board[y][x] = curr + 1
-                if KnightTour.solve_knight_tour(board, move, curr + 1):
+        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):
                     return True
-                board[y][x] = 0
+                self.board[ny][nx] = 0
 
         return False
 
-    @staticmethod
-    def find_knight_tour(n: int) -> list[list[int]]:
+    def find_knight_tour(self) -> list[list[int]]:
         """
-        Find the solution for the knight tour problem for a board of size n. Raises
-        ValueError if the tour cannot be performed for the given size.
+        Find a solution for the Knight's Tour problem for the initialized board size.
+        Raises ValueError if the tour cannot be performed for the given size.
 
-        >>> KnightTour.find_knight_tour(1)
+        >>> solver = KnightTourSolver(1)
+        >>> solver.find_knight_tour()
         [[1]]
-        >>> KnightTour.find_knight_tour(2)
+        >>> solver = KnightTourSolver(2)
+        >>> solver.find_knight_tour()
         Traceback (most recent call last):
             ...
         ValueError: Knight's tour cannot be performed on a board of size 2
         """
-        if n < 1:
-            raise ValueError("Board size must be at least 1")
-
-        board = [[0 for _ in range(n)] for _ in range(n)]
-
-        for i in range(n):
-            for j in range(n):
-                board[i][j] = 1
-                if KnightTour.solve_knight_tour(board, (i, j), 1):
-                    return board
-                board[i][j] = 0
-        error_message = f"Knight's tour cannot be performed on a board of size {n}"
+        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):
+                    return self.board
+                self.board[i][j] = 0
+        error_message = (
+            f"Knight's tour cannot be performed on a board of size {self.board_size}"
+        )
         raise ValueError(error_message)