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)
