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)))
