def test_solve_diagonal_4(self):
diag_sudoku_grid_4 = '..7..5..2.......13.........9...8.7......7...5..2.......1..3.......54.......7....4'
expected_solution_4 = '367415892295867413841329657953284761684173925172956348418632579739541286526798134'
resp = solve(diag_sudoku_grid_4)
if resp is not False:
solution_4 = values_grid(resp)
print('Expected: {}'.format(expected_solution_4))
print('Solution: {}'.format(solution_4))
print(display(grid_values(solution_4)))
self.assertEquals(expected_solution_4, solution_4)
self.assertTrue(is_valid(grid_values(solution_4)))
else:
print('Could not find a valid solution.')
def test_naked_twins(self):
# given
"""
5 367 9 | 478 2 47 | 367 1 468
4 1237 23 | 178 5 6 | 2379 237 89
8 1267 26 | 9 14 3 | 267 2467 5
---------------+---------------+---------------
39 8 7 | 134 1349 2 | 5 36 16
6 5 4 | 137 139 179 | 13 8 2
23 23 1 | 5 6 8 | 4 9 7
---------------+---------------+---------------
1 369 8 | 2 349 5 | 679 467 469
7 29 25 | 6 8 149 | 129 245 3
239 4 2356| 13 7 19 | 8 256 169
"""
t_values = solution.eliminate(
solution.grid_values(
'5.9.2..1.4...56...8..9.3..5.87..25..654....82..15684971.82.5...7..68...3.4..7.8..'
))
# when
result = solution.naked_twins(t_values)
self.assertEqual('9', result['D1'])
def test_is_solved_correctly_False(self):
# given
t_values = solution.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..'
)
# then
self.assertFalse(solution.is_solved_correctly(t_values))
def test_is_solved_correctly_Incorrect(self):
# given
t_values = solution.grid_values(
'483921657967345821251876493548132976729564138136798245372689514814253769695417381'
) # only last char is 1
# then
self.assertFalse(solution.is_solved_correctly(t_values))
def test_is_solved_correctly_True(self):
# given
t_values = solution.grid_values(
'483921657967345821251876493548132976729564138136798245372689514814253769695417382'
)
# then
self.assertTrue(solution.is_solved_correctly(t_values))
def test_solve(self):
print("input:")
solution.display(solution.grid_values(self.diagonal_grid))
print("\nexpected:")
solved = solution.solve(self.diagonal_grid)
solution.display(self.solved_diag_sudoku)
print("\nsolution:")
solution.display(solved)
self.assertEqual(solved, self.solved_diag_sudoku)
def time_solve(grid):
start = time.clock()
values = solution.solve(grid)
t = time.clock() - start
# Display puzzles that take long enough
if showif is not None and t > showif:
solution.display(solution.grid_values(grid))
if values: solution.display(values)
print('(%.2f seconds)\n' % t)
return (t, solved(values))
def test_grid_values(self):
# given
t_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..'
# when
result = solution.grid_values(t_grid_values)
# then
self.assertEquals('123456789', result['A1'])
self.assertEquals('9', result['B1'])
self.assertEquals('9', result['G6'])
self.assertEquals('1', result['I5'])
def test_search(self):
# given
t_values = solution.grid_values(
'.....97..4..7...2...18...39.3....4...769.531...4....9.84...39...1...8..3..26.....'
)
# when
values = solution.search(t_values)
# then
self.assertTrue(solution.is_solved_correctly(values))
print()
lines = solution.display(values)
def test_reduce_puzzle(self):
# given
t_values = solution.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..'
)
# when
values = solution.reduce_puzzle(t_values)
# then
self.assertTrue(solution.is_solved_correctly(values))
print()
solution.display(values)
def test_display(self):
# given
t_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..'
# when
lines = solution.display(solution.grid_values(t_grid_values))
# then
self.assertEquals(
'123456789 123456789 3 |123456789 2 123456789 | 6 123456789 123456789 ',
lines[0])
self.assertEquals(
'123456789 123456789 8 | 1 123456789 2 | 9 123456789 123456789 ',
lines[4])
self.assertEquals(
'123456789 123456789 5 |123456789 1 123456789 | 3 123456789 123456789 ',
lines[10])
def test_only_choice(self):
# given
t_values = solution.eliminate(
solution.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..'
))
# when
print()
lines = solution.display(solution.only_choice(t_values))
# then
self.assertEquals(
' 345 345 8 | 1 3456 2 | 9 34567 34567 ',
lines[4])
self.assertEquals(
' 7 2 9 | 5 34569 4 | 1 13456 8 ',
lines[5])
self.assertEquals(
' 1345 13459 6 | 7 3459 8 | 2 1345 345 ',
lines[6])
def test_eliminate(self):
# given
t_values = solution.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..'
)
# when
result = solution.eliminate(t_values)
# then
self.assertEquals('45', result['A1'])
self.assertEquals('9', result['B1'])
self.assertEquals('9', result['G6'])
self.assertEquals('1', result['I5'])
self.assertEquals('34569', result['E5'])
self.assertEquals('24678', result['I8'])
# print
print()
solution.display(result)
def test_grid_values(self):
"""
test the grid_values function
"""
sudoku_grid = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..'
sudoku_dict = {
'C7': '4',
'I6': '123456789',
'E7': '123456789',
'E6': '123456789',
'F6': '8',
'H6': '3',
'C9': '123456789',
'E4': '123456789',
'E9': '8',
'G7': '5',
'A3': '3',
'H2': '123456789',
'G8': '123456789',
'B5': '123456789',
'G5': '123456789',
'G1': '123456789',
'A2': '123456789',
'F7': '2',
'F4': '7',
'B2': '123456789',
'H7': '123456789',
'G2': '123456789',
'I8': '123456789',
'H9': '9',
'B7': '123456789',
'E2': '123456789',
'F9': '123456789',
'I7': '3',
'F3': '6',
'I9': '123456789',
'D8': '123456789',
'G9': '123456789',
'F1': '123456789',
'D5': '123456789',
'B4': '3',
'H5': '123456789',
'I2': '123456789',
'A6': '123456789',
'G3': '2',
'H8': '123456789',
'H4': '2',
'A4': '123456789',
'A9': '123456789',
'D9': '123456789',
'I3': '5',
'E1': '7',
'C2': '123456789',
'F8': '123456789',
'B8': '123456789',
'A7': '6',
'C1': '123456789',
'D2': '123456789',
'C5': '123456789',
'H3': '123456789',
'B1': '9',
'I5': '1',
'A8': '123456789',
'A5': '2',
'F2': '123456789',
'A1': '123456789',
'D7': '9',
'G4': '6',
'H1': '8',
'C8': '123456789',
'E5': '123456789',
'C3': '1',
'C6': '6',
'D3': '8',
'D4': '1',
'D1': '123456789',
'I1': '123456789',
'B3': '123456789',
'B6': '5',
'G6': '9',
'I4': '123456789',
'F5': '123456789',
'B9': '1',
'C4': '8',
'E8': '123456789',
'D6': '2',
'E3': '123456789'
}
self.assertEqual(solution.grid_values(sudoku_grid), sudoku_dict)
def test_grid_values(self):
grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
solution.display(solution.grid_values(grid))
def test_grid_values(self):
items = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
values = solution.grid_values(items)
self.assertEqual(len(values), 81)
expectedValues = {
'A1': '2',
'A2': '123456789',
'A3': '123456789',
'A4': '123456789',
'A5': '123456789',
'A6': '123456789',
'A7': '123456789',
'A8': '123456789',
'A9': '123456789',
'B1': '123456789',
'B2': '123456789',
'B3': '123456789',
'B4': '123456789',
'B5': '123456789',
'B6': '6',
'B7': '2',
'B8': '123456789',
'B9': '123456789',
'C1': '123456789',
'C2': '123456789',
'C3': '1',
'C4': '123456789',
'C5': '123456789',
'C6': '123456789',
'C7': '123456789',
'C8': '7',
'C9': '123456789',
'D1': '123456789',
'D2': '123456789',
'D3': '6',
'D4': '123456789',
'D5': '123456789',
'D6': '8',
'D7': '123456789',
'D8': '123456789',
'D9': '123456789',
'E1': '3',
'E2': '123456789',
'E3': '123456789',
'E4': '123456789',
'E5': '9',
'E6': '123456789',
'E7': '123456789',
'E8': '123456789',
'E9': '7',
'F1': '123456789',
'F2': '123456789',
'F3': '123456789',
'F4': '6',
'F5': '123456789',
'F6': '123456789',
'F7': '4',
'F8': '123456789',
'F9': '123456789',
'G1': '123456789',
'G2': '4',
'G3': '123456789',
'G4': '123456789',
'G5': '123456789',
'G6': '123456789',
'G7': '8',
'G8': '123456789',
'G9': '123456789',
'H1': '123456789',
'H2': '123456789',
'H3': '5',
'H4': '2',
'H5': '123456789',
'H6': '123456789',
'H7': '123456789',
'H8': '123456789',
'H9': '123456789',
'I1': '123456789',
'I2': '123456789',
'I3': '123456789',
'I4': '123456789',
'I5': '123456789',
'I6': '123456789',
'I7': '123456789',
'I8': '123456789',
'I9': '3'
}
self.assertEqual(expectedValues, values)
def test_search(self):
p = '4.....8.5.3..........7......2.....6.....8.4......1.......6.3.7.5..2.....1.4......'
p = solution.grid_values(p)
solution.search(p)
expected = {
'A1': '4',
'A2': '9',
'A3': '7',
'A4': '1',
'A5': '2',
'A6': '6',
'A7': '8',
'A8': '3',
'A9': '5',
'B1': '6',
'B2': '3',
'B3': '8',
'B4': '4',
'B5': '6',
'B6': '568',
'B7': '79',
'B8': '2',
'B9': '179',
'C1': '289',
'C2': '1',
'C3': '2',
'C4': '7',
'C5': '3',
'C6': '58',
'C7': '6',
'C8': '4',
'C9': '139',
'D1': '8',
'D2': '2',
'D3': '1',
'D4': '5',
'D5': '39',
'D6': '4',
'D7': '379',
'D8': '6',
'D9': '379',
'E1': '7',
'E2': '5',
'E3': '569',
'E4': '39',
'E5': '8',
'E6': '2',
'E7': '4',
'E8': '1',
'E9': '379',
'F1': '3',
'F2': '4',
'F3': '569',
'F4': '',
'F5': '1',
'F6': '7',
'F7': '5',
'F8': '8',
'F9': '239',
'G1': '2',
'G2': '8',
'G3': '9',
'G4': '6',
'G5': '5',
'G6': '3',
'G7': '1',
'G8': '7',
'G9': '4',
'H1': '5',
'H2': '7',
'H3': '3',
'H4': '2',
'H5': '4',
'H6': '1',
'H7': '',
'H8': '9',
'H9': '8',
'I1': '1',
'I2': '6',
'I3': '4',
'I4': '8',
'I5': '7',
'I6': '9',
'I7': '3',
'I8': '5',
'I9': '2'
}
self.assertEqual(expected, p)
def test_solve_naked_twins(self):
before_naked_twins1 = '9.1....8.8.5.7..4.2.4....6...7......5..............83.3..6......9................'
expected_solution = '9.1....8.8.5.7..4.2.4....6...7......5..............83.3..6......9................'
solution = values_grid(naked_twins(grid_values(before_naked_twins1)))
self.assertEquals(solution, expected_solution)
def test_solve(self):
solution.display(solution.grid_values(self.diagonal_grid2))
solution.display(solution.solve(self.diagonal_grid2))
self.assertEqual(solution.solve(self.diagonal_grid),
self.solved_diag_sudoku)
def test_grid_values(self):
response = grid_values(self.grid_1)
print(response)
self.assertEqual(response, self.values_1)
def test_unsolved_string_substitution(self):
values = solution.grid_values(self.diagonal_grid)
self.assertEqual(values['A2'], '123456789')
'D4': '237',
'D5': '347',
'D2': '1',
'D3': '79',
'D1': '5'
}
class TestNakedTwins(unittest.TestCase):
def test_naked_twins(self):
self.assertEqual(solution.naked_twins(before_naked_twins),
after_naked_twins)
diagonal_grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
diag_sudoku = solution.grid_values(diagonal_grid)
solved_diag_sudoku = {
'G7': '8',
'G6': '9',
'G5': '7',
'G4': '3',
'G3': '2',
'G2': '4',
'G1': '6',
'G9': '5',
'G8': '1',
'C9': '6',
'C8': '7',
'C3': '1',
'C2': '9',
'C1': '4',
class TestNormalSudoku(unittest.TestCase):
normal_grid = '..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3..'
solved_normal_sudoku = solution.grid_values('483921657967345821251876493548132976729564138136798245372689514814253769695417382')
def rest_solve(self):
self.assertEqual(solution.solve(self.normal_grid), self.solved_normal_sudoku)
def empty_grid():
return solution.grid_values('.' * 81)
def test_display_001(self):
grid = "..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3.."
display(grid_values(grid))
def test_direct_copy_of_solved_boxes(self):
values = solution.grid_values(self.diagonal_grid)
self.assertEqual(values['A1'], '2')
self.assertEqual(values['B6'], '6')
def test_only_choice_001(self):
grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
values = grid_values(grid)
values = eliminate(values)
values = only_choice(values)
# with the diagonal constraint
self.assertEqual(
{
'G7': '8',
'G6': '13579',
'G5': '13567',
'G4': '13579',
'G3': '2',
'G2': '4',
'G1': '1679',
'G9': '12569',
'G8': '12569',
'C9': '45689',
'C8': '7',
'C3': '1',
'C2': '35689',
'C1': '45689',
'C7': '35',
'C6': '23459',
'C5': '23458',
'C4': '34589',
'E5': '9',
'E4': '145',
'F1': '15789',
'F2': '125789',
'F3': '2789',
'F4': '6',
'F5': '12357',
'F6': '57',
'F7': '4',
'F8': '123589',
'F9': '12589',
'B4': '1345789',
'B5': '134578',
'B6': '6',
'B7': '2',
'B1': '45789',
'B2': '57',
'B3': '34789',
'B8': '1345',
'B9': '14589',
'I9': '3',
'I8': '124569',
'I1': '17',
'I3': '2789',
'I2': '126789',
'I5': '145678',
'I4': '145789',
'I7': '15679',
'I6': '14579',
'A1': '2',
'A3': '34789',
'A2': '356789',
'E9': '7',
'A4': '1345789',
'A7': '13569',
'A6': '134579',
'A9': '145',
'A8': '1345689',
'E7': '156',
'E6': '1245',
'E1': '3',
'E3': '248',
'E2': '1258',
'E8': '12568',
'A5': '134578',
'H8': '6',
'H9': '1469',
'H2': '137',
'H3': '5',
'H1': '16789',
'H6': '13479',
'H7': '1679',
'H4': '2',
'H5': '134678',
'D8': '12359',
'D9': '1259',
'D6': '8',
'D7': '1359',
'D4': '457',
'D5': '123457',
'D2': '12579',
'D3': '6',
'D1': '14579'
}, values)
def test_grid_values_001(self):
grid = "..3.2.6..9..3.5..1..18.64....81.29..7.......8..67.82....26.95..8..2.3..9..5.1.3.."
self.assertEqual(
{
'I6': '123456789',
'H9': '9',
'I2': '123456789',
'E8': '123456789',
'H3': '123456789',
'H7': '123456789',
'I7': '3',
'I4': '123456789',
'H5': '123456789',
'F9': '123456789',
'G7': '5',
'G6': '9',
'G5': '123456789',
'E1': '7',
'G3': '2',
'G2': '123456789',
'G1': '123456789',
'I1': '123456789',
'C8': '123456789',
'I3': '5',
'E5': '123456789',
'I5': '1',
'C9': '123456789',
'G9': '123456789',
'G8': '123456789',
'A1': '123456789',
'A3': '3',
'A2': '123456789',
'A5': '2',
'A4': '123456789',
'A7': '6',
'A6': '123456789',
'C3': '1',
'C2': '123456789',
'C1': '123456789',
'E6': '123456789',
'C7': '4',
'C6': '6',
'C5': '123456789',
'C4': '8',
'I9': '123456789',
'D8': '123456789',
'I8': '123456789',
'E4': '123456789',
'D9': '123456789',
'H8': '123456789',
'F6': '8',
'A9': '123456789',
'G4': '6',
'A8': '123456789',
'E7': '123456789',
'E3': '123456789',
'F1': '123456789',
'F2': '123456789',
'F3': '6',
'F4': '7',
'F5': '123456789',
'E2': '123456789',
'F7': '2',
'F8': '123456789',
'D2': '123456789',
'H1': '8',
'H6': '3',
'H2': '123456789',
'H4': '2',
'D3': '8',
'B4': '3',
'B5': '123456789',
'B6': '5',
'B7': '123456789',
'E9': '8',
'B1': '9',
'B2': '123456789',
'B3': '123456789',
'D6': '2',
'D7': '9',
'D4': '1',
'D5': '123456789',
'B8': '123456789',
'B9': '1',
'D1': '123456789'
}, grid_values(grid))
class TestXWing(unittest.TestCase):
before_x_wing_1 = solution.eliminate(
solution.grid_values(
'.....7..6...2..5....613.79.63194..5729.76..8374.325169..261...8..3.796.59.78..3.4'
))
possible_solutions_1 = [{
'A1': '1358',
'A2': '1258',
'A3': '4589',
'A4': '45',
'A5': '89',
'A6': '7',
'A7': '248',
'A8': '1234',
'A9': '6',
'B1': '138',
'B2': '178',
'B3': '489',
'B4': '2',
'B5': '89',
'B6': '68',
'B7': '5',
'B8': '134',
'B9': '1',
'C1': '458',
'C2': '258',
'C3': '6',
'C4': '1',
'C5': '3',
'C6': '48',
'C7': '7',
'C8': '9',
'C9': '2',
'D1': '6',
'D2': '3',
'D3': '1',
'D4': '9',
'D5': '4',
'D6': '8',
'D7': '2',
'D8': '5',
'D9': '7',
'E1': '2',
'E2': '9',
'E3': '5',
'E4': '7',
'E5': '6',
'E6': '1',
'E7': '4',
'E8': '8',
'E9': '3',
'F1': '7',
'F2': '4',
'F3': '8',
'F4': '3',
'F5': '2',
'F6': '5',
'F7': '1',
'F8': '6',
'F9': '9',
'G1': '45',
'G2': '5',
'G3': '2',
'G4': '6',
'G5': '1',
'G6': '34',
'G7': '9',
'G8': '7',
'G9': '8',
'H1': '18',
'H2': '18',
'H3': '3',
'H4': '4',
'H5': '7',
'H6': '9',
'H7': '6',
'H8': '12',
'H9': '5',
'I1': '9',
'I2': '16',
'I3': '7',
'I4': '8',
'I5': '5',
'I6': '2',
'I7': '3',
'I8': '12',
'I9': '4'
}]
def test_x_wing(self):
discarded_val = '4'
discarded_boxes = solution.cross('ABDEFHI', '16')
sol = solution.x_wing(self.before_x_wing_1)
for box in discarded_boxes:
self.assertTrue(discarded_val not in sol[box])
def test_search_001(self):
grid = '2.............62....1....7...6..8...3...9...7...6..4...4....8....52.............3'
values = grid_values(grid)
values = search(values)
# with the diagonal constraint
self.assertEqual(
{
'G7': '8',
'G6': '9',
'G5': '7',
'G4': '3',
'G3': '2',
'G2': '4',
'G1': '6',
'G9': '5',
'G8': '1',
'C9': '6',
'C8': '7',
'C3': '1',
'C2': '9',
'C1': '4',
'C7': '5',
'C6': '3',
'C5': '2',
'C4': '8',
'E5': '9',
'E4': '1',
'F1': '1',
'F2': '2',
'F3': '9',
'F4': '6',
'F5': '5',
'F6': '7',
'F7': '4',
'F8': '3',
'F9': '8',
'B4': '7',
'B5': '1',
'B6': '6',
'B7': '2',
'B1': '8',
'B2': '5',
'B3': '3',
'B8': '4',
'B9': '9',
'I9': '3',
'I8': '2',
'I1': '7',
'I3': '8',
'I2': '1',
'I5': '6',
'I4': '5',
'I7': '9',
'I6': '4',
'A1': '2',
'A3': '7',
'A2': '6',
'E9': '7',
'A4': '9',
'A7': '3',
'A6': '5',
'A9': '1',
'A8': '8',
'E7': '6',
'E6': '2',
'E1': '3',
'E3': '4',
'E2': '8',
'E8': '5',
'A5': '4',
'H8': '6',
'H9': '4',
'H2': '3',
'H3': '5',
'H1': '9',
'H6': '1',
'H7': '7',
'H4': '2',
'H5': '8',
'D8': '9',
'D9': '2',
'D6': '8',
'D7': '1',
'D4': '4',
'D5': '3',
'D2': '7',
'D3': '6',
'D1': '5'
}, values)
