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)