def test_equality():
s = Sudoku.load_file(os.path.join(_test_dir, 'hard_sol.sud'))
s2 = Sudoku.load_file(os.path.join(_test_dir, 'medium_sol.sud'))
s3 = Sudoku.load_file(os.path.join(_test_dir, 'hard_sol.sud'))
assert s != s2
assert s == s3
assert s != 5
def test_to_oneliner_method():
s = Sudoku.load_file(os.path.join(_test_dir, 'hard.sud'))
s.solve(verbose=True)
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'hard_sol.sud'))
assert s == correct_solution
oneliner = s.to_oneliner()
oneliner_parsed = Sudoku(oneliner)
assert oneliner_parsed == correct_solution
def solve(unsolved_sudoku):
# https://github.com/hbldh/dlxsudoku
from dlxsudoku import Sudoku
from dlxsudoku.exceptions import SudokuHasMultipleSolutionsError, SudokuHasNoSolutionError, SudokuTooDifficultError
s = table_to_string(unsolved_sudoku)
try:
sudoku = Sudoku(s)
sudoku.solve()
except SudokuHasNoSolutionError as e:
print(e)
return unsolved_sudoku
pass
except SudokuHasMultipleSolutionsError as e:
print(e)
return unsolved_sudoku
pass
except SudokuTooDifficultError as e:
print(e)
return unsolved_sudoku
else:
return string_to_table(sudoku.to_oneliner())
def test_README_code():
sudoku_string_1 = "030467050920010006067300148301006027400850600090200400005624001203000504040030702"
sudoku_string_2 = "# Example Sudoku\n" + \
"*72****6*\n" + \
"***72*9*4\n" + \
"*9*1****2\n" + \
"*******4*\n" + \
"82*4*71**\n" + \
"**9*6*8**\n" + \
"***9**6**\n" + \
"**3*72*9*\n" + \
"*6*843*7*"
s1 = Sudoku(sudoku_string_1)
s1.solve()
assert s1.is_solved
s2 = Sudoku(sudoku_string_2)
s2.solve()
assert s2.is_solved
from dlxsudoku import Sudoku
f = open('sudoku.txt', 'r')
ret = 0
for l in f:
s = Sudoku(l)
s.solve()
s = s.to_oneliner()
ret += int(s[0:3])
print ret
def AttemptSudokuSolve(InputQueue, ProcessedDigits, FinalImage):
loaded_model = joblib.load('finalized_sudoku_model.sav')
from dlxsudoku import Sudoku
font = cv2.FONT_HERSHEY_SIMPLEX
result_old = np.zeros(81)
result_really_old = result_old
result = np.zeros(81)
while True:
gray = InputQueue.get()
img, cropped, digits = cw.extract_sudoku(gray)
boardFound = 1
result_really_really_old = result_really_old
result_really_old = result_old
result_old = result
sleep(0.05)
ProcessedDigits.put(img)
result = loaded_model.predict(digits)
resultList = (result_old, result_really_old, result_really_really_old)
for resul in resultList:
for i in result:
if result[i] == 10:
if resul[i] != 10:
#print('correction2')
print(
str(result[i]) + " changed to " +
str(int(resul[i])))
result[i] = int(resul[i])
temp = 0
for i in result:
if i == 10:
temp = temp + 1
result[i] = 0
if temp >= 6:
continue
res = ""
grid = np.zeros((9, 9), dtype='int')
grid = result.reshape(9, 9)
#Getting the set of numbers within a number's group------------------------------------
for re in result:
if re == 10:
boardFound = 0
break
else:
res += str(re)
if boardFound == 1:
#print(res)
try:
#start = time.time()
s1 = Sudoku(res)
s1.solve(verbose=False, allow_brute_force=True)
#print("YAY!")
stringlist = s1.to_oneliner()
charlist = list(stringlist)
results = list(map(int, charlist))
#print(results)
y = cropped.shape[0]
cell_Spacing = y // 9
posx = cell_Spacing // 2 - 4
posy = cell_Spacing // 2 + 6
for i in range(81):
if results[i] != result[i]:
cropped = cv2.putText(cropped, charlist[i],
(posx, posy), font, 0.6,
(0, 0, 255), 2, cv2.LINE_AA)
if posx + cell_Spacing >= y:
posy = posy + cell_Spacing
posx = cell_Spacing // 2 - 4
else:
posx = posx + cell_Spacing
FinalImage.put(cropped)
except:
pass
#print("too many solutions")
else:
pass
def test_solve_multiple_solutions():
with pytest.raises(SudokuHasMultipleSolutionsError):
s = Sudoku("***4*******9*******3**7*******7*********5*32*4**86***55*3****8*7983**4****6**9***")
s.solve(verbose=True, allow_brute_force=True)
def test_solve_very_hard_sudoku_with_brute_force():
s = Sudoku.load_file(os.path.join(_test_dir, 'very_hard.sud'))
s.solve(verbose=True, allow_brute_force=True)
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'very_hard_sol.sud'))
assert s == correct_solution
assert 'BRUTE FORCE' in "".join(s.solution_steps)
def test_solve_very_hard_sudoku_raises_error_if_brute_force_disallowed():
s = Sudoku.load_file(os.path.join(_test_dir, 'very_hard.sud'))
with pytest.raises(SudokuTooDifficultError):
s.solve(verbose=True, allow_brute_force=False)
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'very_hard_sol.sud'))
assert s != correct_solution
def test_solve_hard_sudoku():
s = Sudoku.load_file(os.path.join(_test_dir, 'hard.sud'))
s.solve(verbose=True)
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'hard_sol.sud'))
assert s == correct_solution
def test_solve_medium_sudoku():
s = Sudoku.load_file(os.path.join(_test_dir, 'medium.sud'))
s.solve()
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'medium_sol.sud'))
assert s == correct_solution
def test_solve_simple_sudoku_read_from_flat_file():
s = Sudoku.load_file(os.path.join(_test_dir, 'simple_flat.sud'))
s.solve()
correct_solution = Sudoku.load_file(os.path.join(_test_dir, 'simple_sol.sud'))
assert s == correct_solution
def test_project_euler_sudokus(sudoku):
sudoku[0] = b"# " + sudoku[0]
s = Sudoku("".join([i.decode("utf-8") for i in sudoku]).strip())
s.solve()
assert s.is_solved
def test_str_repr():
s = Sudoku.load_file(os.path.join(_test_dir, 'hard_sol.sud'))
assert str(s) == repr(s)
def test_raises_error_when_input_is_invalid():
with pytest.raises(SudokuHasNoSolutionError):
s = Sudoku("***4*******9***5***3**7***2***7*********5*32*4**86***55*3****8*7983**4*2**6**9***")
s.solve(verbose=True, allow_brute_force=True)
def test_raises_error_when_unsolvable_2():
with pytest.raises(SudokuHasNoSolutionError):
s = Sudoku.load_file(os.path.join(_test_dir, 'hard.sud'))
s._matrix[2][7] = 6
s.solve()
