def test_one_check():
s3 = sudoku_solver.Sudoku(
"4r36015k8de94kjr2o8500000cfghnjiaw4lk70i0fg0svb5f7x102erv2jh67909ld5jh0bd3hg4uy8k"
)
s3.create_possibility()
sudoku_ad = sudoku_solver.Sudoku.alldifferent_rcs(s3.data)
sudoku_ac = sudoku_solver.Sudoku.one_check(sudoku_ad)
assert sudoku_ac == [[4, 2, 3, 6, [2, 9], 1, 5, 9, 8],
[[1, 6, 7], [1, 6], 9, 4, [3, 8], [3, 5, 7, 8],
[3, 7], 2, [1, 3, 6, 7]],
[
8, 5, [1, 2, 6, 7], [3, 7, 9], [2, 3, 9],
[2, 3, 7, 9], [3, 4, 7, 9], [1, 3, 6, 9],
[1, 3, 4, 6, 7]
],
[[1, 2, 3, 6, 9], [1, 2, 6, 8], [1, 2, 6, 8],
[1, 3, 5, 8, 9], [1, 2, 3, 6, 8, 9],
[2, 3, 5, 6, 8, 9], [3, 7, 8, 9], 4, [3, 5, 6, 7]],
[[1, 2, 3, 6, 9], 7, [1, 2, 4, 6, 8], [1, 3, 5, 8, 9],
[1, 2, 3, 6, 8, 9], [2, 3, 4, 5, 6, 8, 9], [3, 8, 9],
[3, 5, 6, 9], [3, 5, 6]],
[[3, 6, 9], [4, 6, 8], 5, [3, 8, 9], 7,
[3, 4, 6, 8, 9], 1, [3, 6, 9], 2],
[[1, 5], [1, 4, 8], [1, 4, 8], 2, [1, 3, 8], [3, 8],
6, 7, 9],
[[1, 2, 6, 7], 9, [1, 2, 4, 6, 7, 8], [1, 3, 7, 8], 5,
[3, 6, 7, 8], [2, 3, 4], [1, 3], [1, 3, 4]],
[[1, 2, 5, 6, 7], 3, [1, 2, 6, 7], [1, 7, 9], 4,
[6, 7, 9], 2, 8, [1, 5]]]
def test_alldifferent_rcs():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.create_possibility()
sudoku_ad = sudoku_solver.Sudoku.alldifferent_rcs(s0.data)
assert sudoku_ad == [[[2, 3, 4, 8], [2, 3, 4, 7, 8], 6, [1, 2, 5, 7, 8],
[2, 4, 8], [1, 2, 4, 5, 8], [3, 5, 8], [1, 3, 5, 8],
9],
[[4, 8], 1, [4, 8], 3, [4, 6, 8], [4, 5, 8, 9], 2, 7,
[5, 6, 8]],
[
5, 9, [7, 8], [1, 2, 6, 7, 8], [2, 6, 8],
[1, 2, 8], 4, [1, 3, 6, 8], [1, 3, 6, 8]
],
[[1, 2, 3, 8], [2, 3, 8], 5, 9, [2, 3, 8], 6,
[3, 7, 8], 4, [1, 3, 7, 8]],
[[1, 3, 4, 6, 8], [3, 4, 6, 8], 9, [8], 5, 7,
[3, 6, 8], 2, [1, 3, 6, 8]],
[
7, [2, 3, 4, 6, 8], [4, 8], [2, 8], 1,
[2, 3, 4, 8], [3, 5, 6, 8, 9], [3, 5, 6, 8],
[3, 5, 6, 8]
],
[[6, 8], [5, 6, 7, 8], 3, 4, 9, [2, 5, 8], 1,
[5, 6, 8], [2, 5, 6, 7, 8]],
[[1, 4, 6, 8, 9], [4, 5, 6, 8], 2, [1, 5, 6, 8], 7,
[1, 3, 5, 8], [3, 5, 6, 8], [3, 5, 6, 8],
[3, 4, 5, 6, 8]],
[[1, 4, 6, 8], [4, 5, 6, 7, 8], [1, 4, 7, 8],
[1, 2, 5, 6, 8], [2, 3, 6, 8], [1, 2, 3, 5, 8],
[3, 5, 6, 7, 8], 9, [2, 3, 4, 5, 6, 7, 8]]]
def test_count_known_values():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.create_possibility()
values = sudoku_solver.Sudoku.count_known_values(s0.data)
assert values == 26
def test_get_min_choice():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.create_possibility()
s0_ad = sudoku_solver.Sudoku.alldifferent_rcs(s0.data)
choice = sudoku_solver.Sudoku.get_min_choice(s0_ad)
assert choice == [1, 0]
def test_load_new(self):
sudoku = sudoku_solver.Sudoku()
sudoku.load_new(difficulty="Medium #2")
self.assertEqual(
sudoku.grid,
[[0, 0, 0, 4, 8, 0, 2, 0, 9], [0, 0, 0, 0, 7, 0, 0, 5, 1],
[0, 8, 3, 0, 2, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0],
[7, 6, 0, 0, 0, 0, 0, 0, 2], [0, 5, 0, 7, 0, 9, 0, 0, 0],
[0, 0, 7, 0, 0, 5, 9, 0, 4], [0, 0, 0, 0, 0, 0, 5, 0, 0],
[4, 0, 0, 8, 0, 0, 6, 7, 0]])
def test_reset(self):
sudoku = sudoku_solver.Sudoku()
sudoku.solve()
sudoku.reset()
self.assertEqual(
sudoku.grid,
[[1, 0, 0, 9, 0, 4, 0, 8, 2], [0, 5, 2, 6, 8, 0, 3, 0, 0],
[8, 6, 4, 2, 0, 0, 9, 1, 0], [0, 1, 0, 0, 4, 9, 8, 0, 6],
[4, 9, 8, 3, 0, 0, 7, 0, 1], [6, 0, 7, 0, 1, 0, 0, 9, 3],
[0, 8, 6, 0, 3, 5, 2, 0, 9], [5, 0, 9, 0, 0, 2, 1, 3, 0],
[0, 3, 0, 4, 9, 7, 0, 0, 8]],
)
def test_get_hint():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
sudoku_unsolved = s0.data
s0.solve()
sudoku_solved = s0.data
known_values_1 = sudoku_solver.Sudoku.count_known_values(sudoku_unsolved)
sudoku_hint = sudoku_solver.Sudoku.get_hint(sudoku_unsolved, sudoku_solved)
known_values_2 = sudoku_solver.Sudoku.count_known_values(sudoku_hint)
assert known_values_1 == (known_values_2 - 1)
def test_get_data():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
assert s0.data == [['-', '-', 6, '-', '-', '-', '-', '-', 9],
['-', 1, '-', 3, '-', '-', 2, 7, '-'],
[5, 9, '-', '-', '-', '-', 4, '-', '-'],
['-', '-', 5, 9, '-', 6, '-', 4, '-'],
['-', '-', 9, '-', 5, 7, '-', 2, '-'],
[7, '-', '-', '-', 1, '-', '-', '-', '-'],
['-', '-', 3, 4, 9, '-', 1, '-', '-'],
['-', '-', 2, '-', 7, '-', '-', '-', '-'],
['-', '-', '-', '-', '-', '-', '-', 9, '-']]
def test_solve():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.solve()
assert s0.data == [[2, 3, 6, 7, 4, 5, 8, 1,
9], [8, 1, 4, 3, 6, 9, 2, 7, 5],
[5, 9, 7, 1, 2, 8, 4, 3,
6], [1, 2, 5, 9, 3, 6, 7, 4, 8],
[3, 4, 9, 8, 5, 7, 6, 2,
1], [7, 6, 8, 2, 1, 4, 9, 5, 3],
[6, 5, 3, 4, 9, 2, 1, 8,
7], [9, 8, 2, 5, 7, 1, 3, 6, 4],
[4, 7, 1, 6, 8, 3, 5, 9, 2]]
def test_get_subgrids():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
subgrids = sudoku_solver.Sudoku.get_subgrids(s0.data)
assert subgrids == [['-', '-', 6, '-', 1, '-', 5, 9, '-'],
['-', '-', '-', 3, '-', '-', '-', '-', '-'],
['-', '-', 9, 2, 7, '-', 4, '-', '-'],
['-', '-', 5, '-', '-', 9, 7, '-', '-'],
[9, '-', 6, '-', 5, 7, '-', 1, '-'],
['-', 4, '-', '-', 2, '-', '-', '-', '-'],
['-', '-', 3, '-', '-', 2, '-', '-', '-'],
[4, 9, '-', '-', 7, '-', '-', '-', '-'],
[1, '-', '-', '-', '-', '-', '-', 9, '-']]
def test_get_colomns():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
colomns = sudoku_solver.Sudoku.get_colomns(s0.data)
assert colomns == [['-', '-', 5, '-', '-', 7, '-', '-', '-'],
['-', 1, 9, '-', '-', '-', '-', '-', '-'],
[6, '-', '-', 5, 9, '-', 3, 2, '-'],
['-', 3, '-', 9, '-', '-', 4, '-', '-'],
['-', '-', '-', '-', 5, 1, 9, 7, '-'],
['-', '-', '-', 6, 7, '-', '-', '-', '-'],
['-', 2, 4, '-', '-', '-', 1, '-', '-'],
['-', 7, '-', 4, 2, '-', '-', '-', 9],
[9, '-', '-', '-', '-', '-', '-', '-', '-']]
def test_alldifferent_tabu_search():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.create_possibility()
s0.alldifferent_tabu_search()
assert s0.data == [[2, 3, 6, 7, 4, 5, 8, 1,
9], [8, 1, 4, 3, 6, 9, 2, 7, 5],
[5, 9, 7, 1, 2, 8, 4, 3,
6], [1, 2, 5, 9, 3, 6, 7, 4, 8],
[3, 4, 9, 8, 5, 7, 6, 2,
1], [7, 6, 8, 2, 1, 4, 9, 5, 3],
[6, 5, 3, 4, 9, 2, 1, 8,
7], [9, 8, 2, 5, 7, 1, 3, 6, 4],
[4, 7, 1, 6, 8, 3, 5, 9, 2]]
def test_set_data():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.set_data([['-', '-', '-', '-', '-', '-', 4, 4, 5],
['-', '-', 8, '-', 3, 5, '-', '-', '-'],
[4, 6, '-', '-', 2, '-', 8, '-', '-'],
['-', '-', '-', 2, '-', '-', '-', '-', '-'],
['-', 7, '-', 8, '-', '-', '-', '-', '-'],
['-', '-', '-', '-', 5, '-', 2, '-', 4],
[5, '-', '-', '-', '-', '-', 1, 8, '-'],
['-', 9, '-', '-', '-', 3, '-', '-', '-'],
[6, '-', '-', 1, 9, '-', '-', '-', '-']])
assert s0.data == [['-', '-', '-', '-', '-', '-', 4, 4, 5],
['-', '-', 8, '-', 3, 5, '-', '-', '-'],
[4, 6, '-', '-', 2, '-', 8, '-', '-'],
['-', '-', '-', 2, '-', '-', '-', '-', '-'],
['-', 7, '-', 8, '-', '-', '-', '-', '-'],
['-', '-', '-', '-', 5, '-', 2, '-', 4],
[5, '-', '-', '-', '-', '-', 1, 8, '-'],
['-', 9, '-', '-', '-', 3, '-', '-', '-'],
[6, '-', '-', 1, 9, '-', '-', '-', '-']]
def solve_grid(ord_grid, n):
"""
Arguments:
ord_grid -- the unsolved sudoku grid
n -- the number of iterations, better be high for hard sudokus
Returns:
Sudoku.ordinary_grid -- the solved (hopefully) sudoku grid
zeros_indices -- A list of coordinates of the originally
empty sudoku cells (before solving)
"""
# Construct a grid of blocks where each row is a block
blk_grid = [[ord_grid[0][0:3], ord_grid[1][0:3], ord_grid[2][0:3]],
[ord_grid[0][3:6], ord_grid[1][3:6], ord_grid[2][3:6]],
[ord_grid[0][6:9], ord_grid[1][6:9], ord_grid[2][6:9]],
[ord_grid[3][0:3], ord_grid[4][0:3], ord_grid[5][0:3]],
[ord_grid[3][3:6], ord_grid[4][3:6], ord_grid[5][3:6]],
[ord_grid[3][6:9], ord_grid[4][6:9], ord_grid[5][6:9]],
[ord_grid[6][0:3], ord_grid[7][0:3], ord_grid[8][0:3]],
[ord_grid[6][3:6], ord_grid[7][3:6], ord_grid[8][3:6]],
[ord_grid[6][6:9], ord_grid[7][6:9], ord_grid[8][6:9]]]
# Instantiate a Sudoku object
Sudoku = sd.Sudoku(grid=blk_grid, ordinaryGrid=ord_grid)
for i in range(1, n): # Repeat the algorithm n times
for number in range(1, 10): # Repeat the algorithm for all numbers
# 1. Solving using blocks
found_instances = Sudoku.find_num_blk_instances(
number) # a list of [block, row, column] per instance
valid_blocks = Sudoku.find_valid_blocks_for_num(
found_instances) # a list of possible blocks
for block in valid_blocks:
valid_cells = Sudoku.find_valid_cells_in_blk_for_num(
number, block, found_instances)
Sudoku.add_note_or_num(
number, block,
valid_cells) # Add a number (solve) or add a note
# 2. Solving using rows
ord_found_instances = Sudoku.find_ord_instances_for_num(
number) # a list of [row, column] per instance
valid_rows = Sudoku.find_valid_rows_for_num(
ord_found_instances) # a list of possible rows
for row in valid_rows:
row_valid_cells = Sudoku.find_valid_cells_in_row(
row, ord_found_instances)
Sudoku.add_to_row(number, row, row_valid_cells)
# 3. Solving using columns
ord_found_instances = Sudoku.find_ord_instances_for_num(
number) # a list of [row, column] per instance
valid_cols = Sudoku.find_valid_cols_for_num(
ord_found_instances) # a list of possible columns
for col in valid_cols:
col_valid_cells = Sudoku.find_valid_cells_in_col(
col, ord_found_instances)
Sudoku.add_to_col(number, col, col_valid_cells)
if Sudoku.solved:
return Sudoku.ordinaryGrid, Sudoku.emptyCells
# 4. Solving using cells
for row in range(0, 9):
Sudoku.solve_by_cell_in_row(row)
for col in range(0, 9):
Sudoku.solve_by_cell_in_col(col)
if Sudoku.solved:
return Sudoku.ordinaryGrid, Sudoku.emptyCells
return Sudoku.ordinaryGrid, Sudoku.emptyCells
def setUp(self):
self.sudoku = sudoku_solver.Sudoku(difficulty="Easy #1")
def test_create_possibility():
s0 = sudoku_solver.Sudoku(
"006000009010300270590000400005906040009057020700010000003490100002070000000000090"
)
s0.create_possibility()
assert s0.data == [[[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 6,
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 9],
[[1, 2, 3, 4, 5, 6, 7, 8, 9], 1,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 3,
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 2, 7,
[1, 2, 3, 4, 5, 6, 7, 8, 9]],
[
5, 9, [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 4,
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9]
],
[[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 5, 9,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 6,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 4,
[1, 2, 3, 4, 5, 6, 7, 8, 9]],
[[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 9,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 5, 7,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 2,
[1, 2, 3, 4, 5, 6, 7, 8, 9]],
[
7, [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 1,
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9]
],
[[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 3, 4, 9,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 1,
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9]],
[[1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 2,
[1, 2, 3, 4, 5, 6, 7, 8, 9], 7,
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9]],
[[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8,
9], [1, 2, 3, 4, 5, 6, 7, 8, 9],
[1, 2, 3, 4, 5, 6, 7, 8, 9], 9,
[1, 2, 3, 4, 5, 6, 7, 8, 9]]]
