Fix sudoku solving and solution printing

Author: RgrMz

SudokuSolver/main.py

@@ -4,8 +4,7 @@
 def main() -> None:
 
     sudoku_to_be_solved = import_sudoku()
-    sudoku_solved = solve_sudoku(sudoku_to_be_solved)
-    print("The solution to the sudoku proposed is:\n", sudoku_solved.grid)
+    solve_sudoku(sudoku_to_be_solved, 0, 0)
 
 if __name__ == '__main__':
     main()

SudokuSolver/sudoku.py

@@ -20,11 +20,18 @@ def put_number(self, move: Move) -> None:
 
         self.grid[move.row, move.column] = move.number
 
-    def check_legal_state(self, previous_move: Move) -> bool:
+    def is_legal_state(self, new_move: Move) -> bool:
 
-        row_to_check = self.grid[previous_move.row, :].copy()
-        column_to_check = self.grid[:, previous_move.column].copy()
-        region_to_check = self.get_region_from_move(previous_move)
+        # Make the movement, take copies of the grid and remove the movement
+
+        self.put_number(new_move)
+
+        row_to_check = self.grid[new_move.row, :].copy()
+        column_to_check = self.grid[:, new_move.column].copy()
+        region_to_check = self.get_region_from_move(new_move).copy()
+
+        reset_move = Move(0, new_move.row, new_move.column)
+        self.put_number(reset_move)
 
         # Remove 0's from the areas to be checked
 

SudokuSolver/sudoku_solver.py

@@ -1,35 +1,41 @@
-import numpy as np
-import random
 from move import Move
 from sudoku import Sudoku
 
-LEGIT_DIGITS = list(range(1,10))
-
-def solve_sudoku(sudoku: Sudoku) -> Sudoku:
+LEGIT_DIGITS = list(range(1, 10))
+SUDOKU_DIMENSION = 9
 
+def solve_sudoku(sudoku: Sudoku, row: int, column: int) -> bool:
     '''
         Solve a given legal sudoku by appliying a
         backtracking strategy.
     '''
 
-    if np.count_nonzero(sudoku.grid) == 0:
-        return sudoku
-        
-    # Test a move for the first nakedcell encountered
-    naked_cells_indexes = np.where(sudoku.grid == 0)
-    first_naked_cell = (naked_cells_indexes[0][0], naked_cells_indexes[1][0])
-    #digits_in_row = sudoku.grid[first_naked_cell[0], :]
-    #digits_in_column = sudoku.grid[:, first_naked_cell[1]]
-    #digits_in_region = sudoku.get_region_from_move(Move(0, first_naked_cell[0], first_naked_cell[1]))
+    # Return True when the last cell is achieved to avoid further backtracking
+    
+    if (row == SUDOKU_DIMENSION - 1 and column == SUDOKU_DIMENSION - 1):
+        print("The solution to the Sudoku proposed is: \n", sudoku.grid)
+        return True
+
+    # If we're in the last column, move to the next row
+
+    if column == SUDOKU_DIMENSION:
+        row += 1
+        column = 0
+
+    if sudoku.grid[row, column] > 0:
+        return solve_sudoku(sudoku, row, column + 1)
 
-    move = Move(0, first_naked_cell[0], first_naked_cell[1])
+    move = Move(0, row, column)
 
     for digit in LEGIT_DIGITS:
         move.number = digit
-        sudoku.put_number(move)
-        if sudoku.check_legal_state(move):
-            print("Legal move")
-            print(sudoku.grid)
-            solve_sudoku(sudoku)
-            move.number = 0
-            sudoku.put_number(move)
+
+        if sudoku.is_legal_state(move):
+            sudoku.put_number(move)
+
+            if solve_sudoku(sudoku, row, column + 1):
+                return True
+
+        sudoku.grid[row, column] = 0
+
+    return False