def gen_sudoku(num_cells=60):
board = [[0] * 9 for i in range(9)]
fill_diagonal(board)
fill_rest(board)
remove_cells(board, 81 - num_cells)
solver.print_board(board)
return board
def solve(self):
solver(self.board)
print_board(self.board)
self.cubes = [[
Cube(self.board[i][j], i, j, self.width, self.height)
for j in range(self.cols)
] for i in range(self.rows)]
def main():
#set a title
pygame.display.set_caption("Sudoku Solver")
# create a display that is square of a set size
screenSize = 450
squareSize = screenSize//9
screen = pygame.display.set_mode((screenSize,screenSize))
#Create the sudoku squares, and orgainse them into a 2D array
#This 2D array is addressed by y first, then x !!!
sudokuSquares = list()
for y in range(9):
sudokuSquares.append([])
for x in range(9):
sudokuSquares[y].append(SudokuSquare(x*squareSize, y*squareSize, squareSize, screen))
#Create the lines we need to seperate the squares
#Lines have form of (startPos, endPos, width)
LINE_COLOR = pygame.Color(0,0,0)
lines = list()
for x in range(1,9):
lines.append(((x*squareSize, 0), (x*squareSize, screenSize), 1 if x%3 else 3))
for y in range(1,9):
lines.append(((0, y*squareSize), (screenSize, y*squareSize), 1 if y%3 else 3))
# main loop
running = True
while running:
# event handling, gets all event from the event queue
for event in pygame.event.get():
#If exit button is clicked, exit the game
if event.type == pygame.QUIT:
running=False
#Give the event to the squares
for y in range(9):
for x in range(9):
sudokuSquares[y][x].handle_event(event)
#Redraw the lines
for line in lines:
pygame.draw.line(screen, LINE_COLOR, line[0], line[1], line[2])
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
values = list()
for y in range(9):
values.append([])
for x in range(9):
values[y].append(sudokuSquares[y][x].get_digit())
solver.print_board(values)
if event.key == pygame.K_s:
solve_board(sudokuSquares)
if event.key == pygame.K_c:
for y in range(9):
for x in range(9):
sudokuSquares[y][x].clear_digit()
pygame.display.update()
def main(board_to_solve):
initial_time = time()
print("Question:")
print_board(board_to_solve)
solve(board_to_solve)
print()
print("Solution:")
print_board(board_to_solve)
print()
final_time = time()
print(f'Time taken: {round(final_time - initial_time, 3)} s')
from solver import steps
print(f'Steps taken: {steps}')
print()
def main():
saved_puzzle = list()
puzzle, complete = generate()
saved_puzzle = complete = [x[:] for x in puzzle]
print('\n this is saved puzzle\n ')
print(saved_puzzle)
print('\n this is complete puzzle\n')
print(complete)
result = solver.solve(puzzle)
attempt = 0
while complete != result:
puzzle, complete = generate()
saved_puzzle = complete = [x[:] for x in puzzle]
solver.print_board(puzzle)
result = solver.solve(puzzle)
attempt += 1
print(attempt)
print('\n This is the solved puzzle: \n')
solver.print_board(saved_puzzle)
print()
return saved_puzzle
def main():
boards = {'1': board_1, '2': board_2, '3': board_3}
user = input("What is your name: ")
diff = input(f"Hello {user}\n"
"3 Boards are available\n"
"Board 1, 2 or 3\n"
"Please choose a board to solve (No. Only): ")
board = boards[diff]
print_board(board)
choice = input("Would you like to solve it yourself?\n"
"Please type yes or no: ")
if choice == 'yes':
print("good luck")
exit(0)
elif choice == 'no':
solve(board)
print_board(board)
else:
print("Invalid choice. Exiting...")
exit(0)
import solver
bo_1 = [[2, 0, 4, 0, 0, 0, 0, 6, 7], [3, 0, 0, 4, 7, 0, 0, 0, 5],
[1, 5, 0, 8, 2, 0, 0, 0, 3], [0, 0, 6, 0, 0, 0, 0, 3, 1],
[8, 0, 2, 1, 0, 5, 6, 0, 4], [4, 1, 0, 0, 0, 0, 9, 0, 0],
[7, 0, 0, 0, 8, 0, 0, 4, 6], [6, 0, 0, 0, 1, 2, 0, 0, 0],
[9, 3, 0, 0, 0, 0, 7, 1, 0]]
bo = [[3, 8, 0, 4, 0, 0, 1, 2, 0], [6, 0, 0, 0, 7, 5, 0, 0, 9],
[0, 0, 0, 6, 0, 1, 0, 7, 8], [0, 0, 7, 0, 4, 0, 2, 6, 0],
[0, 0, 1, 0, 5, 0, 9, 3, 0], [9, 0, 4, 0, 6, 0, 0, 0, 5],
[0, 7, 0, 3, 0, 0, 0, 1, 2], [1, 2, 0, 0, 0, 7, 4, 0, 0],
[0, 4, 9, 2, 0, 6, 0, 0, 7]]
solver.solve(bo_1)
solver.print_board(bo_1)
# randomly removes/resets value of cells
x = 81
while x > nums:
row = random.randint(0, 8)
col = random.randint(0, 8)
# only remove if not empty
if not bo[row][col] == 0:
bo[row][col] = 0
x -= 1
# generates random values in a diagonal pattern vs random
def generate2(bo):
col = 0
row = 0
while col < 9:
val = random.randint(1, 9)
if bo[row][col] == 0 and valid(bo, val, (row, col)):
bo[row][col] = val
col += 1
row += 1
print_board(board)
generate(board)
print()
print_board(board)
import solver
import pygame
import game
if __name__ == "__main__":
#theGame = Game()
#theGame.on_execute()
board = [
[3,0,1,0,0,4,0,5,0],
[4,0,7,0,0,0,6,9,0],
[0,9,0,0,3,0,0,7,1],
[0,2,8,0,1,0,9,0,7],
[0,0,0,2,0,7,0,0,0],
[1,0,6,0,5,0,2,4,0],
[7,5,0,0,6,0,0,2,0],
[0,1,3,0,0,0,5,0,9],
[0,4,0,5,0,0,7,0,6]
]
solver.print_board(board)
solver.solve(board)
print("")
print("")
solver.print_board(board)
def main():
win = pygame.display.set_mode((540, 600))
pygame.display.set_caption("Sudoku")
board = Grid(9, 9, 540, 540)
board_empty = Grid(9, 9, 540, 540)
key = None
run = True
start = time.time()
strikes = 0
while run:
play_time = round(time.time() - start)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
key = 1
if event.key == pygame.K_2:
key = 2
if event.key == pygame.K_3:
key = 3
if event.key == pygame.K_4:
key = 4
if event.key == pygame.K_5:
key = 5
if event.key == pygame.K_6:
key = 6
if event.key == pygame.K_7:
key = 7
if event.key == pygame.K_8:
key = 8
if event.key == pygame.K_9:
key = 9
if event.key == pygame.K_DELETE:
board.clear()
key = None
if event.key == pygame.K_SPACE:
start_time = time.time()
solve(board.board)
end_time = time.time()
time_lapsed = end_time - start_time
time_convert(time_lapsed)
board2 = Grid(9, 9, 540, 540)
board2.board = board.board
print_board(board2.board)
board = board2
redraw_window(win, board, play_time, strikes)
pygame.display.update()
if event.key == pygame.K_RETURN:
i, j = board.selected
if board.cubes[i][j].temp != 0:
if board.place(board.cubes[i][j].temp):
print("Success")
else:
print("Wrong")
strikes += 1
key = None
if board.is_finished():
print("Game over")
run = False
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
clicked = board.click(pos)
if clicked:
board.select(clicked[0], clicked[1])
key = None
if board.selected and key != None:
board.sketch(key)
redraw_window(win, board, play_time, strikes)
pygame.display.update()
key = None
if board.is_finished():
print("Game over, Have a nice day!")
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
clicked = list(board.click(pos))
if clicked:
board.select(clicked[0], clicked[1])
key = None
if board.selected and key != None:
board.sketch(key)
redraw_window(win, board, play_time, strikes)
pygame.display.update()
print("Question:")
print_board(sudoku)
print("")
main()
solve(sudoku)
print("")
print("Solution:")
print_board(sudoku)
print("")
pygame.quit()
import solver as solver solver = solver.solver() solver.find_solution() solver.print_board()
import solver
sample_board = [[5, 1, 7, 6, 0, 0, 0, 3, 4], [2, 8, 9, 0, 0, 4, 0, 0, 0], [3, 4, 6, 2, 0, 5, 0, 9, 0],
[6, 0, 2, 0, 0, 0, 0, 1, 0], [0, 3, 8, 0, 0, 6, 0, 4, 7], [0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 9, 0, 0, 0, 0, 0, 7, 8], [7, 0, 3, 4, 0, 0, 5, 6, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]
print("\nInitial Board")
solver.print_board(sample_board)
solver.solve(sample_board)
print("\n\nSolved Board")
solver.print_board(sample_board)
def slice_digits(img):
cv2.imshow('imagee', img)
puzzle = []
divisor = img.shape[0] // 9
for i in range(9):
row = []
for j in range(9):
# slice image, reshape it to 28x28 (mnist reader size)
row.append(cv2.resize(img[i * divisor:(i + 1) * divisor,
j * divisor:(j + 1) * divisor][3:-3, 3:-3],
dsize=(28, 28),
interpolation=cv2.INTER_CUBIC))
puzzle.append(row)
#cv2.imshow('imagee', puzzle[3][4])
#buraya kadar doğru puzzle arr'i
#model = tf.keras.models.Sequential()
""""
model.add(tf.keras.layers.Conv2D(254, kernel_size=(3, 3), input_shape=(28, 28, 1)))
model.add(tf.keras.layers.MaxPool2D((2, 2)))
model.add(tf.keras.layers.Conv2D(128, kernel_size=(3, 3)))
model.add(tf.keras.layers.MaxPool2D((2, 2)))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(140, activation='relu'))
model.add(tf.keras.layers.Dropout(0.2))
model.add(tf.keras.layers.Dense(80, activation='relu'))
model.add(tf.keras.layers.Dropout(0.2))
model.add(tf.keras.layers.Dense(units=10, activation='sigmoid'))
"""
model_1_filter_size = 3
epochs = 10
#model = tf.keras.models.model_from_json()
#sequantial dan json a çevirdim
"""""
model = tf.keras.models.Sequential(
[Convolution2D(filters=64, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu', input_shape=(28, 28, 1)),
Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.5),
Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'),
Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.5),
Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.5),
Flatten(),
Dense(1024, activation='elu'),
Dropout(0.5),
Dense(1024, activation='elu'),
Dropout(0.5),
Dense(10, activation='softmax'),
])
"""
"""
model.add(tf.keras.layers.Convolution2D(filters=64, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu', input_shape=(28, 28, 1)))
model.add(tf.keras.layers.Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'))
model.add(tf.keras.layers.Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Convolution2D(filters=128, kernel_size=(model_1_filter_size, model_1_filter_size),
padding='same', activation='elu'))
model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dense(1024, activation='elu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(1024, activation='elu'))
model.add(tf.keras.layers.Dropout(0.5))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
"""
"""""
model.compile(optimizer=Adam(lr=0.0005), loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(images, labels, batch_size=256, epochs=epochs, shuffle=True, verbose=1,
validation_data=(test_images, test_labels))
"""
# model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
desktop = os.path.join(os.path.join(os.environ['USERPROFILE']), 'Desktop')
f = open(desktop + '/258epochs_model_7.json', 'r')
model_json = f.read()
model = model_from_json(model_json)
model.load_weights(desktop + '/258epochs_model_7.h5')
count = 0
for row in puzzle:
for spot in row:
if np.mean(spot) > 6:
count += 1
#plt.imshow(spot)
#plt.show()
#print(model.predict_classes(spot.reshape(1, 1, 28, 28).astype('float32')/255))
#print(model.predict_classes(spot.reshape(1,28,28,1).astype('float32')/255))
print(count, ' digits are recognized')
template = [
[0 for _ in range(9)] for _ in range(9)
]
for i, row in enumerate(puzzle):
for j, spot in enumerate(row):
if np.mean(spot) > 6:
template[i][j] = model.predict_classes(spot.reshape(1, 1, 28, 28).astype('float32') / 255)[0]
print(template)
"""
flat_list = np.asarray(puzzle[0][0])
flat_list = flat_list.ravel()
flat_list = str(list(flat_list))
flat_list = flat_list.replace("\\r\\n", "")
input_data = "{\"data\": [" + flat_list + "]}"
resp = requests.post("http://abc25a52-54ea-49fa-bfb5-e93e7d6b135b.eastus.azurecontainer.io/score", data=input_data,
headers={'Content-Type': 'application/json'})
print('Azure : ', resp.text)
"""
if solver.validSolvedPuzzle(template)==True:
print("Doğru")
else:
print("Yanlış")
solver.board = template
solver.solve(template)
solver.print_board(template)
cv2.waitKey(0) # Wait for any key to be pressed (with the image window active)
#cv2.destroyAllWindows()
# Close all windows
return template
# GUI.py
import pygame
import copy
import time
from diffboard import boardgen
from solver import solve, valid, print_board
pygame.font.init()
l = boardgen()
g = copy.deepcopy(l)
solve(l)
print_board(l)
class Grid:
board = g
def __init__(self, rows, cols, width, height, win):
self.rows = rows
self.cols = cols
self.cubes = [[
Cube(self.board[i][j], i, j, width, height) for j in range(cols)
] for i in range(rows)]
self.width = width
self.height = height
self.model = None
self.update_model()
self.selected = None
self.win = win
def update_model(self):
self.model = [[self.cubes[i][j].value for j in range(self.cols)]
my_file = os.path.join(THIS_FOLDER, 'input.txt')
# saving the ocntents of the file in a variable
with open(my_file, 'r') as f1:
string_list = f1.read()
string_list = string_list.split() # converting the string into a list
# terminating the program if the list is not 9x9
if len(string_list) != 81:
print("Please enter a 9x9 board")
exit()
unsolved = []
index = 0 # counter to keep track of the string list's index
# saving the contents of the string list into a 2-d list
for i in range(9):
unsolved.append([])
for j in range(9):
unsolved[i].append(int(string_list[index]))
index += 1
print("input board: ")
print_board(unsolved)
solution = solve_board(unsolved)
print()
print('Solution: ')
print_board(solution)
def main():
win = pygame.display.set_mode((540, 600))
pygame.display.set_caption("Sudoku")
board = Grid(9, 9, 540, 540, win)
key = None
run = True
start = time.time()
strikes = 0
hints = 3
print_board(board.answer)
while run:
play_time = round(time.time() - start)
for event in pygame.event.get():
if event.type == pygame.QUIT:
run = False
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_1:
key = 1
if event.key == pygame.K_2:
key = 2
if event.key == pygame.K_3:
key = 3
if event.key == pygame.K_4:
key = 4
if event.key == pygame.K_5:
key = 5
if event.key == pygame.K_6:
key = 6
if event.key == pygame.K_7:
key = 7
if event.key == pygame.K_8:
key = 8
if event.key == pygame.K_9:
key = 9
if event.key == pygame.K_DELETE or event.key == pygame.K_BACKSPACE:
board.clear()
key = None
if event.key == pygame.K_SPACE:
board.solve_board()
if event.key == pygame.K_r:
start = time.time()
# hints
if event.key == pygame.K_h:
i, j = board.selected
if board.cubes[i][j].value == 0:
hints -= 1
if hints >= 0:
start -= 30
board.hint()
if event.key == pygame.K_RETURN:
i, j = board.selected
if board.cubes[i][j].temp != 0 and board.cubes[i][
j].value == 0:
if board.place(board.cubes[i][j].temp):
print("Success")
else:
print("Wrong")
strikes += 1
key = None
if strikes > 2:
print("You Lose")
run = False
if board.is_finished():
print("You won!")
run = False
# clicking on cell
if event.type == pygame.MOUSEBUTTONDOWN:
pos = pygame.mouse.get_pos()
clicked = board.click(pos)
if clicked:
board.select(clicked[0], clicked[1])
key = None
if board.selected and key != None:
board.sketch(key)
redraw_window(win, board, play_time, strikes, hints)
pygame.display.update()
temp = int(temp[0])
else:
temp = 0
ans.append(temp)
x += dx
x = xc
if (j % 3 == 0):
y += dy + 12
else:
y += dy + 8
grid.append(ans)
touch.append(t)
orig_grid = copy.deepcopy(grid)
solve(grid)
print_board(grid)
def click(i, j):
device.shell(f'input touchscreen tap {touch[i][j][0]} {touch[i][j][1]}')
def select(n):
arr = [123, 212, 314, 410, 515, 623, 724, 839, 937]
device.shell(f'input touchscreen tap {arr[n-1]} 1453')
for i in range(len(grid)):
for j in range(len(grid[0])):
if (orig_grid[i][j] == 0):
select(grid[i][j])
