class TestAlgPeter(unittest.TestCase):
def setUp(self):
self.solver = PeterNorvigAlgorithm()
def tearDown(self):
pass
def test_WhenAPeterNorvigSolverIsCreatedThenThenTheBasicStructuresToSolveSudokuShouldBeCreatedProperly(self):
pass
"A set of tests that must pass."
assert len(self.solver.squares) == 81
assert len(self.solver.unitlist) == 27
assert all(len(self.solver.units[s]) == 3 for s in self.solver.squares)
assert all(len(self.solver.peers[s]) == 20 for s in self.solver.squares)
assert self.solver.units['C2'] == [['A2', 'B2', 'C2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2'],
['C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9'],
['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']]
assert self.solver.peers['C2'] == set(['A2', 'B2', 'D2', 'E2', 'F2', 'G2', 'H2', 'I2',
'C1', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9',
'A1', 'A3', 'B1', 'B3'])
def test_CrossFunctionShouldReturnTheCartesianOperationOfTwoMatrices(self):
list1 = ['A', 'B', 'C']
list2 = ['1', '2', '3']
expected = ['A1', 'A2', 'A3', 'B1', 'B2', 'B3', 'C1', 'C2', 'C3']
result = self.solver.cross(list1, list2)
self.assertEqual(expected, result)
def test_parsegridisworkingwell(self):
initialGrid = {
"A1":'.', "A2":'.', "A3":'.', "A4":'.', "A5":'.', "A6":'.', "A7":'.', "A8":'.', "A9":'.',
"B1":'.', "B2":'4', "B3":'.', "B4":'.', "B5":'.', "B6":'.', "B7":'.', "B8":'.', "B9":'.',
"C1":'.', "C2":'.', "C3":'.', "C4":'.', "C5":'.', "C6":'.', "C7":'.', "C8":'.', "C9":'.',
"D1":'.', "D2":'.', "D3":'.', "D4":'.', "D5":'.', "D6":'.', "D7":'.', "D8":'.', "D9":'.',
"E1":'.', "E2":'.', "E3":'.', "E4":'.', "E5":'.', "E6":'.', "E7":'.', "E8":'.', "E9":'.',
"F1":'.', "F2":'.', "F3":'.', "F4":'.', "F5":'.', "F6":'.', "F7":'.', "F8":'.', "F9":'.',
"G1":'.', "G2":'.', "G3":'.', "G4":'.', "G5":'.', "G6":'.', "G7":'.', "G8":'.', "G9":'.',
"H1":'.', "H2":'.', "H3":'.', "H4":'.', "H5":'.', "H6":'.', "H7":'.', "H8":'.', "H9":'.',
"I1":'.', "I2":'.', "I3":'.', "I4":'.', "I5":'.', "I6":'.', "I7":'.', "I8":'.', "I9":'.'
}
values = self.solver.parse_grid(initialGrid)
other = '123456789'
peer = '12356789'
square = '4'
self.assertEqual(square, values['B2'])
allPeers = self.solver.peers['B2']
for p in allPeers:
self.assertEqual(peer, values[p])
otherSquares = set(self.solver.squares) - allPeers - set(['B2'])
for o in otherSquares:
self.assertEqual(other, values[o])
def test_Given_A_Sudoku_Nivel_Basic_Then_Alg_Of_Peter_Should_Solver_Sudoku_With_Correct_Solution(self):
initialGrid = {
"A1":'.', "A2":'6', "A3":'7', "A4":'.', "A5":'4', "A6":'.', "A7":'.', "A8":'.', "A9":'2',
"B1":'9', "B2":'.', "B3":'.', "B4":'7', "B5":'3', "B6":'.', "B7":'4', "B8":'5', "B9":'.',
"C1":'4', "C2":'.', "C3":'5', "C4":'.', "C5":'.', "C6":'.', "C7":'.', "C8":'.', "C9":'.',
"D1":'6', "D2":'.', "D3":'.', "D4":'.', "D5":'8', "D6":'.', "D7":'.', "D8":'.', "D9":'.',
"E1":'.', "E2":'.', "E3":'.', "E4":'9', "E5":'.', "E6":'.', "E7":'3', "E8":'2', "E9":'.',
"F1":'2', "F2":'8', "F3":'3', "F4":'5', "F5":'.', "F6":'.', "F7":'6', "F8":'4', "F9":'9',
"G1":'.', "G2":'7', "G3":'.', "G4":'.', "G5":'.', "G6":'.', "G7":'.', "G8":'.', "G9":'3',
"H1":'.', "H2":'.', "H3":'.', "H4":'6', "H5":'5', "H6":'7', "H7":'8', "H8":'.', "H9":'4',
"I1":'.', "I2":'.', "I3":'6', "I4":'4', "I5":'2', "I6":'3', "I7":'5', "I8":'9', "I9":'7'
}
expectedGrid = {
"A1":'1', "A2":'6', "A3":'7', "A4":'8', "A5":'4', "A6":'5', "A7":'9', "A8":'3', "A9":'2',
"B1":'9', "B2":'2', "B3":'8', "B4":'7', "B5":'3', "B6":'6', "B7":'4', "B8":'5', "B9":'1',
"C1":'4', "C2":'3', "C3":'5', "C4":'2', "C5":'1', "C6":'9', "C7":'7', "C8":'8', "C9":'6',
"D1":'6', "D2":'4', "D3":'9', "D4":'3', "D5":'8', "D6":'2', "D7":'1', "D8":'7', "D9":'5',
"E1":'7', "E2":'5', "E3":'1', "E4":'9', "E5":'6', "E6":'4', "E7":'3', "E8":'2', "E9":'8',
"F1":'2', "F2":'8', "F3":'3', "F4":'5', "F5":'7', "F6":'1', "F7":'6', "F8":'4', "F9":'9',
"G1":'5', "G2":'7', "G3":'4', "G4":'1', "G5":'9', "G6":'8', "G7":'2', "G8":'6', "G9":'3',
"H1":'3', "H2":'9', "H3":'2', "H4":'6', "H5":'5', "H6":'7', "H7":'8', "H8":'1', "H9":'4',
"I1":'8', "I2":'1', "I3":'6', "I4":'4', "I5":'2', "I6":'3', "I7":'5', "I8":'9', "I9":'7'
}
solution = self.solver.solve(initialGrid)
self.assertEqual(expectedGrid, solution)
def test_Given_A_Sudoku_Nivel_Intermediate_Then_Alg_Of_Peter_Should_Solver_Sudoku_With_Correct_Solution(self):
initialGrid = {
"A1":'.', "A2":'8', "A3":'.', "A4":'7', "A5":'.', "A6":'4', "A7":'.', "A8":'.', "A9":'.',
"B1":'9', "B2":'.', "B3":'4', "B4":'.', "B5":'.', "B6":'.', "B7":'6', "B8":'.', "B9":'8',
"C1":'7', "C2":'.', "C3":'6', "C4":'.', "C5":'8', "C6":'.', "C7":'.', "C8":'.', "C9":'.',
"D1":'.', "D2":'.', "D3":'.', "D4":'2', "D5":'.', "D6":'8', "D7":'.', "D8":'6', "D9":'5',
"E1":'.', "E2":'9', "E3":'2', "E4":'.', "E5":'4', "E6":'7', "E7":'.', "E8":'.', "E9":'3',
"F1":'.', "F2":'.', "F3":'.', "F4":'.', "F5":'.', "F6":'.', "F7":'.', "F8":'.', "F9":'.',
"G1":'.', "G2":'.', "G3":'.', "G4":'8', "G5":'.', "G6":'.', "G7":'.', "G8":'.', "G9":'1',
"H1":'4', "H2":'6', "H3":'5', "H4":'.', "H5":'2', "H6":'.', "H7":'.', "H8":'8', "H9":'9',
"I1":'3', "I2":'.', "I3":'.', "I4":'.', "I5":'.', "I6":'9', "I7":'5', "I8":'.', "I9":'6'
}
expectedGrid = {
"A1":'5', "A2":'8', "A3":'1', "A4":'7', "A5":'6', "A6":'4', "A7":'3', "A8":'9', "A9":'2',
"B1":'9', "B2":'2', "B3":'4', "B4":'3', "B5":'1', "B6":'5', "B7":'6', "B8":'7', "B9":'8',
"C1":'7', "C2":'3', "C3":'6', "C4":'9', "C5":'8', "C6":'2', "C7":'1', "C8":'5', "C9":'4',
"D1":'1', "D2":'4', "D3":'7', "D4":'2', "D5":'3', "D6":'8', "D7":'9', "D8":'6', "D9":'5',
"E1":'6', "E2":'9', "E3":'2', "E4":'5', "E5":'4', "E6":'7', "E7":'8', "E8":'1', "E9":'3',
"F1":'8', "F2":'5', "F3":'3', "F4":'6', "F5":'9', "F6":'1', "F7":'2', "F8":'4', "F9":'7',
"G1":'2', "G2":'7', "G3":'9', "G4":'8', "G5":'5', "G6":'6', "G7":'4', "G8":'3', "G9":'1',
"H1":'4', "H2":'6', "H3":'5', "H4":'1', "H5":'2', "H6":'3', "H7":'7', "H8":'8', "H9":'9',
"I1":'3', "I2":'1', "I3":'8', "I4":'4', "I5":'7', "I6":'9', "I7":'5', "I8":'2', "I9":'6'
}
solution = self.solver.solve(initialGrid)
self.assertEqual(expectedGrid, solution)
def test_Given_A_Sudoku_Nivel_Advanced_Then_Alg_Of_Peter_Should_Solver_Sudoku_With_Correct_Solution(self):
initialGrid = {
"A1":'.', "A2":'.', "A3":'9', "A4":'.', "A5":'2', "A6":'1', "A7":'4', "A8":'.', "A9":'.',
"B1":'7', "B2":'.', "B3":'.', "B4":'.', "B5":'3', "B6":'.', "B7":'.', "B8":'.', "B9":'6',
"C1":'.', "C2":'6', "C3":'.', "C4":'.', "C5":'.', "C6":'4', "C7":'.', "C8":'2', "C9":'.',
"D1":'9', "D2":'.', "D3":'5', "D4":'.', "D5":'.', "D6":'.', "D7":'.', "D8":'8', "D9":'.',
"E1":'.', "E2":'.', "E3":'.', "E4":'.', "E5":'.', "E6":'.', "E7":'.', "E8":'.', "E9":'.',
"F1":'8', "F2":'.', "F3":'3', "F4":'.', "F5":'6', "F6":'.', "F7":'.', "F8":'1', "F9":'.',
"G1":'.', "G2":'.', "G3":'.', "G4":'.', "G5":'.', "G6":'.', "G7":'.', "G8":'5', "G9":'2',
"H1":'.', "H2":'.', "H3":'.', "H4":'2', "H5":'.', "H6":'8', "H7":'.', "H8":'3', "H9":'.',
"I1":'.', "I2":'.', "I3":'.', "I4":'.', "I5":'4', "I6":'9', "I7":'.', "I8":'.', "I9":'.'
}
expectedGrid = {
"A1":'3', "A2":'8', "A3":'9', "A4":'6', "A5":'2', "A6":'1', "A7":'4', "A8":'7', "A9":'5',
"B1":'7', "B2":'2', "B3":'4', "B4":'8', "B5":'3', "B6":'5', "B7":'1', "B8":'9', "B9":'6',
"C1":'5', "C2":'6', "C3":'1', "C4":'7', "C5":'9', "C6":'4', "C7":'3', "C8":'2', "C9":'8',
"D1":'9', "D2":'7', "D3":'5', "D4":'4', "D5":'1', "D6":'2', "D7":'6', "D8":'8', "D9":'3',
"E1":'6', "E2":'1', "E3":'2', "E4":'9', "E5":'8', "E6":'3', "E7":'5', "E8":'4', "E9":'7',
"F1":'8', "F2":'4', "F3":'3', "F4":'5', "F5":'6', "F6":'7', "F7":'2', "F8":'1', "F9":'9',
"G1":'4', "G2":'3', "G3":'8', "G4":'1', "G5":'7', "G6":'6', "G7":'9', "G8":'5', "G9":'2',
"H1":'1', "H2":'9', "H3":'6', "H4":'2', "H5":'5', "H6":'8', "H7":'7', "H8":'3', "H9":'4',
"I1":'2', "I2":'5', "I3":'7', "I4":'3', "I5":'4', "I6":'9', "I7":'8', "I8":'6', "I9":'1'
}
solution = self.solver.solve(initialGrid)
self.assertEqual(expectedGrid, solution)
def test_Given_A_InvalidSudoku_Then_Alg_Of_Peter_Should_Not_Solve_Sudoku(self):
initialGrid = {
"A1":'.', "A2":'6', "A3":'7', "A4":'.', "A5":'4', "A6":'.', "A7":'.', "A8":'7', "A9":'2',
"B1":'9', "B2":'.', "B3":'.', "B4":'7', "B5":'3', "B6":'.', "B7":'4', "B8":'5', "B9":'.',
"C1":'4', "C2":'.', "C3":'5', "C4":'.', "C5":'.', "C6":'.', "C7":'.', "C8":'.', "C9":'.',
"D1":'6', "D2":'.', "D3":'.', "D4":'.', "D5":'8', "D6":'.', "D7":'.', "D8":'.', "D9":'.',
"E1":'.', "E2":'.', "E3":'.', "E4":'9', "E5":'.', "E6":'.', "E7":'3', "E8":'2', "E9":'.',
"F1":'2', "F2":'8', "F3":'3', "F4":'5', "F5":'.', "F6":'.', "F7":'6', "F8":'4', "F9":'9',
"G1":'.', "G2":'7', "G3":'.', "G4":'.', "G5":'.', "G6":'.', "G7":'.', "G8":'.', "G9":'3',
"H1":'.', "H2":'.', "H3":'.', "H4":'6', "H5":'5', "H6":'7', "H7":'8', "H8":'.', "H9":'4',
"I1":'.', "I2":'.', "I3":'6', "I4":'4', "I5":'2', "I6":'3', "I7":'5', "I8":'9', "I9":'7'
}
try:
self.solver.solve(initialGrid)
self.fail("Did't raise expected InvalidSudokuException")
except InvalidSudokuException:
pass
def test_Given_A_EmptySudoku_Then_Alg_Of_Peter_Should_Solve_Sudoku(self):
initialGrid = {
"A1":'.', "A2":'.', "A3":'.', "A4":'.', "A5":'.', "A6":'.', "A7":'.', "A8":'.', "A9":'.',
"B1":'.', "B2":'.', "B3":'.', "B4":'.', "B5":'.', "B6":'.', "B7":'.', "B8":'.', "B9":'.',
"C1":'.', "C2":'.', "C3":'.', "C4":'.', "C5":'.', "C6":'.', "C7":'.', "C8":'.', "C9":'.',
"D1":'.', "D2":'.', "D3":'.', "D4":'.', "D5":'.', "D6":'.', "D7":'.', "D8":'.', "D9":'.',
"E1":'.', "E2":'.', "E3":'.', "E4":'.', "E5":'.', "E6":'.', "E7":'.', "E8":'.', "E9":'.',
"F1":'.', "F2":'.', "F3":'.', "F4":'.', "F5":'.', "F6":'.', "F7":'.', "F8":'.', "F9":'.',
"G1":'.', "G2":'.', "G3":'.', "G4":'.', "G5":'.', "G6":'.', "G7":'.', "G8":'.', "G9":'.',
"H1":'.', "H2":'.', "H3":'.', "H4":'.', "H5":'.', "H6":'.', "H7":'.', "H8":'.', "H9":'.',
"I1":'.', "I2":'.', "I3":'.', "I4":'.', "I5":'.', "I6":'.', "I7":'.', "I8":'.', "I9":'.'
}
expectedGrid = {
"A1":'1', "A2":'2', "A3":'3', "A4":'4', "A5":'5', "A6":'6', "A7":'7', "A8":'8', "A9":'9',
"B1":'4', "B2":'5', "B3":'6', "B4":'7', "B5":'8', "B6":'9', "B7":'1', "B8":'2', "B9":'3',
"C1":'7', "C2":'8', "C3":'9', "C4":'1', "C5":'2', "C6":'3', "C7":'4', "C8":'5', "C9":'6',
"D1":'2', "D2":'3', "D3":'1', "D4":'6', "D5":'7', "D6":'4', "D7":'8', "D8":'9', "D9":'5',
"E1":'8', "E2":'7', "E3":'5', "E4":'9', "E5":'1', "E6":'2', "E7":'3', "E8":'6', "E9":'4',
"F1":'6', "F2":'9', "F3":'4', "F4":'5', "F5":'3', "F6":'8', "F7":'2', "F8":'1', "F9":'7',
"G1":'3', "G2":'1', "G3":'7', "G4":'2', "G5":'6', "G6":'5', "G7":'9', "G8":'4', "G9":'8',
"H1":'5', "H2":'4', "H3":'2', "H4":'8', "H5":'9', "H6":'7', "H7":'6', "H8":'3', "H9":'1',
"I1":'9', "I2":'6', "I3":'8', "I4":'3', "I5":'4', "I6":'1', "I7":'5', "I8":'7', "I9":'2'
}
solution = self.solver.solve(initialGrid)
self.assertEqual(expectedGrid, solution)
def test_Given_A_Valid_Solved_Sudoku_Then_Alg_Of_Peter_Should_Return_The_Same_Solved_Sudoku(self):
initialGrid = {
"A1":'1', "A2":'2', "A3":'3', "A4":'4', "A5":'5', "A6":'6', "A7":'7', "A8":'8', "A9":'9',
"B1":'4', "B2":'5', "B3":'6', "B4":'7', "B5":'8', "B6":'9', "B7":'1', "B8":'2', "B9":'3',
"C1":'7', "C2":'8', "C3":'9', "C4":'1', "C5":'2', "C6":'3', "C7":'4', "C8":'5', "C9":'6',
"D1":'2', "D2":'3', "D3":'1', "D4":'6', "D5":'7', "D6":'4', "D7":'8', "D8":'9', "D9":'5',
"E1":'8', "E2":'7', "E3":'5', "E4":'9', "E5":'1', "E6":'2', "E7":'3', "E8":'6', "E9":'4',
"F1":'6', "F2":'9', "F3":'4', "F4":'5', "F5":'3', "F6":'8', "F7":'2', "F8":'1', "F9":'7',
"G1":'3', "G2":'1', "G3":'7', "G4":'2', "G5":'6', "G6":'5', "G7":'9', "G8":'4', "G9":'8',
"H1":'5', "H2":'4', "H3":'2', "H4":'8', "H5":'9', "H6":'7', "H7":'6', "H8":'3', "H9":'1',
"I1":'9', "I2":'6', "I3":'8', "I4":'3', "I5":'4', "I6":'1', "I7":'5', "I8":'7', "I9":'2'
}
expectedGrid = {
"A1":'1', "A2":'2', "A3":'3', "A4":'4', "A5":'5', "A6":'6', "A7":'7', "A8":'8', "A9":'9',
"B1":'4', "B2":'5', "B3":'6', "B4":'7', "B5":'8', "B6":'9', "B7":'1', "B8":'2', "B9":'3',
"C1":'7', "C2":'8', "C3":'9', "C4":'1', "C5":'2', "C6":'3', "C7":'4', "C8":'5', "C9":'6',
"D1":'2', "D2":'3', "D3":'1', "D4":'6', "D5":'7', "D6":'4', "D7":'8', "D8":'9', "D9":'5',
"E1":'8', "E2":'7', "E3":'5', "E4":'9', "E5":'1', "E6":'2', "E7":'3', "E8":'6', "E9":'4',
"F1":'6', "F2":'9', "F3":'4', "F4":'5', "F5":'3', "F6":'8', "F7":'2', "F8":'1', "F9":'7',
"G1":'3', "G2":'1', "G3":'7', "G4":'2', "G5":'6', "G6":'5', "G7":'9', "G8":'4', "G9":'8',
"H1":'5', "H2":'4', "H3":'2', "H4":'8', "H5":'9', "H6":'7', "H7":'6', "H8":'3', "H9":'1',
"I1":'9', "I2":'6', "I3":'8', "I4":'3', "I5":'4', "I6":'1', "I7":'5', "I8":'7', "I9":'2'
}
solution = self.solver.solve(initialGrid)
self.assertEqual(expectedGrid, solution)
def test_Given_A_Invalid_Solved_Sudoku_Then_Alg_Of_Peter_Should_Return_False_Solved_Sudoku(self):
initialGrid = {
"A1":'1', "A2":'2', "A3":'3', "A4":'4', "A5":'5', "A6":'6', "A7":'7', "A8":'8', "A9":'8',
"B1":'4', "B2":'5', "B3":'6', "B4":'7', "B5":'8', "B6":'9', "B7":'1', "B8":'2', "B9":'3',
"C1":'7', "C2":'8', "C3":'9', "C4":'1', "C5":'2', "C6":'3', "C7":'4', "C8":'5', "C9":'6',
"D1":'2', "D2":'3', "D3":'1', "D4":'6', "D5":'7', "D6":'4', "D7":'8', "D8":'9', "D9":'5',
"E1":'8', "E2":'7', "E3":'5', "E4":'9', "E5":'1', "E6":'2', "E7":'3', "E8":'6', "E9":'4',
"F1":'6', "F2":'9', "F3":'4', "F4":'5', "F5":'3', "F6":'8', "F7":'2', "F8":'1', "F9":'7',
"G1":'3', "G2":'1', "G3":'7', "G4":'2', "G5":'6', "G6":'5', "G7":'9', "G8":'4', "G9":'8',
"H1":'5', "H2":'4', "H3":'2', "H4":'8', "H5":'9', "H6":'7', "H7":'6', "H8":'3', "H9":'1',
"I1":'9', "I2":'6', "I3":'8', "I4":'3', "I5":'4', "I6":'1', "I7":'5', "I8":'7', "I9":'2'
}
try:
self.solver.solve(initialGrid)
self.fail("Did't raise expected InvalidSudokuException")
except InvalidSudokuException:
pass
def test_if_a_secuence_is_clean_then_some_funtion_should_return_false(self):
seq = []
value = self.solver.some(seq)
self.assertFalse(value)
def test_give_a_eliminate_value_then_should_return_false(self):
values = {
"A1":'12', "A2":'12', "A3":'7', "A4":'8', "A5":'4', "A6":'5', "A7":'9', "A8":'3', "A9":'2',
"B1":'9', "B2":'2', "B3":'8', "B4":'7', "B5":'3', "B6":'6', "B7":'4', "B8":'5', "B9":'1',
"C1":'4', "C2":'3', "C3":'5', "C4":'2', "C5":'1', "C6":'9', "C7":'7', "C8":'8', "C9":'6',
"D1":'6', "D2":'4', "D3":'9', "D4":'3', "D5":'8', "D6":'2', "D7":'1', "D8":'7', "D9":'5',
"E1":'7', "E2":'5', "E3":'1', "E4":'9', "E5":'6', "E6":'4', "E7":'3', "E8":'2', "E9":'8',
"F1":'2', "F2":'8', "F3":'3', "F4":'5', "F5":'7', "F6":'1', "F7":'6', "F8":'4', "F9":'9',
"G1":'5', "G2":'7', "G3":'4', "G4":'1', "G5":'9', "G6":'8', "G7":'2', "G8":'6', "G9":'3',
"H1":'3', "H2":'9', "H3":'2', "H4":'6', "H5":'5', "H6":'7', "H7":'8', "H8":'1', "H9":'4',
"I1":'8', "I2":'1', "I3":'6', "I4":'4', "I5":'2', "I6":'3', "I7":'5', "I8":'9', "I9":'7'
}
value = self.solver.eliminate(values, "A1", "2")
self.assertFalse(value)
def test_give_a_eliminate_value_then_should_return_false_if_does_not_be_assigned_in_one_unit(self):
values = {
"A1":'18', "A2":'0', "A3":'0', "A4":'0', "A5":'0', "A6":'0', "A7":'0', "A8":'0', "A9":'0',
"B1":'12', "B2":'0', "B3":'0', "B4":'0', "B5":'0', "B6":'0', "B7":'0', "B8":'0', "B9":'0',
"C1":'23', "C2":'0', "C3":'0', "C4":'0', "C5":'0', "C6":'0', "C7":'0', "C8":'0', "C9":'0',
"D1":'34', "D2":'0', "D3":'0', "D4":'0', "D5":'0', "D6":'0', "D7":'0', "D8":'0', "D9":'0',
"E1":'45', "E2":'0', "E3":'0', "E4":'0', "E5":'0', "E6":'0', "E7":'0', "E8":'0', "E9":'0',
"F1":'56', "F2":'0', "F3":'0', "F4":'0', "F5":'0', "F6":'0', "F7":'0', "F8":'0', "F9":'0',
"G1":'79', "G2":'0', "G3":'0', "G4":'0', "G5":'0', "G6":'0', "G7":'0', "G8":'0', "G9":'0',
"H1":'39', "H2":'0', "H3":'0', "H4":'0', "H5":'0', "H6":'0', "H7":'0', "H8":'0', "H9":'0',
"I1":'72', "I2":'0', "I3":'0', "I4":'0', "I5":'0', "I6":'0', "I7":'0', "I8":'0', "I9":'0'
}
value = self.solver.eliminate(values, "A1", "8")
self.assertFalse(value)
def test_give_a_eliminate_value_then_should_return_false_if_assigned_eliminated_value_founds_contradiction(self):
values = {
"A1":'18', "A2":'0', "A3":'0', "A4":'0', "A5":'0', "A6":'0', "A7":'0', "A8":'0', "A9":'0',
"B1":'12', "B2":'0', "B3":'0', "B4":'0', "B5":'0', "B6":'0', "B7":'0', "B8":'0', "B9":'0',
"C1":'23', "C2":'0', "C3":'0', "C4":'0', "C5":'0', "C6":'0', "C7":'0', "C8":'0', "C9":'0',
"D1":'34', "D2":'0', "D3":'0', "D4":'0', "D5":'0', "D6":'0', "D7":'0', "D8":'0', "D9":'0',
"E1":'45', "E2":'0', "E3":'0', "E4":'0', "E5":'0', "E6":'0', "E7":'0', "E8":'0', "E9":'0',
"F1":'56', "F2":'0', "F3":'0', "F4":'0', "F5":'0', "F6":'0', "F7":'0', "F8":'0', "F9":'0',
"G1":'79', "G2":'0', "G3":'0', "G4":'0', "G5":'0', "G6":'0', "G7":'0', "G8":'0', "G9":'0',
"H1":'398', "H2":'8', "H3":'0', "H4":'0', "H5":'0', "H6":'0', "H7":'0', "H8":'0', "H9":'0',
"I1":'72', "I2":'0', "I3":'0', "I4":'0', "I5":'0', "I6":'0', "I7":'0', "I8":'0', "I9":'0'
}
value = self.solver.eliminate(values, "A1", "8")
self.assertFalse(value)
def setUp(self):
self.solver = PeterNorvigAlgorithm()
