ref: refactor KnightTour implementation

Author: sozelfist

backtracking/knight_tour.py

@@ -1,98 +1,93 @@
-# Knight Tour Intro: https://www.youtube.com/watch?v=ab_dY3dZFHM
-
 from __future__ import annotations
 
 
-def get_valid_pos(position: tuple[int, int], n: int) -> list[tuple[int, int]]:
-    """
-    Find all the valid positions a knight can move to from the current position.
-
-    >>> get_valid_pos((1, 3), 4)
-    [(2, 1), (0, 1), (3, 2)]
-    """
-
-    y, x = position
-    positions = [
-        (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),
-    ]
-    permissible_positions = []
-
-    for position in positions:
-        y_test, x_test = position
-        if 0 <= y_test < n and 0 <= x_test < n:
-            permissible_positions.append(position)
-
-    return permissible_positions
-
-
-def is_complete(board: list[list[int]]) -> bool:
+class KnightTour:
     """
-    Check if the board (matrix) has been completely filled with non-zero values.
-
-    >>> is_complete([[1]])
-    True
-
-    >>> is_complete([[1, 2], [3, 0]])
-    False
+    Represents a Knight's Tour problem solver.
     """
 
-    return not any(elem == 0 for row in board for elem in row)
+    @staticmethod
+    def get_valid_moves(position: tuple[int, int], n: int) -> list[tuple[int, int]]:
+        """
+        Find all the valid positions a knight can move to from the current position.
 
-
-def open_knight_tour_helper(
-    board: list[list[int]], pos: tuple[int, int], curr: int
-) -> bool:
-    """
-    Helper function to solve knight tour problem.
-    """
-
-    if is_complete(board):
-        return True
-
-    for position in get_valid_pos(pos, len(board)):
+        >>> KnightTour.get_valid_moves((1, 3), 4)
+        [(2, 1), (0, 1), (3, 2)]
+        """
         y, x = position
-
-        if board[y][x] == 0:
-            board[y][x] = curr + 1
-            if open_knight_tour_helper(board, position, curr + 1):
-                return True
-            board[y][x] = 0
-
-    return False
-
-
-def open_knight_tour(n: int) -> 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.
-
-    >>> open_knight_tour(1)
-    [[1]]
-
-    >>> open_knight_tour(2)
-    Traceback (most recent call last):
-        ...
-    ValueError: Open Knight Tour cannot be performed on a board of size 2
-    """
-
-    board = [[0 for i in range(n)] for j in range(n)]
-
-    for i in range(n):
-        for j in range(n):
-            board[i][j] = 1
-            if open_knight_tour_helper(board, (i, j), 1):
-                return board
-            board[i][j] = 0
-
-    msg = f"Open Knight Tour cannot be performed on a board of size {n}"
-    raise ValueError(msg)
+        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),
+        ]
+        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:
+        """
+        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
+        """
+        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):
+            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):
+                    return True
+                board[y][x] = 0
+
+        return False
+
+    @staticmethod
+    def find_knight_tour(n: int) -> 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.
+
+        >>> KnightTour.find_knight_tour(1)
+        [[1]]
+        >>> KnightTour.find_knight_tour(2)
+        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}"
+        raise ValueError(error_message)
 
 
 if __name__ == "__main__":