def test_it_solves_correctly_for_other_sizes(self):
problem = [[0, 1, 0, 0], [4, 0, 0, 3], [1, 0, 0, 2], [0, 0, 3, 0]]
expected_solution = [[3, 1, 2, 4], [4, 2, 1, 3], [1, 3, 4, 2],
[2, 4, 3, 1]]
solver = Solver(problem)
solution = solver.solve()
self.assertEqual(solution, expected_solution)
def _loop(stdscr, puzzle, slow):
Display.draw_screen(stdscr)
try:
solver = Solver(puzzle, slow)
Display.prompt("press any key to continue")
solver.backtrack()
Display.prompt("%d iterations, press any key to exit" %
solver.iteration)
finally:
Display.close_screen()
def _loop(stdscr, puzzle, slow):
Display.draw_screen(stdscr)
try:
solver = Solver(puzzle, slow)
Display.prompt("press any key to continue")
solver.backtrack()
Display.prompt("%d iterations, press any key to exit"
% solver.iteration)
finally:
Display.close_screen()
def test_it_calls_all_the_strategies(self, mocker):
mocker.patch('sudoku.strategies.RowStrategy.execute')
mocker.patch('sudoku.strategies.ColumnStrategy.execute')
mocker.patch('sudoku.strategies.SectionStrategy.execute')
grid = Grid([[1, 2, 3, 4], [None, 3, 4, 1], [3, 4, None, 2],
[4, 1, 2, 3]])
solver = Solver(grid)
solver.solve()
RowStrategy.execute.assert_called()
ColumnStrategy.execute.assert_called()
SectionStrategy.execute.assert_called()
def test_it_does_not_alter_the_problem(self):
problem = [[0, 9, 0, 0, 0, 0, 0, 0, 6], [0, 0, 0, 9, 6, 0, 4, 8, 5],
[0, 0, 0, 5, 8, 1, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0],
[5, 1, 7, 2, 0, 0, 9, 0, 0], [6, 0, 2, 0, 0, 0, 3, 7, 0],
[1, 0, 0, 8, 0, 4, 0, 2, 0], [7, 0, 6, 0, 0, 0, 8, 1, 0],
[3, 0, 0, 0, 9, 0, 0, 0, 0]]
original_problem = copy.deepcopy(problem)
solver = Solver(problem)
solver.solve()
self.assertEqual(problem, original_problem)
def solve(self, model_dir='./model/'):
"""
Get processed sudoku grid and solved it.
Args:
model_dir --> Directory that contains the trained model (ckpt files) \
to recognise the digits.
"""
assert self._is_loaded, "Coudn\'t find sudoku image!"
edge = self._preprocess_img(self.img)
edgec, cnts = self._get_blob(edge)
corners = self._find_corners(cnts)
warped = self._crop_and_warp(self.img, corners)
squares = self._infer_grid(warped)
cells = self._get_digits(warped, squares, 28)
digits = {}
for i, digit in enumerate(cells):
if np.max(digit) == 0:
digits[i] = (digit, None)
else:
digits[i] = (digit, not None)
digits_v2 = []
for i in range(81):
if digits[i][1]:
digits_v2.append(digits[i][0])
predictions = predict(digits_v2, model_dir=model_dir)
predictions = predictions.tolist()
grid = []
for i in range(81):
if digits[i][1] is None:
grid.append(0)
else:
grid.append(predictions.pop(0))
# reshape grid to 9x9
grid = np.asarray(grid).reshape(9, 9).tolist()
try:
Solver.load_sudoku(self, grid)
solved = Solver.solve(self)
return solved
except:
print('Sudoku could not be solved!')
return
def test_returns_false_for_unsolvable_problems(self):
unsolvable_problem = [[1, 0, 2, 3, 4, 5, 6, 7, 8],
[0, 9, 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, 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, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0]]
solver = Solver(unsolvable_problem)
solution = solver.solve()
self.assertEqual(solution, None)
def index(request):
if request.GET:
valid = True
values = dict()
for l in "012345678":
for n in "012345678":
if l + n not in request.GET:
valid = False
else:
if len(request.GET[l + n]) > 1:
valid = False
elif len(request.GET[l + n]) == 1:
if request.GET[l + n] not in "012345678":
valid = False
else:
values[l + n] = request.GET[l + n]
if valid:
values = Solver(values).values
if values:
return render(request, 'index.html', {'values': values})
return redirect('index')
else:
return render(request, 'index.html')
def test_it_solves_correctly(self):
problem = [[0, 9, 0, 0, 0, 0, 0, 0, 6], [0, 0, 0, 9, 6, 0, 4, 8, 5],
[0, 0, 0, 5, 8, 1, 0, 0, 0], [0, 0, 4, 0, 0, 0, 0, 0, 0],
[5, 1, 7, 2, 0, 0, 9, 0, 0], [6, 0, 2, 0, 0, 0, 3, 7, 0],
[1, 0, 0, 8, 0, 4, 0, 2, 0], [7, 0, 6, 0, 0, 0, 8, 1, 0],
[3, 0, 0, 0, 9, 0, 0, 0, 0]]
expected_solution = [[8, 9, 5, 7, 4, 2, 1, 3, 6],
[2, 7, 1, 9, 6, 3, 4, 8, 5],
[4, 6, 3, 5, 8, 1, 7, 9, 2],
[9, 3, 4, 6, 1, 7, 2, 5, 8],
[5, 1, 7, 2, 3, 8, 9, 6, 4],
[6, 8, 2, 4, 5, 9, 3, 7, 1],
[1, 5, 9, 8, 7, 4, 6, 2, 3],
[7, 4, 6, 3, 2, 5, 8, 1, 9],
[3, 2, 8, 1, 9, 6, 5, 4, 7]]
solver = Solver(problem)
solution = solver.solve()
self.assertEqual(solution, expected_solution)
def test_invalid(self):
print "------"
board = Board(readSudokuFile("test-input/test-invalid1.txt"))
print "Board:"
print board
print "Checking for: ", repr(board[(0,6)]), "$"
res = Solver.getAffectedFilledCells(board,board[(0,6)])
print "Final:", repr(res)
if len(set(res)) != len(res):
raise InvalidSudokuStateError("Cell @" + repr(cell))
print "-------"
#No asserts, stdout check
def test_it_can_solve_a_sudoku(self):
grid = Grid([[7, 2, None, None, 5, 4, 3, None, None],
[None, None, 9, None, None, None, None, 5, None],
[None, 5, None, 1, 7, None, 2, None, 8],
[None, 6, 2, 4, None, None, 8, None, 9],
[None, None, None, 7, None, 9, 4, None, None],
[None, 9, None, None, None, 5, 6, None, 3],
[None, 7, None, 8, None, 2, None, None, None],
[2, 4, None, None, None, 6, 9, 8, None],
[1, 8, None, 3, None, None, 5, None, None]])
solver = Solver(grid)
solver.solve()
assert grid == Grid([[7, 2, 8, 9, 5, 4, 3, 6, 1],
[3, 1, 9, 6, 2, 8, 7, 5, 4],
[6, 5, 4, 1, 7, 3, 2, 9, 8],
[5, 6, 2, 4, 3, 1, 8, 7, 9],
[8, 3, 1, 7, 6, 9, 4, 2, 5],
[4, 9, 7, 2, 8, 5, 6, 1, 3],
[9, 7, 5, 8, 4, 2, 1, 3, 6],
[2, 4, 3, 5, 1, 6, 9, 8, 7],
[1, 8, 6, 3, 9, 7, 5, 4, 2]])
def main():
board = Board(readSudokuFile('input.txt'))
solver = Solver(board)
solver.solve()
#print "Final --"
#print repr(board)
print "-----"
solver.solve()
print board
def benchmark(filename):
problems = from_file(filename)
durations = []
for problem in problems:
start = time.time()
Solver(problem).solve()
finish = time.time()
durations.append(finish - start)
sys.stdout.write('.')
sys.stdout.flush()
print()
return durations
def test_value1(self):
board = Board(readSudokuFile("test-input/test-input.txt"))
print repr(Solver.getAffectedCells(board, board[(7,1)]))