def testvals():
indices_seq = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
values = indices_seq
rows = indices_seq
columns = indices_seq
result = ""
liste = ""
if request.method == 'POST':
result = request.form
for i in rows:
for j in columns:
cell = "cell_" + i + j
liste += result[cell] + " " + "\n"
erg = solve_sudoku(result)
print(erg)
fieldString = ""
for i in range(9):
fieldString += "<tr>\n"
for j in range(9):
fieldString += "<td><input type=\"number\" value=\"" + erg[i][
j] + " \" name=\"cell_" + str(i) + str(
j) + "\">" + erg[i][j] + "</td>\n"
fieldString += "\n</tr>"
print(fieldString)
return render_template('sudoku.html', fields=fieldString)
def sudoku():
board = request.json.get("board")
converted_board = convert_board(board)
solved_board = solve_sudoku(converted_board)
return jsonify({
"board": solved_board
})
def get_sudoku(self):
sudoku = []
linha = []
num = 0
while num < 81:
self.data[num].config({"background": "White"})
linha.append(self.data[num].get())
if self.data[num].get() == '':
self.soluction_cel.append(num)
num += 1
if not num % 9 and num:
sudoku.append(linha)
linha = []
result, solucao = solve_sudoku(sudoku)
if result == 0:
self.warning['text'] = "Solution:"
idx = 0
for lin in solucao:
for col in lin:
if self.data[idx].get() == '':
self.data[idx].insert(0, str(col))
else:
self.data[idx].config(fg='green')
idx += 1
if result == 1:
self.warning['text'] = "Mutiple solutions, exemple:"
idx = 0
for lin in solucao:
for col in lin:
if self.data[idx].get() == '':
self.data[idx].insert(0, str(col))
else:
self.data[idx].config(fg='green')
idx += 1
elif result == 2:
self.warning['text'] = "Sudoku not resovable"
elif result == 3:
self.warning['text'] = "Too litle data in the Sudoku"
elif result == 4:
self.warning['text'] = 'Conflicts in the Sudoku'
for cel in solucao:
loc = (cel[0] * 9) + cel[1]
self.data[loc].config({"background": "Red"})
def post(self):
sudoku_input = ''
for i in range(0, 9):
line = ''
for j in range(0, 9):
val = self.get_argument(str(i) + str(j), '')
if val == '':
val = '0'
line += val + ' '
sudoku_input += line[:-1] + '\n'
#board = sudoku.solve_sudoku(sudoku_input)
board = sudoku.solve_sudoku("")
message = ' '.join(str(item) for innerlist in board for item in innerlist)
self.write(message)
def solve_puzzle(self):
screenshot = self.screenshot(wait=2)
img_fields = recognize_puzzle(screenshot)
print('Puzzle:\n', [i.number for i in img_fields])
solved_puzzle = solve_sudoku([i.number for i in img_fields])
print('Solution:\n', solved_puzzle)
last_x, last_y = 0, 0
for i in img_fields:
if i.number:
continue
print(i)
self.click_by_position(i.x_center - last_x, i.y_center - last_y,
solved_puzzle[i.index])
last_x = i.x_center
last_y = i.y_center
def test_solve_sudoku(self):
matrix = [[1,0,0,0],
[0,0,0,4],
[0,0,2,0],
[0,3,0,0]]
target = [[1,4,3,2],
[3,2,1,4],
[4,1,2,3],
[2,3,4,1]]
bqm = build_bqm(matrix)
result = solve_sudoku(bqm, matrix)
self.assertEqual(result, target)
def get_sudoku(sudoku_image):
"""this method gets the answer for the sudoku"""
method_return = detect_sudoku(sudoku_image)
"""digits : grids of numbers present in the image, matrix is predicted numbers"""
matrix, digits, cropped = method_return # cropped sudoku with changed and warped perspective
# show_image(digits)
print("matrix")
matrix = matrix.tolist()
answer = []
count = 0
"""sudoku.py called here to solve the sudoku"""
for solution in sudoku.solve_sudoku((3, 3), matrix):
if count > 10:
break
count = count + 1
answer.append([*solution])
answer = np.array(answer)
answer = answer.reshape(9, 9)
return answer.flatten(), digits, cropped
def test_get_random_sudoku(self):
sud=get_random_sudoku()
self.check(sud)
print("Random:")
self.print_sud(sud)
print()
remove=20
sud=get_random_sudoku(remove)
count=0
for row in range(9):
for col in range(9):
count+=1 if sud[row][col] is None else 0
self.assertEqual(remove,count)
print("Random remove")
self.print_sud(sud)
print()
solved=solve_sudoku(sud)
self.check(solved)
print("Random remove solved")
self.print_sud(sud)
print()
def test_get_random_sudoku(self):
sud = get_random_sudoku()
self.check(sud)
print("Random:")
self.print_sud(sud)
print()
remove = 20
sud = get_random_sudoku(remove)
count = 0
for row in range(9):
for col in range(9):
count += 1 if sud[row][col] is None else 0
self.assertEqual(remove, count)
print("Random remove")
self.print_sud(sud)
print()
solved = solve_sudoku(sud)
self.check(solved)
print("Random remove solved")
self.print_sud(sud)
print()
else:
row.append(0)
bar.next()
grid.append(row)
return grid
# Input the solved sudoku into the game
def automate_game(org_grid, solved_grid):
for i in range(9):
for j in range(9):
if org_grid[i][j] == 0: # If the box was blank in the game
x1, y1, x2, y2 = get_coords(i, j)
center = (x1 + (x2 - x1)/2, y1 + (y2-y1)/2) # Calculating the center of the box (to select it)
solution = solved_grid[i][j]
device.shell(
f'input touchscreen swipe {center[0]} {center[1]} {center[0]} {center[1]} 5')
device.shell(f'input text {solution}')
if __name__ == "__main__":
# Connect the device using ADB
device = adb.connect_device()
# Take Screenshot of the screen and save it in screen.png
adb.take_screenshot(device)
image = Image.open('screen.png')
image = process_image(image) # Process the image for OCR
org_grid = get_grid_from_image(image) # Convert the Image to 2D list using OCR / Pytesseract
solved_grid = deepcopy(org_grid) # Deepcopy is used to prevent the function from modifying the original sudoku game
solve_sudoku(solved_grid)
automate_game(org_grid, solved_grid) # Input the solved game into your device
import sudoku
TestMatrix = ((0, 8, 0, 0, 5, 0, 2, 0, 0),
(0, 0, 0, 7, 0, 0, 0, 9, 0),
(0, 3, 0, 0, 0, 2, 0, 0, 0),
(0, 7, 2, 3, 0, 6, 1, 0, 0),
(0, 0, 0, 0, 0, 5, 0, 2, 0),
(5, 0, 3, 0, 1, 0, 8, 0, 0),
(0, 0, 0, 0, 0, 0, 0, 1, 0),
(9, 0, 0, 0, 4, 8, 0, 0, 7),
(0, 0, 0, 9, 2, 0, 4, 0, 0))
print('Manually enter testset, PRESS 1')
print('Use sample testset, PRESS 2\n')
choice = input('Enter choice: ')
print()
if choice is '1':
testset = sudoku.input_testset()
elif choice is '2':
testset = TestMatrix
sudoku.solve_sudoku(testset, 'row')
def test_find_solution(self):
for k in TEST_KEYS:
self.assertEqual(sudoku.solve_sudoku(sudoku_problems[k]),
sudoku_solutions[k])
def test_sudoku(constraints):
try:
status, solution = solve_sudoku(constraints)
return "PASS" if status == 'Optimal' else "FAIL"
except:
return "FAIL"
def solve_sudoku(dict_values_readed):
dict_values_solved = dict(dict_values_readed)
return sudoku.solve_sudoku(dict_values_solved)
def test_solve_sudoku(simple_sudoku, simple_sudoku_solved):
assert sudoku.solve_sudoku(simple_sudoku)
assert simple_sudoku == simple_sudoku_solved
def test_find_solution(self):
print '\n'
for k in TEST_KEYS:
print 'Solving', k
self.assertEqual(sudoku.solve_sudoku(sudoku_problems[k]),
sudoku_solutions[k])
num_img = cv2.dilate(erode,kernel,iterations =1)
image = num_img.reshape((1,784)).astype(np.float32)
num = clf.predict(image)
grid[i][j] = num[0]
sudstr = ''.join(str(i) for i in grid.flatten())
return sudstr
def save_sol(sud_sol,sudstr,warp,solfile):
for i in range(81):
if sudstr[i] == '0':
x = (i%9)*50 + 17
y = int(i/9)*50 + 40
cv2.putText(warp, sud_sol[i], (x, y), cv2.FONT_HERSHEY_SIMPLEX, 1, (181, 2, 1), 2)
cv2.imwrite(solfile,warp)
if __name__ == '__main__':
trainfile = r'data/train.data'
labelfile = r'data/label.data'
testfile = r'data/test/test3.jpg'
solfile = r'output/t3_ans.jpg'
clf = get_clf(trainfile,labelfile)
warp = get_roi(testfile)
if warp is not None:
sudstr = process_and_get_sud(clf,warp)
sud_sol = sudoku.solve_sudoku(sudstr)
save_sol(sud_sol,sudstr,warp,solfile)
else:
print('Failed to find Puzzle!')
def test_find_solution(self):
print '\n'
for k in TEST_KEYS:
print 'Solving', k
self.assertEqual(sudoku.solve_sudoku(sudoku_problems[k]),
sudoku_solutions[k])
def test_find_solution():
for k in TEST_KEYS:
print('Solving', k)
assert sudoku.solve_sudoku(sudoku_problems[k]) == sudoku_solutions[k]
def test_find_solution():
for k in TEST_KEYS:
print("Solving", k)
assert sudoku.solve_sudoku(sudoku_problems[k]) == sudoku_solutions[k]
