def solve_the_sudoku():
self.is_in_play_mode = False
board = Sudoku(self.board)
solve_sudoku = multiprocessing.Process(
target=board.return_the_solution)
solve_sudoku.start()
solve_sudoku.join(4)
if solve_sudoku.is_alive():
solve_sudoku.terminate()
tk.messagebox.showinfo(
message='There is no solution for this sudoku',
title='Advice')
else:
self.board = board.return_the_solution()
update_the_board()
# Lock all the labels
for i, _ in enumerate(self.labels):
for l, _ in enumerate(self.labels):
self.labels[i][l].is_locked = True
clean_highlighted_labels()
tk.messagebox.showinfo(message='This is the solution!',
title='Done!')
# Leave the bord in blank if the user wants to play again
self.board = self.empty_sudoku_board
return_to_menu()
def tipp_bttn_func(self):
self.label.setText("")
su = Sudoku(self.translate_to_2d())
if not su.is_solved():
not_defined = su.get_not_defined()
solution = su.solve()
x, y = random.choice(not_defined)
self.elements[y][x].setText(str(solution[y][x]))
self.elements[y][x].setStyleSheet("background-color:lightgreen")
def test_solve_naked_singles(self, init_sudoku, init_sudoku_solution):
sudoku = Sudoku(init_sudoku)
sudoku.solve_naked_singles()
empty_set = set()
for i in range(9):
for j in range(9):
assert sudoku.cells[i][j].value == init_sudoku_solution[i][
j], f'({i}, {j})'
assert sudoku.cells[i][j].choices == empty_set
def validate_bttn_func(self):
self.label.setText("")
su = Sudoku(self.translate_to_2d())
if su.is_solved():
if su.validate():
self.label.setText("Correct :) - There may be other solutions")
return
if su.validate():
self.label.setText("So far so good, probably")
return
else:
self.label.setText("Wrong :(")
def test_set_value(self, init_sudoku):
sudoku = Sudoku(init_sudoku)
sudoku.set_value(0, 0, 4)
assert sudoku.unsolved_cells == 48
assert sudoku.cells[0][0].value == 4
assert sudoku.cells[0][0].choices == set()
assert sudoku.cells[0][1].choices == {5, 7, 8}
assert sudoku.cells[0][3].choices == {9}
assert sudoku.cells[3][0].choices == {3, 5}
assert sudoku.cells[8][0].choices == {6}
assert sudoku.cells[1][1].choices == {2, 6, 7, 8}
assert sudoku.cells[1][2].choices == {7}
def solve_bttn_func(self):
self.label.setText("")
su = Sudoku(self.translate_to_2d())
not_defined = su.get_not_defined()
su.solve()
for ye, (y, y_i) in enumerate(zip(su.sudoku, self.elements)):
for xe, (x, x_i) in enumerate(zip(y, y_i)):
if not x:
self.label.setText("There is no solution - Invalid sudoku")
return
x_i.setText(str(x))
if (xe, ye) in not_defined:
x_i.setStyleSheet("background-color:lightblue")
def test_solve_intersection_removal(self):
sudoku = Sudoku([[0, 1, 7, 9, 0, 3, 6, 0, 0],
[0, 0, 0, 0, 8, 0, 0, 0, 0],
[9, 0, 0, 0, 0, 0, 5, 0, 7],
[0, 7, 2, 0, 1, 0, 4, 3, 0],
[0, 0, 0, 4, 0, 2, 0, 7, 0],
[0, 6, 4, 3, 7, 0, 2, 5, 0],
[7, 0, 1, 0, 0, 0, 0, 6, 5],
[0, 0, 0, 0, 3, 0, 0, 0, 0],
[0, 0, 5, 6, 0, 1, 7, 2, 0]])
sudoku.solve_intersection_removal()
assert sudoku.cells[1][0].choices == {2, 4, 5, 6}
assert sudoku.cells[1][1].choices == {2, 4, 5}
assert sudoku.cells[1][2].choices == {6}
sudoku = Sudoku([[0, 1, 6, 0, 0, 7, 8, 0, 3],
[0, 9, 0, 8, 0, 0, 0, 0, 0],
[8, 7, 0, 0, 0, 1, 0, 6, 0],
[0, 4, 8, 0, 0, 0, 3, 0, 0],
[6, 5, 0, 0, 0, 9, 0, 8, 2],
[0, 3, 9, 0, 0, 0, 6, 5, 0],
[0, 6, 0, 9, 0, 0, 0, 2, 0],
[0, 8, 0, 0, 0, 2, 9, 3, 6],
[9, 2, 4, 6, 0, 0, 5, 1, 0]])
sudoku.solve_intersection_removal()
assert sudoku.cells[1][4].choices == {3, 5, 6}
assert sudoku.cells[2][3].choices == {3, 4, 5}
assert sudoku.cells[2][4].choices == {3, 4, 5, 9}
assert sudoku.cells[1][6].choices == {1, 2, 7}
assert sudoku.cells[2][6].choices == {2}
assert sudoku.cells[1][8].choices == {1, 5, 7}
assert sudoku.cells[2][8].choices == {5, 9}
def test_solve_hidden_singles(self):
sudoku = Sudoku([[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 2, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 6, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 8, 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, 2, 0, 0, 0]])
sudoku.solve_hidden_singles()
assert sudoku.cells[4][4].value == 2
def __init__(self, size, matrix):
self._size_x = size # window size
self._size_y = self._size_x
self._block_size = self._size_x / 9 # cell
self.sudoku_solver = Sudoku(matrix)
pg.init()
pg.display.set_caption("Sudoku Solver")
self._window = pg.display.set_mode((self._size_x, self._size_y),
RESIZABLE)
self._window.fill(WHITE)
self.prepare_board()
self.clicked = None
self.key = None
self.delete = False
self.simulate = False
def test_solve_hidden_pairs(self):
sudoku = Sudoku([[0, 6, 0, 3, 9, 0, 1, 0, 0],
[0, 0, 3, 1, 5, 0, 0, 9, 0],
[1, 9, 0, 4, 2, 6, 3, 0, 0],
[8, 3, 0, 5, 7, 9, 4, 1, 0],
[9, 0, 0, 0, 6, 1, 0, 0, 0],
[0, 5, 1, 0, 4, 3, 0, 0, 9],
[4, 1, 9, 6, 3, 5, 8, 2, 7],
[0, 2, 0, 9, 8, 4, 5, 0, 1],
[0, 8, 0, 7, 1, 2, 9, 4, 0]])
sudoku.solve_hidden_pairs()
assert sudoku.cells[4][7].choices == {3, 5}
assert sudoku.cells[4][8].choices == {3, 5}
def test_solve_naked_pairs(self):
sudoku = Sudoku([[4, 0, 0, 0, 0, 0, 9, 3, 8],
[0, 3, 2, 0, 9, 4, 1, 0, 0],
[0, 9, 5, 3, 0, 0, 2, 4, 0],
[3, 7, 0, 6, 0, 9, 0, 0, 4],
[5, 2, 9, 0, 0, 1, 6, 7, 3],
[6, 0, 4, 7, 0, 3, 0, 9, 0],
[9, 5, 7, 0, 0, 8, 3, 0, 0],
[0, 0, 3, 9, 0, 0, 4, 0, 0],
[2, 4, 0, 0, 3, 0, 7, 0, 9]])
assert sudoku.cells[0][1].choices == {1, 6}
assert sudoku.cells[0][2].choices == {1, 6}
assert sudoku.cells[0][3].choices == {1, 2, 5}
assert sudoku.cells[0][4].choices == {1, 2, 5, 6, 7}
assert sudoku.cells[0][5].choices == {2, 5, 6, 7}
assert sudoku.cells[1][0].choices == {7, 8}
assert sudoku.cells[2][0].choices == {1, 7, 8}
assert sudoku.cells[2][4].choices == {1, 6, 7, 8}
assert sudoku.cells[2][5].choices == {6, 7}
assert sudoku.cells[2][8].choices == {6, 7}
assert sudoku.cells[3][2].choices == {1, 8}
assert sudoku.cells[3][4].choices == {2, 5, 8}
assert sudoku.cells[5][4].choices == {2, 5, 8}
assert sudoku.cells[3][6].choices == {5, 8}
assert sudoku.cells[3][7].choices == {1, 2, 5, 8}
sudoku.solve_naked_pairs()
assert sudoku.cells[0][1].choices == {1, 6}
assert sudoku.cells[0][2].choices == {1, 6}
assert sudoku.cells[0][3].choices == {2, 5}
assert sudoku.cells[0][4].choices == {7}
assert sudoku.cells[0][5].choices == {2, 5, 7}
assert sudoku.cells[1][0].choices == {7}
assert sudoku.cells[2][0].choices == {8}
assert sudoku.cells[2][4].choices == {1, 8}
assert sudoku.cells[2][5].choices == {6, 7}
assert sudoku.cells[2][8].choices == {6, 7}
assert sudoku.cells[3][2].choices == {1, 8}
assert sudoku.cells[3][4].choices == {2, 5}
assert sudoku.cells[5][4].choices == {2, 5}
assert sudoku.cells[3][6].choices == {5, 8}
assert sudoku.cells[3][7].choices == {1, 2}
def test_init(self, init_sudoku, init_sudoku_choices):
sudoku = Sudoku(init_sudoku)
assert sudoku.unsolved_cells == 49
for i in range(9):
for j in range(9):
assert isinstance(sudoku.cells[i][j], Cell)
assert sudoku.cells[i][j].value == init_sudoku[i][j]
assert sudoku.cells[i][j].choices == init_sudoku_choices[i][
j], str(f'{i}, {j}')
def main() -> None:
"""Instantiate objects and launch tkinter GUI."""
sudoku = Sudoku()
root = tk.Tk()
MainApplication(sudoku, root)
root.title("Sudoku Solver")
root.geometry("409x290")
tk.mainloop()
def insert_number(number, variable, position):
variable.set(number)
if number.isdigit():
self.board[position[0]][position[1]] = int(number)
# If user press the backspace
else:
self.board[position[0]][position[1]] = ''
highlight_keys(self.board, position, self.labels, self.TEXT_COLOR)
if self.is_in_play_mode:
board = self.board
board = Sudoku(board)
if board.check_if_solved():
announce_win()
def run():
for method in methods:
stats.append([])
for j, level in enumerate(levels):
stats[method].append([])
sub_dir = benchmark_dir + '/' + level
puzzle_list = os.listdir(sub_dir)
puzzle_list = sorted([name for name in puzzle_list
if 'in' in name.lower()])
for puzzle in puzzle_list:
puzzle_dir = sub_dir + '/' + puzzle
with open(puzzle_dir) as f:
grid = parse_input(f)
game = Sudoku(grid, method)
solution, steps, runtime = game.solve()
stats[method][j].append((puzzle, steps, runtime))
assert solution != None
print(puzzle, methods_name[method],'Steps:', steps, 'time(s):',runtime)
print()
print('bt: backtracking')
print('cp1: one-candidate')
print('cp2: cp1+naked-pair+hidden-pair')
print('cp3: cp1+cp2+x-wing')
print('mrv: Minimum Remaining Values')
print()
print('Average backtracking steps and runtime:')
print('tuples are in the format of (steps, time in milliseconds)')
print('puzzle_level, bt, bt+cp1, bt+cp2, bt+cp3, bt+cp3+mrv')
for j, level in enumerate(levels):
stat = []
for method in methods:
time = 0
step = 0
count = len(stats[method][j])
for p in stats[method][j]:
time += p[2]
step += p[1]
stat.append('({}, {:.2f})'.format(step // count, time * 1000 / count))
print(level + ',' + ','.join(stat))
print(comment)
def get_sudoku_examples():
"""Читает из файла 50 головоломок судоку."""
examples = []
with open('p096_sudoku.txt', 'r') as f:
line = f.readline()
while line.startswith('Grid'):
matrix = [[int(ch) for ch in f.readline().strip()]
for i in range(9)]
sudoku = Sudoku(matrix)
examples.append(sudoku)
line = f.readline()
return examples
def test_solve_x_wing(self):
sudoku = Sudoku([[0, 0, 3, 8, 0, 0, 5, 1, 0],
[0, 0, 8, 7, 0, 0, 9, 3, 0],
[1, 0, 0, 3, 0, 5, 7, 2, 8],
[0, 0, 0, 2, 0, 0, 8, 4, 9],
[8, 0, 1, 9, 0, 6, 2, 5, 7],
[0, 0, 0, 5, 0, 0, 1, 6, 3],
[9, 6, 4, 1, 2, 7, 3, 8, 5],
[3, 8, 2, 6, 5, 9, 4, 7, 1],
[0, 1, 0, 4, 0, 0, 6, 9, 2]])
sudoku.solve_x_wing()
assert sudoku.cells[0][1].choices == {2, 7, 9}
assert sudoku.cells[1][1].choices == {2, 5}
assert sudoku.cells[0][4].choices == {6, 9}
assert sudoku.cells[1][4].choices == {1, 6}
assert sudoku.cells[5][1].choices == {2, 7, 9}
assert sudoku.cells[5][4].choices == {7, 8}
sudoku = Sudoku([[0, 0, 0, 0, 0, 0, 0, 9, 4],
[7, 6, 0, 9, 1, 0, 0, 5, 0],
[0, 9, 0, 0, 0, 2, 0, 8, 1],
[0, 7, 0, 0, 5, 0, 0, 1, 0],
[0, 0, 0, 7, 0, 9, 0, 0, 0],
[0, 8, 0, 0, 3, 1, 0, 6, 7],
[2, 4, 0, 1, 0, 0, 0, 7, 0],
[0, 1, 0, 0, 9, 0, 0, 4, 5],
[9, 0, 0, 0, 0, 0, 1, 0, 0]])
sudoku.solve_x_wing()
assert sudoku.cells[4][1].choices == {3, 5}
assert sudoku.cells[4][2].choices == {1, 3, 4, 5, 6}
assert sudoku.cells[4][6].choices == {3, 4, 5, 8}
assert sudoku.cells[4][8].choices == {3, 8}
assert sudoku.cells[8][3].choices == {3, 4, 5, 6, 8}
assert sudoku.cells[8][8].choices == {3, 6, 8}
class SudokuUI:
BOARD_SIZE = 9
def __init__(self, size, matrix):
self._size_x = size # window size
self._size_y = self._size_x
self._block_size = self._size_x / 9 # cell
self.sudoku_solver = Sudoku(matrix)
pg.init()
pg.display.set_caption("Sudoku Solver")
self._window = pg.display.set_mode((self._size_x, self._size_y),
RESIZABLE)
self._window.fill(WHITE)
self.prepare_board()
self.clicked = None
self.key = None
self.delete = False
self.simulate = False
def clear_window(self):
self._window.fill(WHITE)
def clear_cell(self, y, x):
cell_rect = pg.Rect(x * self._block_size + self._block_size * 0.1,
y * self._block_size + self._block_size * 0.1,
self._block_size * 0.8, self._block_size * 0.8)
self._window.fill(WHITE, cell_rect)
def draw(self, x, y, color=BLUE):
font = pg.font.Font('freesansbold.ttf', int(self._block_size * 0.6))
submatrix_rect = pg.Rect(x * (self._block_size * 3),
y * (self._block_size * 3),
self._block_size * 3, self._block_size * 3)
pg.draw.rect(self._window, BLACK, submatrix_rect,
int(self._block_size / 10))
cell_rect = pg.Rect(x * self._block_size, y * self._block_size,
self._block_size, self._block_size)
pg.draw.rect(self._window, (0, 0, 0), cell_rect, 1)
val = self.sudoku_solver.get_cell(x, y)
val = val if val != '.' else ''
#print('color:', color, 'x:', x, 'y:', y, 'val:', val)
text = font.render(val, True, color)
textRect = text.get_rect()
textRect.center = (self._block_size / 2 + (self._block_size * y),
self._block_size / 2 + (self._block_size * x))
self._window.blit(text, textRect)
pg.display.update()
def prepare_board(self):
for x in range(self.BOARD_SIZE):
for y in range(self.BOARD_SIZE):
self.draw(x, y)
pg.display.update()
def click(self, pos):
if pos[0] < self._size_x and pos[1] < self._size_y:
x = pos[0] // self._block_size
y = pos[1] // self._block_size
return (int(y), int(x))
def solve(self):
return self.sudoku_solver.solve()
def revert(self, matrix):
self.sudoku_solver.reset_board(matrix)
def make_backup(self):
return self.sudoku_solver.make_backup()
def place(self, x, y, num):
self.sudoku_solver.place_cell(x, y, num)
def remove(self, x, y):
self.sudoku_solver.remove_cell(x, y)
def play(self):
run = True
while run:
for event in pg.event.get():
if event.type == pg.QUIT:
run = False
if event.type == pg.MOUSEBUTTONDOWN:
pos = pg.mouse.get_pos()
self.clicked = self.click(pos)
else:
self.clicked = False
if event.type == pg.KEYDOWN:
keys = pg.key.get_pressed()
if keys[pg.K_1] or keys[pg.K_KP1]:
self.key = '1'
if keys[pg.K_2] or keys[pg.K_KP2]:
self.key = '2'
if keys[pg.K_3] or keys[pg.K_KP3]:
self.key = '3'
if keys[pg.K_4] or keys[pg.K_KP4]:
self.key = '4'
if keys[pg.K_5] or keys[pg.K_KP5]:
self.key = '5'
if keys[pg.K_6] or keys[pg.K_KP6]:
self.key = '6'
if keys[pg.K_7] or keys[pg.K_KP7]:
self.key = '7'
if keys[pg.K_8] or keys[pg.K_KP8]:
self.key = '8'
if keys[pg.K_9] or keys[pg.K_KP9]:
self.key = '9'
if keys[pg.K_SPACE]:
self.simulate = True
else:
self.simulate = False
if keys[pg.K_DELETE] or keys[pg.K_BACKSPACE] or keys[
pg.K_d]:
self.delete = True
else:
self.delete = False
if self.simulate:
print('\nTrying to solve....')
current_matrix = self.make_backup()
can_solve = self.solve()
#print('Can solve:', can_solve)
if not can_solve:
self.revert(current_matrix)
print(
'\nThe position cannot be solved. Remove elements from arbitrary cells and try again.'
)
else:
self.clear_window()
self.prepare_board()
pg.display.update()
run = False
self.simulate = False
pg.display.update()
if self.delete:
if self.clicked:
#print('val before removing:', self.sudoku_solver.get_cell(self.clicked[0],self.clicked[1]))
self.remove(self.clicked[0], self.clicked[1])
#print('val after removing:', self.sudoku_solver.get_cell(self.clicked[0],self.clicked[1]))
self.clear_cell(self.clicked[0], self.clicked[1])
self.draw(self.clicked[0], self.clicked[1])
self.delete = False
#[print(row) for row in self.sudoku_solver._matrix]
pg.display.update()
if self.key:
if self.clicked:
#print('self.clicked:', self.clicked, 'self.key:', self.key)
is_valid_placement = self.sudoku_solver.is_valid(
self.clicked[0], self.clicked[1], self.key)
self.clear_cell(self.clicked[0], self.clicked[1])
self.place(self.clicked[0], self.clicked[1], self.key)
self.draw(self.clicked[0], self.clicked[1])
pg.display.update()
if not is_valid_placement:
self.clear_cell(self.clicked[0], self.clicked[1])
self.draw(self.clicked[0], self.clicked[1], RED)
pg.display.update()
self.delete = True
print(
f"\nThe placement of {self.key} on ({self.clicked[0]},{self.clicked[1]}) is invalid. Please remove current element and try something else"
)
#[print(row) for row in self.sudoku_solver._matrix]
else:
current_matrix = self.make_backup()
can_solve = self.solve()
#print('Can solve:', can_solve)
self.revert(current_matrix)
if not can_solve:
self.clear_cell(self.clicked[0], self.clicked[1])
self.draw(self.clicked[0], self.clicked[1], RED)
pg.display.update()
self.delete = True
print(
'\nThe cell is valid, BUT the position CANNOT be solved from here. Please remove current element and try something else'
)
#[print(row) for row in self.sudoku_solver._matrix]
else:
if self.sudoku_solver.is_full():
print("\nWOW, you've solved it!")
run = False
else:
print(
'\nThe cell is valid AND you CAN solve from here on. Good job!'
)
self.clicked = False
self.key = None
pg.display.update()
from sudoku_solver import Sudoku
if __name__ == "__main__":
board = """EEE|EOO|OOO
OOO|EOO|EEE
EOO|EEO|OOE
--- --- ---
OOE|OEE|OOE
OEO|OEE|OEO
EEO|OOO|EEO
--- --- ---
OEE|OOE|OEO
EOE|OOO|EOE
OOO|EEE|EOO"""
constraints = [((1, 2), 11), ((1, 3), 21), ((1, 4), 17), ((2, 9), 7),
((3, 9), 9), ((4, 9), 22), ((9, 6), 9), ((9, 7), 22),
((9, 8), 9), ((6, 1), 18), ((7, 1), 13), ((8, 1), 15)]
sudoku = Sudoku(board)
for start, goal in constraints:
sudoku.add_little_killer_constraint(start, goal)
sudoku.solve()
import cv2
import img_sudoku as img
from sudoku_solver import Sudoku
import text_to_speech as tts
original = cv2.imread('screenshots/ss1.jpg', cv2.IMREAD_GRAYSCALE)
pre_processed = img.pre_process_image(original)
corners = img.find_corners(pre_processed)
cropped = original[corners[0][1]:corners[2][1], corners[0][0]:corners[2][0]]
final_image = img.get_final_image_from_cropped_image(cropped)
grid = img.extract_number(final_image)
#print(grid)
Sudoku().print_sudoku_from_list(grid)
yn = input('looks good? (y/n): ')
if yn == 'y':
solved = Sudoku().solve_sudoku(grid)
solved = [str(n) for n in solved]
joined = ' ... '.join(solved)
print(joined)
tts.speak_text(joined)
else:
print('Back to the drawing board ..')
def solve_sudoku(matrix):
sudoku_solver = Sudoku(matrix)
is_solved = sudoku_solver.solve("A", "0", time.time(), False)
return sudoku_solver.grid if is_solved else None
#!/usr/bin/python
# -*- coding: UTF-8 -*-
""" Solving test of the sudoku_solver program
It attempts to solve all the games placed in the "sudoku-example" directory
Pierre Haessig — January 2012
"""
from __future__ import print_function
from glob import glob
from sudoku_solver import Sudoku
sudoku_games = glob('./sudoku-examples/sudoku-*.txt')
sudoku_games.sort()
successes = 0
for game in sudoku_games:
S = Sudoku(game)
(is_solved, nb_iter) = S.solve_game()
if all([len(c.possibilities) == 9 for c in S.cells]):
print(' (this was an empty Sudoku)')
successes += 1 # count it as a success anyway
else:
successes += int(is_solved)
print('-' * 50)
print('\nTest ran without failure')
print('Number of successes : %d/%d' % (successes, len(sudoku_games)))
from sudoku_solver import Sudoku
example = Sudoku([[9, 0, 6, 0, 7, 0, 4, 0, 3],
[0, 0, 0, 4, 0, 0, 2, 0, 0],
[0, 7, 0, 0, 2, 3, 0, 1, 0],
[5, 0, 0, 0, 0, 0, 1, 0, 0],
[0, 4, 0, 2, 0, 8, 0, 6, 0],
[0, 0, 3, 0, 0, 0, 0, 0, 5],
[0, 3, 0, 7, 0, 0, 0, 5, 0],
[0, 0, 7, 0, 0, 5, 0, 0, 0],
[4, 0, 5, 0, 1, 0, 7, 0, 8]], only_one_solution=False)
solutions = example.solve()
"""
Solution 1: [9, 2, 6, 5, 7, 1, 4, 8, 3], [3, 5, 1, 4, 8, 6, 2, 7, 9], [8, 7, 4, 9, 2, 3, 5, 1, 6],
[5, 8, 2, 3, 6, 7, 1, 9, 4], [1, 4, 9, 2, 5, 8, 3, 6, 7], [7, 6, 3, 1, 9, 4, 8, 2, 5],
[2, 3, 8, 7, 4, 9, 6, 5, 1], [6, 1, 7, 8, 3, 5, 9, 4, 2], [4, 9, 5, 6, 1, 2, 7, 3, 8]
Solution 2: [9, 2, 6, 5, 7, 1, 4, 8, 3], [3, 5, 1, 4, 8, 6, 2, 7, 9], [8, 7, 4, 9, 2, 3, 5, 1, 6],
[5, 8, 2, 3, 6, 7, 1, 9, 4], [1, 4, 9, 2, 5, 8, 3, 6, 7], [7, 6, 3, 1, 4, 9, 8, 2, 5],
[2, 3, 8, 7, 9, 4, 6, 5, 1], [6, 1, 7, 8, 3, 5, 9, 4, 2], [4, 9, 5, 6, 1, 2, 7, 3, 8]
"""
def test_column(self, init_sudoku, idx, expected):
sudoku = Sudoku(init_sudoku)
assert [cell.value for cell in sudoku.column(idx)] == expected
def test_square(self, init_sudoku, idx, expected):
sudoku = Sudoku(init_sudoku)
assert [cell.value for cell in sudoku.square(idx)] == expected
from sudoku_solver import Sudoku
solved = 0
result = 0
with open('p096_sudoku.txt', 'r') as f:
line = f.readline()
while line.startswith('Grid'):
print(line.strip())
matrix = [[int(ch) for ch in f.readline().strip()] for i in range(9)]
sudoku = Sudoku(matrix)
sudoku.solve()
if sudoku.unsolved_cells == 0:
solved += 1
result += (sudoku.cells[0][0].value * 100 +
sudoku.cells[0][1].value * 10 +
sudoku.cells[0][2].value)
print(sudoku)
line = f.readline()
print(f'Решено {solved} судоку из 50')
print(f'Ответ: {result}')
a_cell_active = False
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.MOUSEBUTTONDOWN:
mouse_pressed_pos = event.pos
if mouse_pressed_pos[1] <= 450:
a_cell_active = True
if solve_button.mouse_is_over(mouse_pressed_pos):
grid = [list(map(int, row)) for row in grid]
puzzle = Sudoku(grid)
puzzle.solve()
solutions = puzzle.get_solutions()
grid = solutions[0] if len(solutions) > 0 else grid
grid = [list(map(str, row)) for row in grid]
if event.type == pygame.KEYDOWN:
if a_cell_active:
if event.unicode >= '0' and event.unicode <= '9':
grid[i][j] = grid[i][j][:-1]
grid[i][j] += event.unicode
if event.key == pygame.K_RETURN:
a_cell_active = False
win.fill(bg)
