Add first solving approach, need to fix return

Author: RgrMz

SudokuSolver/examples/ex2.csv

@@ -0,0 +1,10 @@
+a,b,c,d,e,f,g,h,i
+0,0,0,7,0,8,0,0,0
+0,0,7,0,4,0,0,5,0
+0,3,0,0,0,2,8,0,0
+3,0,4,0,8,0,0,0,2
+5,7,0,2,0,0,0,0,3
+0,2,0,0,7,3,0,6,5
+0,0,0,6,5,0,0,2,0
+8,0,0,0,3,0,6,0,9
+0,0,0,8,0,0,0,7,4

SudokuSolver/main.py

@@ -0,0 +1,11 @@
+from read_sudoku import import_sudoku
+from sudoku_solver import solve_sudoku
+
+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)
+
+if __name__ == '__main__':
+    main()

SudokuSolver/read_sudoku.py

@@ -20,7 +20,7 @@ def is_solvable(sudoku: Sudoku) -> bool:
 
     # Check there are at least 17 non 0 numbers for unique solution
 
-    if sudoku[sudoku.grid != 0].size < MINIMUM_NUMBERS_FOR_UNIQUE_SOLUTION:
+    if sudoku.grid[sudoku.grid != 0].size < MINIMUM_NUMBERS_FOR_UNIQUE_SOLUTION:
         return False
 
     # Check rows' legality
@@ -30,14 +30,14 @@ def is_solvable(sudoku: Sudoku) -> bool:
             return False
 
     # Check columns' legality
-    for column in np.nditer(sudoku, flags = ['external_loop'], order='C'):
+    for column in np.nditer(sudoku.grid, flags = ['external_loop'], order='C'):
         column = column[column != 0]
         if np.unique(column).size != column.size:
             return False
 
     # Check regions' legality
     for region_number in range(NUMBER_REGIONS):
-        region = getattr(sudoku, 'region'+(region_number+1))
+        region = getattr(sudoku, "{}{}".format('region',region_number+1))
         region = region[region != 0]
         if np.unique(region).size != region.size:
             return False

SudokuSolver/sudoku_solver.py

@@ -1,7 +1,35 @@
+import numpy as np
+import random
+from move import Move
 from sudoku import Sudoku
 
-LEGIT_NUMBERS = list(range(1,10))
+LEGIT_DIGITS = list(range(1,10))
 
 def solve_sudoku(sudoku: Sudoku) -> Sudoku:
 
-    return sudoku
+    '''
+        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]))
+
+    move = Move(0, first_naked_cell[0], first_naked_cell[1])
+
+    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)