def test_safest_first_solver_with_hard_one(self): print("test_safest_first_solver_with_hard_one") grid = create_hard_sudoku() solver = SudokuSolver(grid) self.assertTrue( solver.safest_first_solver() ) self.assertTrue( solver.check() ) solver._debug()
def main(): initial_board_values = [ [0, 9, 6, 0, 4, 0, 0, 3, 0], [0, 5, 7, 8, 2, 0, 0, 0, 0], [1, 0, 0, 9, 0, 0, 5, 0, 0], [0, 0, 9, 0, 1, 0, 0, 0, 8], [5, 0, 0, 0, 0, 0, 0, 0, 2], [4, 0, 0, 0, 9, 0, 6, 0, 0], [0, 0, 4, 0, 0, 3, 0, 0, 1], [0, 0, 0, 0, 7, 9, 2, 6, 0], [0, 2, 0, 0, 5, 0, 9, 8, 0], ] board = Board(initial_board_values) sudoku_solver = SudokuSolver() sudoku_solver.prepare(board) start_time = time.time() sudoku_solver.run() elapsed_time = time.time() - start_time result = sudoku_solver.get_result() print('Puzzle solved?: {}'.format(result.success)) print('Elapsed time (s): {}'.format(elapsed_time)) if result.success: print('\nInitial board:\n') print(board) board.update_units_by_name(result.assignment.state) print('\nSolved board:\n') print(board)
def test_safest_first_solver(self): print("test_safest_first_solver") grid = create_real_world_grid() solver = SudokuSolver(grid) self.assertTrue( solver.safest_first_solver() ) self.assertTrue( solver.check()) solver._debug()
def test_getters(): board = [list("abcd"), list("efgh"), list("ijkl"), list("mnop")] sudoku = SudokuSolver(board=board) assert sudoku.get_row(0) == set(list("abcd")) assert sudoku.get_row(1) == set(list("efgh")) assert sudoku.get_row(2) == set(list("ijkl")) assert sudoku.get_row(3) == set(list("mnop")) assert sudoku.get_col(0) == set(list("aeim")) assert sudoku.get_col(1) == set(list("bfjn")) assert sudoku.get_col(2) == set(list("cgko")) assert sudoku.get_col(3) == set(list("dhlp")) assert sudoku.get_quadrant(0, 0) == set(list("abef")) assert sudoku.get_quadrant(0, 1) == set(list("abef")) assert sudoku.get_quadrant(1, 0) == set(list("abef")) assert sudoku.get_quadrant(1, 1) == set(list("abef")) assert sudoku.get_quadrant(0, 2) == set(list("cdgh")) assert sudoku.get_quadrant(0, 3) == set(list("cdgh")) assert sudoku.get_quadrant(1, 2) == set(list("cdgh")) assert sudoku.get_quadrant(1, 3) == set(list("cdgh")) assert sudoku.get_quadrant(2, 0) == set(list("ijmn")) assert sudoku.get_quadrant(2, 1) == set(list("ijmn")) assert sudoku.get_quadrant(3, 0) == set(list("ijmn")) assert sudoku.get_quadrant(3, 1) == set(list("ijmn")) assert sudoku.get_quadrant(2, 2) == set(list("klop")) assert sudoku.get_quadrant(2, 3) == set(list("klop")) assert sudoku.get_quadrant(3, 2) == set(list("klop")) assert sudoku.get_quadrant(3, 3) == set(list("klop"))
def test_multiple_solutions(): board = [ ["", "4", "", "1"], ["1", "", "4", ""], ["", "1", "", "4"], ["4", "", "1", ""], ] solutions = [ [ ["3", "4", "2", "1"], ["1", "2", "4", "3"], ["2", "1", "3", "4"], ["4", "3", "1", "2"], ], [ ["2", "4", "3", "1"], ["1", "3", "4", "2"], ["3", "1", "2", "4"], ["4", "2", "1", "3"], ], ] sudoku = SudokuSolver(board=board) sudoku_solutions = [_ for _ in sudoku.solve_all()] assert len(solutions) == 2 assert [s.board for s in sudoku_solutions] == solutions assert sudoku.solve().board == solutions[0]
def test_solver(): board = [ ["9", "", "", "", "", "8", "", "7", ""], ["5", "", "", "6", "7", "9", "2", "3", ""], ["1", "", "", "", "", "5", "9", "6", ""], ["8", "5", "", "7", "", "2", "6", "", ""], ["", "", "9", "8", "", "", "7", "", "2"], ["3", "7", "", "1", "", "", "", "", ""], ["", "", "4", "", "3", "", "5", "8", "6"], ["", "8", "3", "", "6", "", "", "", "4"], ["", "1", "5", "", "8", "", "", "", ""], ] solution = [ ["9", "2", "6", "3", "1", "8", "4", "7", "5"], ["5", "4", "8", "6", "7", "9", "2", "3", "1"], ["1", "3", "7", "4", "2", "5", "9", "6", "8"], ["8", "5", "1", "7", "9", "2", "6", "4", "3"], ["4", "6", "9", "8", "5", "3", "7", "1", "2"], ["3", "7", "2", "1", "4", "6", "8", "5", "9"], ["7", "9", "4", "2", "3", "1", "5", "8", "6"], ["2", "8", "3", "5", "6", "7", "1", "9", "4"], ["6", "1", "5", "9", "8", "4", "3", "2", "7"], ] sudoku = SudokuSolver(board=board) solutions = [_ for _ in sudoku.solve_all()] assert len(solutions) == 1 assert solutions[0].board == solution assert sudoku.solve().board == solution
def __init__(self): super().__init__() self.setWindowTitle("Sudoku Solver") self.widget_cells = [] self.window = QWidget(self) self._set_to_initial_layout() self.solver = SudokuSolver()
def test_all_positions_and_numbers_are_possible_on_zero_grid(self): grid = create_zero_grid() solver = SudokuSolver(grid) for number in range(1, 10): for col in range(9): for row in range(9): self.assertTrue(solver._is_possible(col,row,number))
def __init__(self): pygame.init() self.sudoku_rules = SudokuSolver() self.size = FULLSIZE self.screen = pygame.display.set_mode(self.size) pygame.display.set_caption("SUDOKU") self.screen.fill(WHITE) self.draw_grid()
def __init__(self, tile, digit, sudoku_board, children=None): self.solver = SudokuSolver() self.solver.sudoku_board = copy.deepcopy(sudoku_board) self.tile = tile self.digit = digit self.children = [] if children is not None: for child in children: self.add_child(child)
def test_find_safest_position_to_solve(self): grid = create_solved_grid() solution = grid[8][8] grid[8][8] = 0 solver = SudokuSolver(grid) self.assertEqual( solver.find_safest_position_to_solve(), ( (8, 8),[solution]) )
def test_solve_missing_one_number(self): grid = create_solved_grid() grid[0][0] = 0 solver = SudokuSolver(grid) self.assertTrue( solver.brut_force() ) self.assertEqual(solver._grid , create_solved_grid() )
def test_cannot_insert_number_if_it_is_already_on_same_column(self): grid = create_zero_grid() col = 3 number = 8 grid[col][2] = number solver = SudokuSolver(grid) self.assertFalse(solver._is_possible(col,4,number)) # ok for neighbor col self.assertTrue(solver._is_possible(col + 1, 4 ,number))
def test_cannot_insert_number_if_it_is_already_on_same_row(self): grid = create_zero_grid() row = 3 number = 8 grid[2][row] = number solver = SudokuSolver(grid) self.assertFalse(solver._is_possible(4,row,number)) # ok for neighbor row self.assertTrue(solver._is_possible(4,row + 1,number))
def _erase(self, board: Board) -> Board: while True: i, j = self._get_next_coords() board_c = deepcopy(board) board_c[i][j] = "" sudoku = SudokuSolver(board=board_c) if len([_ for _ in sudoku.solve_all()]) > 1: return board board = board_c
def test_cannot_insert_number_if_it_is_already_on_same_block(self): grid = create_zero_grid() number = 8 grid[1][1] = number grid[4][4] = number grid[7][7] = number solver = SudokuSolver(grid) self.assertFalse(solver._is_possible(2,2,number)) self.assertFalse(solver._is_possible(5,5,number)) self.assertFalse(solver._is_possible(8,8,number))
def test_incorrect_board(): board = [ ["1", "1", "1", "1"], ["", "", "", "4"], ["4", "", "3", "1"], ["3", "2", "4", ""], ] sudoku = SudokuSolver(board=board) solution = [_ for _ in sudoku.solve_all()] assert len(solution) == 0 assert sudoku.solve() is None
def main(): board = SudokuBoard() board.add_element(0, 3, 3) board.add_element(0, 4, 4) board.add_element(0, 5, 6) board.add_element(0, 7, 5) board.add_element(0, 8, 9) ########### # board.add_element(0, 0, 5) # board.add_element(0, 1, 3) # board.add_element(0, 4, 7) # board.add_element(1, 0, 6) # board.add_element(1, 3, 1) # board.add_element(1, 4, 9) # board.add_element(1, 5, 5) # board.add_element(2, 1, 9) # board.add_element(2, 2, 8) # board.add_element(2, 7, 6) # board.add_element(3, 0, 8) # board.add_element(3, 4, 6) # board.add_element(3, 8, 3) # board.add_element(4, 0, 4) # board.add_element(4, 3, 8) # board.add_element(4, 5, 3) # board.add_element(4, 8, 1) # board.add_element(5, 0, 7) # board.add_element(5, 4, 2) # board.add_element(5, 8, 6) # board.add_element(6, 1, 6) # board.add_element(6, 6, 2) # board.add_element(6, 7, 8) # board.add_element(7, 3, 4) # board.add_element(7, 4, 1) # board.add_element(7, 5, 9) # board.add_element(7, 8, 5) # board.add_element(8, 4, 8) # board.add_element(8, 7, 7) # board.add_element(8, 8, 9) # board.build_board() solver = SudokuSolver(board) if solver.board.is_valid_full(): print("Board before solving: \n") print(board, "\n") if solver.backtracking(0, 0): print("Sudoku has been solved \n") print(board) if solver.board.is_valid_full(): print("Solution Exists!!") else: print("Board entered is not valid. Please enter a valid board.")
def main(): sudoku = SudokuSolver() sudoku.check_valid_solutions(sudoku.sudoku_board) sudoku.write_definite_solutions_loop() sudoku.tree_preprocessing() ### SOLVING SUDOKU USING TREE tree = SudokuTree((-1, -1), 0, sudoku.sudoku_board) recursion(sudoku, tree) print "bla"
def solve_puzzle(): cells = [[0 for _ in range(9)] for _ in range(9)] for i in range(9): for j in range(9): if request.args[str(i) + str(j)]: cells[i][j] = int(request.args[str(i) + str(j)]) solver = SudokuSolver(cells) result, grid, path = solver.solve() return render_template('index.html', solution=True, result=result, content=path)
def setUp(self): self.board = [[0, 0, 0, 2, 6, 0, 7, 0, 1], [6, 8, 0, 0, 7, 0, 0, 9, 0], [1, 9, 0, 0, 0, 4, 5, 0, 0], [8, 2, 0, 1, 0, 0, 0, 4, 0], [3, 0, 4, 6, 0, 2, 9, 0, 0], [0, 5, 0, 0, 0, 3, 0, 2, 8], [0, 0, 9, 3, 0, 0, 0, 7, 4], [0, 4, 0, 0, 5, 0, 0, 3, 6], [7, 0, 3, 0, 1, 8, 0, 0, 0]] self.solver = SudokuSolver(self.board) self.solver.solve() self.result = [i for i in range(1, 10)]
def test_simple_solver(): board = [ ["1", "", "2", "3"], ["2", "", "1", "4"], ["4", "", "3", "1"], ["3", "", "4", ""], ] solution = [list("1423"), list("2314"), list("4231"), list("3142")] sudoku = SudokuSolver(board=board) solutions = [_ for _ in sudoku.solve_all()] assert len(solutions) == 1 assert solutions[0].board == solution assert sudoku.solve().board == solution
def test_solve_real_word_sudoku(self): grid = create_real_world_grid() solver = SudokuSolver(grid) import time start = time.monotonic() self.assertTrue( solver.brut_force() ) end = time.monotonic() print ("elapsed = {} s".format(end - start)) self.assertTrue( solver.check()) solver._debug()
def recursion(sudoku, tree, solved=False, solved_sudoku_board=None): if solved: return min_possibility = sudoku.find_min_possibilities() for idx in xrange(0, min_possibility[1]): #finding indexes of the board with minimal #number of possible solutions x, y = min_possibility[0] try: new_sudoku = SudokuSolver() new_sudoku.sudoku_board = copy.deepcopy(sudoku.sudoku_board) new_sudoku.write_definite_solutions_loop() new_sudoku.tree_preprocessing() #new_sudoku.plot_sudoku(new_sudoku.sudoku_board) new_sudoku.check_valid_solutions(new_sudoku.sudoku_board) digit = sudoku.mark_up_board[x][y][idx] new_sudoku.sudoku_board[x][y] = digit new_sudoku.mark_up_board[x][y] = digit new_sudoku.write_definite_solutions_loop() new_sudoku.tree_preprocessing() if new_sudoku.is_solved(new_sudoku.sudoku_board): if new_sudoku.check_valid_solutions(new_sudoku.sudoku_board): new_sudoku.plot_sudoku(new_sudoku.sudoku_board) solved = True #new_sudoku.plot_sudoku(new_sudoku.mark_up_board) new_sudoku.check_valid_solutions(new_sudoku.sudoku_board) #new_sudoku.plot_sudoku(new_sudoku.mark_up_board) new_child = SudokuTree(tile=(x, y), digit=digit, sudoku_board=new_sudoku.sudoku_board) tree.add_child(new_child) recursion(new_sudoku, new_child, solved) except ValueError: #this will happen if new_sudoku.sudoku_board #has some invalid solutions written if idx == min_possibility[1] - 1: return continue
def test_non_unique_solver(): # just test that this completes for a non unique board board = [ ["1", "", "", "", "", "", "", "", ""], ["", "2", "", "", "", "", "", "", ""], ["", "", "3", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", ""], ] sudoku = SudokuSolver(board=board) solution = sudoku.solve() assert all(r != "" for row in solution.board for r in row)
def generate_sudoku(): sudoku_solver = SudokuSolver() array = [[0 for i in range(9)] for j in range(9)] rand_entry = randint(1, 9) rand_row, rand_col = (randint(0, 8), randint(0, 8)) array[rand_row][rand_col] = rand_entry sudoku_solver.solve(array) values_to_remove = sample([(j, k) for j in range(0, 9) for k in range(0, 9)], 48) for el in values_to_remove: array[el[0]][el[1]] = 0 solvable_array = deepcopy(array) if not sudoku_solver.solve(solvable_array): break return array
def main(): GRID_VALUES = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..' GRID_VALUES_HARD = '4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......' ROWS = 'ABCDEFGHI' COLUMNS = '123456789' BOXES = cross(ROWS, COLUMNS) ROW_UNITS = [cross(r, COLUMNS) for r in ROWS] COLUMN_UNITS = [cross(ROWS, c) for c in COLUMNS] SQUARE_UNITS = [ cross(rs, cs) for rs in (ROWS[:3], ROWS[3:6], ROWS[6:]) for cs in (COLUMNS[:3], COLUMNS[3:6], COLUMNS[6:]) ] UNIT_LIST = ROW_UNITS + COLUMN_UNITS + SQUARE_UNITS solver = SudokuSolver(BOXES, UNIT_LIST) board_normal = solver.grid_values(GRID_VALUES) board_hard = solver.grid_values(GRID_VALUES_HARD) print("-- Normal: Unsolved --") print("##############################") solver.display(solver.grid_values(GRID_VALUES), ROWS, COLUMNS) # Setting all posibilities on empty spaces all_choises_board = solver.grid_all_posibilities(GRID_VALUES) # Constraints propagation https://youtu.be/aSYDBcbvC5Y print("-- Normal: Solved --") print("##############################") solver.display(solver.reduce_puzzle(all_choises_board), ROWS, COLUMNS) all_choises_board_hard = solver.grid_all_posibilities(GRID_VALUES_HARD) # Hard Sudoku print("-- Hard: Unsolved --") print("##############################") solver.display(solver.grid_values(GRID_VALUES_HARD), ROWS, COLUMNS) # Reduce does not work anymore with eleminate and only choise technique print("-- Hard: Unsolved but reduced --") print("##############################") solver.display(solver.reduce_puzzle(all_choises_board_hard), ROWS, COLUMNS) # Hard using DFS print("-- Hard: DFS --") print("##############################") solver.display(solver.search(all_choises_board_hard), ROWS, COLUMNS)
def solve_puzzle(puzzle_strings): puzzle_id = puzzle_strings[0] solve_set = set() puzzle = Puzzle(puzzle_strings[1][0], solve_set) solution = Puzzle(puzzle_strings[1][1]) solver = SudokuSolver(puzzle, solve_set) solver.solve() if solver.puzzle == solution: print("Puzzle", puzzle_id, "Complete!") return 1 else: print("Bad Solution for", puzzle_id) return 0
def test_safest_first_solver_with_other_hard_one(self): print("test_safest_first_solver_with__other_hard_one") grid = [ [1,0,0, 0,0,0, 0,0,0], [3,8,0, 0,0,1, 0,0,0], [0,7,0, 0,0,3, 5,0,0], [8,0,0, 0,3,5, 7,2,0], [0,0,3, 0,7,0, 4,0,0], [0,9,2, 8,4,0, 0,0,3], [0,0,8, 2,0,0, 0,4,0], [0,0,0, 4,0,0, 0,6,7], [0,0,0, 0,0,0, 0,0,1] ] solver = SudokuSolver(grid) self.assertTrue( solver.safest_first_solver() ) self.assertTrue( solver.check()) solver._debug()
class SolverConstants: table = [ [0, 0, 0, 0, 0, 3, 0, 0, 6], [0, 0, 3, 5, 0, 0, 0, 8, 0], [1, 0, 0, 6, 4, 0, 0, 7, 3], [5, 0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 4, 8, 7, 0, 0, 0], [0, 8, 0, 0, 0, 0, 0, 0, 9], [4, 3, 0, 0, 2, 5, 0, 0, 7], [0, 5, 0, 0, 0, 6, 2, 0, 0], [7, 0, 0, 1, 0, 0, 0, 0, 0], ] easy_sudoku = [[0, 0, 0, 0, 5, 6, 0, 0, 2], [6, 0, 9, 7, 0, 2, 0, 0, 0], [0, 2, 7, 0, 0, 0, 0, 9, 0], [0, 6, 0, 0, 0, 9, 0, 0, 8], [5, 0, 0, 0, 0, 0, 3, 0, 4], [0, 1, 0, 0, 0, 7, 0, 0, 9], [0, 8, 6, 0, 0, 0, 0, 3, 0], [9, 0, 3, 2, 0, 1, 0, 0, 0], [0, 0, 0, 0, 9, 3, 0, 0, 6]] solver = SudokuSolver(table)