def fill_sudoku_th(): sudoku = [[] for _ in range(9)] for k in range(81): field = fields[k].get() if field.isdigit() and (0 < int(field) <= 9): sudoku[k//9].append(int(field)) elif not field: sudoku[k//9].append(0) else: lbl.config(text='Wrong format!',fg='red') time.sleep(1) lbl.config(text='Enter valid sudoku',fg='black') return solver = SudokuSolver(sudoku) solver.solve_sudoku() if not solver.sudoku_is_correct: lbl.config(text='Sudoku is incorrect!',fg='red') time.sleep(1) lbl.config(text='Enter valid sudoku',fg='black') solved_sudoku = solver.finished_sudoku try: for k in range(81): fields[k].delete(0,END) fields[k].insert(0,str(solved_sudoku[k//9][k%9])) except: pass
def generate(self): # init an empty game emptyGame = Sudoku() # solve it randomly solver = SudokuSolver(emptyGame, enableRandom=True) solution = solver.sudoku # choose the cells to cleanup randomly cellIndices = random.sample( range(solution.numberOfRows * solution.numberOfCols), self.maxEmptyCells) # init the generated game as solution generatedGame = copy.deepcopy(solution) # iteratively try pop the cells for cellIndex in cellIndices: # get the cell using index and backup value cell = generatedGame.getCell( cellIndex // generatedGame.numberOfCols, cellIndex % generatedGame.numberOfCols) valueToBackup = cell.val # replace the value with SudokuCellValue.EMPTY cell.val = SudokuCellValue.EMPTY # if the solution is not unique after SudokuCellValue.EMPTY is filled, just simply revert the action if not SudokuSolver(generatedGame).isSolutionUnique: cell.val = valueToBackup # return the game and solution return (generatedGame, solution)
class TestSudokuSolver(unittest.TestCase): def setUp(self): self._grid = SudokuGrid( "349287501000000700000509002200095007001000400800720005100402000008000000000000376" ) self._solver = SudokuSolver(self._grid) def test_00_is_valid(self): self.assertTrue(self._solver.is_valid()) def test_01_is_solved(self): self.assertFalse(self._solver.is_solved()) def test_02_solve_step(self): self._solver.solve_step() self.assertEqual(list(self._grid.get_row(0))[7], 6) self.assertEqual(list(self._grid.get_row(2))[6], 8) self.assertEqual(list(self._grid.get_row(6))[6:], [9, 5, 8]) self.assertEqual(list(self._grid.get_row(7))[8], 4) def test_03_solve(self): sol = self._solver.solve() for i, row in enumerate( ([3, 4, 9, 2, 8, 7, 5, 6, 1], [5, 8, 2, 6, 4, 1, 7, 9, 3], [6, 1, 7, 5, 3, 9, 8, 4, 2], [2, 3, 4, 1, 9, 5, 6, 8, 7], [7, 5, 1, 8, 6, 3, 4, 2, 9], [8, 9, 6, 7, 2, 4, 1, 3, 5], [1, 6, 3, 4, 7, 2, 9, 5, 8], [9, 7, 8, 3, 5, 6, 2, 1, 4])): self.assertEqual(list(sol.get_row(i)), row)
def main(cli_args): grid = SudokuGrid(cli_args.file) print("Grid input:\n{}\n".format(grid)) sudoku_solver = SudokuSolver(grid) solved_grid = sudoku_solver.solve() print("Solved grid:\n{}\n".format(solved_grid))
def solve(self): grid = self.input_grid() print(grid) solver = SudokuSolver(grid) solver.solve() print('', self.success_message, grid, sep='\n')
def solve_all(running_times): for l in range(1, 245): g = SudokuGrid.from_file("../sudoku_db.txt", l) start = time.monotonic() solver = SudokuSolver(g) solver.solve() running_times.append(1000 * (time.monotonic() - start)) print("\r[{: <40}] ({:.0%})".format('=' * int(40 * l / 244), l / 244), end='')
def test_solving(file_path, model_path): reader = ImageReader() cells = reader.extract_board_cells(file_path) classifier = Classifier(model_path) classifications = classifier.classify_cells(cells) classifications = [str(c) for c in classifications] grid = ''.join(classifications) solver = SudokuSolver() solver.solve(grid)
def generate_field(board): #generate fully solved field print("Generate Sudoku") solver = SudokuSolver(board) values = [1, 2, 3, 4, 5, 6, 7, 8, 9] random.shuffle(values) solver.solve_soduku(values=values) print("Full Board - Now removing numbers") #remove numbers one by one attempts = 5 # higher number = potential higher difficulty solver.counter = 1 while attempts > 0: #select random cell, that is not empty row = random.randint(0, 8) col = random.randint(0, 8) while board.field[row][col] == 0: row = random.randint(0, 8) col = random.randint(0, 8) value = board.field[row][col] #backup value board.field[row][col] = 0 copy_field = deepcopy(board.field) solver.counter = 0 solver.solve_soduku(generate=True, field=copy_field) if solver.counter != 1: board.field[row][col] = value attempts -= 1 board.starting_field = deepcopy(board.field) save_field(board.starting_field) return True
def test(num_fill: int): generator = SudokuGenerator() solver = SudokuSolver() # Generate a puzzle with solution puzzle, solution = generator.generate(num_fill) # Print puzzle print('Puzzle:') print_sudoku(puzzle) # Print solution print('Solution:') print_sudoku(solution) # Solve problem with progress shown print('Solving:') solution_solved = solver.solve(puzzle, show_progress=True) # Print final stage print_sudoku(solution_solved)
def main(): test_img_names = [ 'handwritten.jpg', # 0, unable to read all digits 'site_sudoku.png', # 1, misreads some digits 'sudoku_test_rotated_ccw.png', # 2, ok 'sudoku_test_clear.png', # 3, ok 'sudoku_test_rotated_cw.png', # 4, ok 'sudoku_test_clear_smaller.png', # 5, ok 'sudoku_sample.png' # 6, ok ] img = load_test_image(test_img_names[4]) sf = SudokuFinder(img, debug_mode=True ) puzzle, coords = sf.find_puzzle() ss = SudokuSolver(puzzle) solved = ss.solve(seconds_limit=4) if solved: completed_values = ss.get_completed_values() write_missing_values(img, coords, completed_values) img_show(img) else: print("Could not solve puzzle in under 4 seconds.")
def test_case01_easy(): b = Board([ [1, 0, 6, 0, 0, 2, 3, 0, 0], [0, 5, 0, 0, 0, 6, 0, 9, 1], [0, 0, 9, 5, 0, 1, 4, 6, 2], [0, 3, 7, 9, 0, 5, 0, 0, 0], [5, 8, 1, 0, 2, 7, 9, 0, 0], [0, 0, 0, 4, 0, 8, 1, 5, 7], [0, 0, 0, 2, 6, 0, 5, 4, 0], [0, 0, 4, 1, 5, 0, 6, 0, 9], [9, 0, 0, 8, 7, 4, 2, 1, 0], ]) assert repr(SudokuSolver.solve(b)) == repr([[1, 4, 6, 7, 9, 2, 3, 8, 5], [2, 5, 8, 3, 4, 6, 7, 9, 1], [3, 7, 9, 5, 8, 1, 4, 6, 2], [4, 3, 7, 9, 1, 5, 8, 2, 6], [5, 8, 1, 6, 2, 7, 9, 3, 4], [6, 9, 2, 4, 3, 8, 1, 5, 7], [7, 1, 3, 2, 6, 9, 5, 4, 8], [8, 2, 4, 1, 5, 3, 6, 7, 9], [9, 6, 5, 8, 7, 4, 2, 1, 3]]), "Wrong answer"
def test_case01_hard(): b = Board([ [4, 0, 9, 3, 7, 0, 0, 0, 0], [1, 0, 0, 4, 2, 0, 0, 0, 0], [0, 0, 0, 0, 0, 9, 0, 1, 0], [5, 0, 0, 0, 0, 6, 0, 7, 0], [0, 6, 2, 0, 0, 0, 5, 8, 0], [0, 1, 0, 2, 0, 0, 0, 0, 3], [0, 2, 0, 8, 0, 0, 0, 0, 0], [0, 0, 0, 0, 5, 2, 0, 0, 8], [0, 0, 0, 0, 9, 7, 6, 0, 5], ]) assert repr(SudokuSolver.solve(b)) == repr([[4, 8, 9, 3, 7, 1, 2, 5, 6], [1, 5, 6, 4, 2, 8, 9, 3, 7], [2, 7, 3, 5, 6, 9, 8, 1, 4], [5, 4, 8, 9, 3, 6, 1, 7, 2], [3, 6, 2, 7, 1, 4, 5, 8, 9], [9, 1, 7, 2, 8, 5, 4, 6, 3], [6, 2, 5, 8, 4, 3, 7, 9, 1], [7, 9, 1, 6, 5, 2, 3, 4, 8], [8, 3, 4, 1, 9, 7, 6, 2, 5]]), "Wrong answer"
def test_case01_empty(): b = Board([ [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], ]) assert repr(SudokuSolver.solve(b)) == repr([[1, 2, 3, 4, 5, 8, 9, 6, 7], [4, 5, 8, 6, 7, 9, 1, 2, 3], [9, 6, 7, 1, 2, 3, 8, 4, 5], [2, 1, 9, 8, 3, 4, 5, 7, 6], [3, 8, 4, 5, 6, 7, 2, 1, 9], [5, 7, 6, 9, 1, 2, 3, 8, 4], [8, 9, 1, 3, 4, 6, 7, 5, 2], [6, 3, 2, 7, 8, 5, 4, 9, 1], [7, 4, 5, 2, 9, 1, 6, 3, 8]]), "Wrong answer"
def solve(event=None): global board, solver solver = SudokuSolver(board) t = threading.Thread(target=solver_thread) t.daemon = True t.start() #animate backtracking while solveable == None: board.redraw() board.draw_field("SlateBlue3") board.platform.update() time.sleep(0.01) if solveable == True: board.draw_field("green3") else: board.draw_field("red") board.platform.update()
def test_solve_puzzle_diagonal_1(self): puzzle = Sudoku(diagonal_grid_1, game_type='standard+diagonal') solver = SudokuSolver() solver.solve(puzzle, display_solution=False) self.assertTrue(puzzle.is_solved())
def test_solve_puzzle_5(self): puzzle = Sudoku(grid_5) solver = SudokuSolver() solver.solve(puzzle, display_solution=False) self.assertTrue(puzzle.is_solved())
def setUp(self): self.sudokuSolver = SudokuSolver()
class TestSudokuSolver(unittest.TestCase): def setUp(self): self.sudokuSolver = SudokuSolver() def test_easy_puzzle(self): # Test valid case #1 input_case = [[5, 1, 7, 6, 0, 0, 0, 3, 4], [2, 8, 9, 0, 0, 4, 0, 0, 0], [3, 4, 6, 2, 0, 5, 0, 9, 0], [6, 0, 2, 0, 0, 0, 0, 1, 0], [0, 3, 8, 0, 0, 6, 0, 4, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 0, 0, 0, 0, 7, 8], [7, 0, 3, 4, 0, 0, 5, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]] output_case = [[5, 1, 7, 6, 9, 8, 2, 3, 4], [2, 8, 9, 1, 3, 4, 7, 5, 6], [3, 4, 6, 2, 7, 5, 8, 9, 1], [6, 7, 2, 8, 4, 9, 3, 1, 5], [1, 3, 8, 5, 2, 6, 9, 4, 7], [9, 5, 4, 7, 1, 3, 6, 8, 2], [4, 9, 5, 3, 6, 2, 1, 7, 8], [7, 2, 3, 4, 8, 1, 5, 6, 9], [8, 6, 1, 9, 5, 7, 4, 2, 3]] output_result = self.sudokuSolver.solveSudoku(input_case) self.assertEqual(output_result, output_case) def test_ver_difficult_puzzle(self): # Test taken from # http://www.7sudoku.com/view-puzzle?date=20190317 input_case = [[9, 0, 0, 0, 2, 0, 7, 0, 0], [0, 0, 0, 9, 0, 0, 1, 5, 0], [4, 0, 0, 0, 0, 0, 0, 2, 0], [0, 0, 0, 5, 0, 6, 0, 8, 0], [0, 7, 0, 0, 0, 0, 0, 4, 0], [0, 5, 0, 3, 0, 8, 0, 0, 0], [0, 1, 0, 0, 0, 0, 0, 0, 3], [0, 8, 2, 0, 0, 1, 0, 0, 0], [0, 0, 9, 0, 5, 0, 0, 0, 1]] output_case = [[9, 6, 1, 4, 2, 5, 7, 3, 8], [7, 2, 8, 9, 6, 3, 1, 5, 4], [4, 3, 5, 1, 8, 7, 6, 2, 9], [1, 9, 4, 5, 7, 6, 3, 8, 2], [8, 7, 3, 2, 1, 9, 5, 4, 6], [2, 5, 6, 3, 4, 8, 9, 1, 7], [5, 1, 7, 8, 9, 4, 2, 6, 3], [6, 8, 2, 7, 3, 1, 4, 9, 5], [3, 4, 9, 6, 5, 2, 8, 7, 1]] output_result = self.sudokuSolver.solveSudoku(input_case) self.assertEqual(output_result, output_case) def test_invalid_size(self): input_case = [[1, 1, 2], [2, 1, 3], [1, 3, 2]] output_result = self.sudokuSolver.solveSudoku(input_case) self.assertFalse(output_result) def test_invalid_type(self): input_case = 4 output_result = self.sudokuSolver.solveSudoku(input_case) self.assertFalse(output_result) def test_unsolvable_case(self): input_case = [[5, 5, 5, 6, 0, 0, 0, 3, 4], [5, 5, 5, 0, 0, 4, 0, 0, 0], [5, 5, 5, 2, 0, 5, 0, 9, 0], [6, 0, 2, 0, 0, 0, 0, 1, 0], [0, 3, 8, 0, 0, 6, 0, 4, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 9, 0, 0, 0, 0, 0, 7, 8], [7, 0, 3, 4, 0, 0, 5, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]] output_result = self.sudokuSolver.solveSudoku(input_case) self.assertFalse(output_result)
# plt.imshow(scaled_img) # plt.show() # print('Number: ') # num = int(input()) # df.loc[df.shape[0]] = (scaled_img, num) # df.to_pickle('new_squares.pickle') # print(df.loc[df.shape[0] - 1]) field = np.array(nums) field.shape = (9, 9) while (True): print(field) print('Correct? (Y)') answer = str(input()) if answer == 'Y': # solve(field) field = SudokuSolver.solve(field) break else: print('x = ') temp_x = int(input()) print('y = ') temp_y = int(input()) print('num = ') number = int(input()) field[temp_y][temp_x] = number if field is not None: print(field) else: print('It\'s not Sudoku')
def setUp(self): self._grid = SudokuGrid( "349287501000000700000509002200095007001000400800720005100402000008000000000000376" ) self._solver = SudokuSolver(self._grid)
pygame.draw.line(screen, BLACK, (x, startY), (x, endY), 3) else: pygame.draw.line(screen, BLACK, (x, startY), (x, endY), 1) counter += 1 counter = 0 for y in range(startY, endY + 1, deltaY): if counter % 3 == 0: pygame.draw.line(screen, BLACK, (startX, y), (endX, y), 3) else: pygame.draw.line(screen, BLACK, (startX, y), (endX, y), 1) counter += 1 # Display initial numbers sudoku = SudokuSolver() def display_puzzle(board): centerX = startX + int(deltaX / 2) - 5 centerY = startY + int(deltaY / 2) - 10 for i in range(board.rows): for j in range(board.columns): if board.puzzle[i, j] is not None: myNum = myFont.render(str(board.puzzle[i, j]), 1, BLACK) screen.blit(myNum, (centerX, centerY)) centerX += deltaX centerX = startX + int(deltaX / 2) centerY += deltaY
def solve(fields): solver = SudokuSolver(fields) next(solver.solve(), False)
from itertools import chain from sudoku import Sudoku from solver import SudokuSolver sudoku = Sudoku( chain.from_iterable( [ [9, None, None, None, None, None, 6, None, 8], [None, None, 7, None, None, None, None, None, None], [None, 1, None, 8, 6, 2, None, None, None], [None, None, None, None, 4, None, 5, None, 1], [4, None, None, None, 5, None, None, None, 6], [5, None, 9, None, 8, None, None, None, None], [None, None, None, 6, 1, 7, None, 9, None], [None, None, None, None, None, None, 4, None, None], [1, None, 8, None, None, None, None, None, 3], ] ), 3, ) solver = SudokuSolver(sudoku) if solver.solve(): print(solver.sudoku) else: print("Impossible sudoku")
def test_easy_puzzle(self): solver = SudokuSolver("puzzles/9x9_easy.csv") expected = self.loadSolution("puzzles/9x9_easy_solution.csv") actual = solver.toString(solver.solve()) self.assertEquals(expected, actual)
def test_complete_solver(self): s = SudokuSolver() # 5 3 0 0 7 0 0 0 0 # 6 0 0 1 9 5 0 0 0 # 0 9 8 0 0 0 0 6 0 # 8 0 0 0 6 0 0 0 3 # 4 0 0 8 0 3 0 0 1 # 7 0 0 0 2 0 0 0 6 # 0 6 0 0 0 0 2 8 0 # 0 0 0 4 1 9 0 0 5 # 0 0 0 0 8 0 0 7 9 s.add_filled_number(8, 4, 8) s.add_filled_number(8, 7, 7) s.add_filled_number(8, 8, 9) s.add_filled_number(7, 3, 4) s.add_filled_number(7, 4, 1) s.add_filled_number(7, 5, 9) s.add_filled_number(7, 8, 5) s.add_filled_number(6, 1, 6) s.add_filled_number(6, 6, 2) s.add_filled_number(6, 7, 8) s.add_filled_number(5, 0, 7) s.add_filled_number(5, 4, 2) s.add_filled_number(5, 8, 6) s.add_filled_number(4, 0, 4) s.add_filled_number(4, 3, 8) s.add_filled_number(4, 5, 3) s.add_filled_number(4, 8, 1) s.add_filled_number(3, 0, 8) s.add_filled_number(3, 4, 6) s.add_filled_number(3, 8, 3) s.add_filled_number(2, 1, 9) s.add_filled_number(2, 2, 8) s.add_filled_number(2, 7, 6) s.add_filled_number(1, 0, 6) s.add_filled_number(1, 3, 1) s.add_filled_number(1, 4, 9) s.add_filled_number(1, 5, 5) s.add_filled_number(0, 0, 5) s.add_filled_number(0, 1, 3) s.add_filled_number(0, 4, 7) grid = s.solve() if len(grid) == 0: print("not solvable") else: print(grid) solution = [[5, 3, 4, 6, 7, 8, 9, 1, 2], [6, 7, 2, 1, 9, 5, 3, 4, 8], [1, 9, 8, 3, 4, 2, 5, 6, 7], [8, 5, 9, 7, 6, 1, 4, 2, 3], [4, 2, 6, 8, 5, 3, 7, 9, 1], [7, 1, 3, 9, 2, 4, 8, 5, 6], [9, 6, 1, 5, 3, 7, 2, 8, 4], [2, 8, 7, 4, 1, 9, 6, 3, 5], [3, 4, 5, 2, 8, 6, 1, 7, 9]] self.assertEqual(grid, solution)
from board import Board from solver import SudokuSolver import time filename = "../resources/hardest-board.txt" solver = SudokuSolver(filename, 9) board = solver.board.getBoard().reshape(-1) cellsLeftToPlace = len(list(filter(lambda cell: cell.getValue()==0, board))) print("Board to solve: " + filename) print(solver.board.toString()) start = time.time() solved = solver.backtracking(solver.board, cellsLeftToPlace) end = time.time() if solved: print("Board is solved and verified.") else: print("The board is not solvable.") print("Elapsed time: " + str(end - start) + "s.") print(solver.board.toString())
def test_large_puzzle(self): solver = SudokuSolver("puzzles/25x25_hard.csv") expected = self.loadSolution("puzzles/25x25_hard_solution.csv") actual = solver.toString(solver.solve()) self.assertEquals(expected, actual)
def add_grid_to_solver(s: solver.SudokuSolver, grid): for r in enumerate(grid): for c in enumerate(r[1]): if c[1]: s.add_filled_number(r[0], c[0], c[1])
def solve(Sudoku): solver = SudokuSolver(Sudoku) return solver.solve()
from sudoku import SudokuTable from solver import SudokuSolver table = SudokuTable('some string representing a table') solver = SudokuSolver() solution = solver.solve_sudoku(table) if isinstance(solution, SudokuTable): for i in xrange(9): row = '' for j in xrange(9): row = row + str(solution.table[i,j]) + ' ' print row
def solve(self): sudoku_solver = SudokuSolver(self._puzzle) self._puzzle = sudoku_solver.retrieve_results() return self._puzzle
if __name__ == '__main__': field_data = [] step = 0 for i in range(9): row = [] for j in range(9): row.append(j + 1) row = row[step:] + row[:step] field_data.append(row) step += 3 if step >= 9: step -= 8 field = Field.init_from_data(field_data) field.get_cell(0, 0).value = None field.get_cell(0, 1).value = None field.get_cell(0, 2).value = None field.get_cell(2, 0).value = None field.get_cell(2, 5).value = None field.get_cell(0, 6).value = None field.get_cell(5, 0).value = None field.get_cell(6, 0).value = None field.print() from solver import SudokuSolver # print(SudokuSolver._get_possible_value_tier_1(field, field.get_cell(2, 0))) print(SudokuSolver._get_possible_value_tier_2(field, field.get_cell(2, 0)))