Exemple #1
0
    def solve():
        """this function solves the wordseaerch puzzle given and returns the correspondant cell and direction of each word"""
        self.solveButton.config(state="disabled")
        self.grid = empty((9, 9), dtype=str)
        try:
            for row in range(9):
                for column in range(9):
                    self.grid[row, column] = int(
                        self.numberStringVar[(row, column)].get())
        except:
            mb.showerror("Entry Error", "Input must be single digit numbers")
            self.solveButton.config(state="normal")

        start = time()
        solver = SudokuSolver(self.grid)
        try:
            mb.showinfo(
                "Loding",
                "The solving process could take a long time depending on te complexity of the Sudoku grid \nPlease Wait !!!"
            )
            self.grid = solver.solve()
            for row in range(9):
                for column in range(9):
                    self.numberStringVar[(row, column)].set(
                        str(self.grid[row, column]))
            mb.showinfo(
                "Finished", "The solving process took about " +
                str(time() - start) + " seconds to finish !!!")
        except:
            mb.showerror(
                "Entry Error",
                "There is an error in your input, please re-enter a coorect grid"
            )
            self.solveButton.config(state="normal")
Exemple #2
0
 def __solve_sudoku(self):
     self.unsolved_puzzle = copy.deepcopy(self.game.puzzle)
     #backtracking_solver = BacktrackingSudokuSolver(self.game.puzzle)
     #backtracking_solver.solve()
     dlx_sudoku_solver = SudokuSolver(self.game.puzzle)
     solutions = dlx_sudoku_solver.solve_sudoku()
     dlx_sudoku_solver.final_solution(solutions)
     self.__draw_puzzle(dlx_sudoku_solver.solution_board)
Exemple #3
0
def upload_refined(mat):
	mat = mat.encode('ascii', 'ignore')
	arr = mat.split(',')
	arr = [int(e) for e in arr]
	sud = [arr[i:i + 9] for i in xrange(0, len(arr), 9)]
	ss = SudokuSolver(sud)
	global solvedSuds
	solvedSuds = ss.main()
	print solvedSuds
	return url_for('solved')
Exemple #4
0
def solve_step():
    board = request.json['board']
    sp = SudokuPuzzle(board)
    ss = SudokuSolver(sp)
    ss.solve_next_step()
    log = ss.sudoku_logger.sudoku_log
    try:
        return jsonify({'board': ss.sudoku_puzzle.get_board(), 'steps_log': log})
    except Exception as e:
        print(e)
Exemple #5
0
def solve_puzzle():
    print(request.json)
    print(request.json['board'])
    # params = request.json.to_dict()
    # print(params)
    board = request.json['board']
    sp = SudokuPuzzle(board)
    ss = SudokuSolver(sp)
    ss.do_work()
    log = ss.sudoku_logger.sudoku_log
    try:
        return jsonify({'board': ss.sudoku_puzzle.get_board(), 'steps_log': log})
    except Exception as e:
        print(e)
 def assert_expected_solver_output(self, puzzle, expected_done, solution_count, solution=None, constraints=None):
     puzzle_grid = SudokuGrid(puzzle)
     my_solution, done, info = SudokuSolver().solveSudoku(puzzle_grid, verbose=False, constraints=constraints)
     #self.assertEqual(info,"")
     self.assertEqual(done, expected_done)
     self.assertEqual(info['solutions'], solution_count)
     if solution:
         self.assertTrue(SudokuGrid(solution) == my_solution, msg=f'solution does not match. Actual: {my_solution}')
Exemple #7
0
def main():
    """Spreadsheet Column Printer
    This script allows the user to solve a Sudoku board by specifying the image-path as an argument (with quotation
    marks), the image needs to contain a Sudoku board. This script works best on image taken on real paper where the
    Sudoku board takes up almost the whole picture. If no path is specified, a random image will be taken from the
    folder Example images.

    This script requires that the following dependencies to be within the Python
    environment you are running this script in:
    - keras
    - tensorflow
    - numpy
    - matplotlib
    - scikit-image

    This script can also be run in an IDE, but then the user has to manipulate and manually set the image path.
    """
    if len(sys.argv) > 1:
        image_path = str(sys.argv[1])
    else:
        print("No image specified. Taking a random image.")
        base_path = os.getcwd() + "\Example images\\"
        image_path = base_path + os.listdir(base_path)[random.randint(0,len(os.listdir(base_path))-1)]


    input_sudoku_img = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    plt.imshow(input_sudoku_img, cmap='gray')
    plt.show()
    resized_sudoku_img = cv2.resize(input_sudoku_img, (1200, 900), interpolation=cv2.INTER_AREA)
    processed_sudoku_img = preprocess_sudoku_board(resized_sudoku_img.copy(), MNIST_DIMENSION)
    sudoku_board = np.zeros((9, 9), dtype=np.int8)

    # Import final model
    model = load_model(os.path.dirname(os.path.realpath(__file__)) + "\Final model")

    for index, square in enumerate(processed_sudoku_img):
        if square[1]:
            # Normalize number
            number = square[0] / 255
            number = np.reshape(number, newshape=(1, 28, 28, 1))
            prediction = model.predict(number)[0]
            sudoku_board[int(index / 9)][index % 9] = int(np.argmax(prediction)) + 1
        else:
            sudoku_board[int(index / 9)][index % 9] = -1

    print("Interpreted the Sudoku to be:")
    sudoku_solver = SudokuSolver()
    sudoku_solver.print_board(sudoku_board)

    if not sudoku_solver.is_valid_board(sudoku_board):
        print("Sorry, no solution was found. Take a new picture and try again.")
        quit()

    solved_sudoku = np.array(sudoku_solver.solve(sudoku_board)[0])
    sudoku_solver.print_board(solved_sudoku)
Exemple #8
0
        def click():
            def new_int(t):
                return int(t) if t else 0

            grid = [
                list(new_int(t.get()) for t in self.texts[i * 9:i * 9 + 9])
                for i in range(9)
            ]
            s = SudokuSolver(grid)
            r = s.solve()
            if r.startswith('+'):
                lbs = [
                    list(t for t in labels[i * 9:i * 9 + 9]) for i in range(9)
                ]
                for i in range(9):
                    for j in range(9):
                        lbs[i][j].config(text=s.b[i][j])
            else:
                mb.showerror(message=r)
Exemple #9
0
def main():
    # board = save_and_get_new_board(4)
    # print(board)
    # board = read_saved_board(11)
    board = [
        [None, None, 7, 4, None, None, 3, None, None],
        [None, None, None, None, 7, None, None, None, 8],
        [9, 2, None, None, None, None, None, None, None],
        [6, None, None, 9, 1, 3, 8, None, 2],
        [None, 8, 3, None, None, 4, 6, None, None],
        [2, None, None, 8, None, None, None, None, None],
        [3, None, 8, 1, None, None, None, None, None],
        [None, 9, None, 3, None, None, None, None, 4],
        [1, None, None, None, None, 6, None, None, None]
    ]
    sp = SudokuPuzzle(board)
    # sp.print_board()

    ss = SudokuSolver(sp)
    ss.do_work()
Exemple #10
0
def solve_puzzle():
    try:
        board = request.json['board']
        puzzle_name = request.json['puzzleName']
        # Check if the puzzle has a solution
        validate_puzzle(puzzle_name, board)

        sp = SudokuPuzzle(board)
        ss = SudokuSolver(sp)
        ss.do_work()
        log = ss.sudoku_logger.sudoku_log
        return jsonify({
            'success': True,
            'board': ss.sudoku_puzzle.get_board(),
            'steps_log': log
        })
    except Exception as e:
        print(e)
        return jsonify({
            'success': False
        })
Exemple #11
0
def Main():
    puzzles = ParsePuzzleStrings()
    keySum = 0
    startTime = time()
    for puzzle in puzzles:
        board = puzzle[1]
        trials = 0
        solver = SudokuSolver(board, yieldLevel=0)
        generator = solver.Generate()
        for result in generator:
            # result = next(generator)
            trials += 1
            if result == 2:
                line = solver.board[0]
                key = line[0] * 100 + line[1] * 10 + line[2]
                keySum += key
                print(
                    "After {} trials, we found a solution for {} with a key: {}"
                    .format(trials, puzzle[0], key))
    endTime = time()
    print("After {} seconds, the final sum of keys is {}".format(
        endTime - startTime, keySum))
Exemple #12
0
    def _calc_solution(self, cells_entry):
        solutions_queue = Queue()

        def process_queue():
            try:
                sols = solutions_queue.get(0)
                self._draw_solution(sols)
            except Empty:
                self._root.after(100, lambda: process_queue())

        ss = SudokuSolver()

        for i in range(0, 9):
            for j in range(0, 9):
                value = cells_entry[i][j].get()
                if value:
                    ss.add_known_number(i + 1, j + 1, int(value))

        ResolutionThread(solutions_queue, ss).start()
        self._waiting()

        self._root.after(100, lambda: process_queue())
Exemple #13
0
Fichier : Imp.py Projet : oldteb/AI
def main():

    ss = SudokuSolver()
    print "Algorithm is running..."
    print "Running time limit: 5 mins"
    
    # Imp 1
    #ss.printBoard(ss.getBoard("sudoku9_1.txt"))

    # Imp 2
    #print ss.isValid(ss.getBoard("sudoku4_1.txt"))

    # Imp 3
    #if ss.SA_solver2(ss.getBoard("sudoku9_9.txt")) != False:
    #    ss.printBoard(ss.board)
    #    print "Conflicts:",ss.isValid(ss.board)
    #    print "Time used:",int(ss.e_time),"secs"
    #else:
    #    print "No solution found."


    # Imp 4
    #if ss.AS_solver(ss.getBoard("sudoku9_8.txt")) == True:
    #    ss.printBoard(ss.board)
    #    print "Conflicts:",ss.isValid(ss.board)
    #    print "Time used:",int(ss.e_time),"secs"
    #else:
    #    print "No solution found."


    # Imp 5    
    if ss.CSP_solver(ss.getBoard("sudoku9_8.txt")) == True:
        ss.printBoard(ss.board)
        print "Conflicts:",ss.isValid(ss.board)
        print "Time used:",int(ss.e_time),"secs"
    else:
        print "No solution found."
Exemple #14
0
    def generate_puzzle(iterations):
        solution = SudokuBoard()
        solution.build()

        playable = solution.clone()
        difficult_coefficient = 1
        for _ in range(iterations):
            new_playable = playable.clone()

            row_num, column_num = random.randrange(9), random.randrange(9)
            while new_playable.is_cell_empty(row_num, column_num):
                row_num, column_num = random.randrange(9), random.randrange(9)
            new_playable.clear_cell(row_num, column_num)

            solver = SudokuSolver(new_playable)
            try:
                solver.solve()
                playable = new_playable
                difficult_coefficient = solver.difficult_coefficient
            except:
                continue

        difficult_level = None
        if difficult_coefficient < DifficultLevel.VERY_EASY.value:
            difficult_level = DifficultLevel.VERY_EASY
        elif difficult_coefficient < DifficultLevel.EASY.value:
            difficult_level = DifficultLevel.EASY
        elif difficult_coefficient < DifficultLevel.MEDIUM.value:
            difficult_level = DifficultLevel.MEDIUM
        elif difficult_coefficient < DifficultLevel.HARD.value:
            difficult_level = DifficultLevel.HARD
        elif difficult_coefficient < DifficultLevel.VERY_HARD.value:
            difficult_level = DifficultLevel.VERY_HARD
        elif difficult_coefficient < DifficultLevel.MASTER.value:
            difficult_level = DifficultLevel.MASTER
        return SudokuGame(playable, solution, difficult_level,
                          difficult_coefficient)
Exemple #15
0
    def __init__(self, parent=None):
        self.solver = SudokuSolver()
        QWidget.__init__(self, parent)
        self.errors = dict()

        gbox = QGridLayout()

        c1 = QGraphicsView()
        color = QtGui.QColor(0)
        color.setBlue(255)
        gradient = QtGui.QRadialGradient(0, 0, 10)
        gradient.setSpread(QtGui.QGradient.RepeatSpread)
        c1.setForegroundBrush(color)

        c1.setPalette(QtGui.QPalette(QtGui.QColor(250, 250, 200)))
        c1.setAutoFillBackground(True)

        enter = QPushButton("Solve")
        enter.setMaximumHeight(40)
        enter.clicked.connect(self.solve)

        clear = QPushButton("Clear")
        clear.setMaximumHeight(40)
        clear.clicked.connect(self.clear)

        self.label = QLabel()

        self.squares = SquareWidget()
        gbox.addWidget(self.squares, 0, 0)
        hbox = QHBoxLayout()
        gbox.addWidget(self.label, 1, 0)
        hbox.addWidget(clear)
        hbox.addWidget(enter)
        gbox.addLayout(hbox, 2, 0, alignment=Qt.AlignRight)

        self.setLayout(gbox)
Exemple #16
0
class Main:
    image = ImageDigitReader()

    sudoku_board_img = image.get_sudoku_board()

    sudoku_board = [
        [4, 1, 7, 0, 0, 0, 5, 0, 0],
        [5, 0, 0, 0, 6, 0, 4, 2, 0],
        [0, 6, 2, 0, 0, 0, 0, 0, 0],
        [0, 0, 0, 9, 0, 0, 3, 7, 0],
        [1, 5, 3, 0, 7, 2, 0, 8, 0],
        [0, 0, 0, 3, 0, 8, 6, 0, 0],
        [9, 2, 8, 7, 0, 0, 1, 4, 3],
        [0, 0, 5, 0, 9, 0, 8, 0, 0],
        [6, 0, 1, 4, 0, 0, 2, 9, 5]
    ]
    sudoku = SudokuSolver(sudoku_board_img)

    sudoku.print_solved_sudoku()
Exemple #17
0
#!/usr/bin/env python
from SudokuSolver import SudokuSolver
import sys

s = SudokuSolver('sudoku/example.sdk')
s.parseBoard()
s.printBoard()
s.onlyValid(0,0)
s.printBoard()
Exemple #18
0

t = Tester()

i = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9],
]
t.test(i, True, SudokuSolver().solve(i))

i = [
    [1, 2, 3, 4, 5, 6, 7, 8, 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, 0, 0],
]
t.test(i, True, SudokuSolver().solve(i))

i = [
Exemple #19
0
                            button_text_rect = button_text.get_rect()
                            button_text_rect.center = solve_button.center

                            self.screen.blit(button_text, button_text_rect.topleft)

                            print('Button clicked!')
                            solver.solve_board()


gui = Gui()

solver = SudokuSolver([[0, 0, 0, 0, 1, 0, 9, 2, 0],
                      [0, 0, 0, 4, 9, 3, 0, 0, 0],
                      [0, 0, 0, 0, 0, 0, 0, 7, 0],
                      [6, 0, 0, 0, 0, 0, 3, 0, 0],
                      [0, 5, 0, 0, 0, 0, 0, 0, 0],
                      [0, 1, 3, 0, 0, 0, 0, 6, 8],
                      [0, 0, 2, 9, 0, 0, 7, 3, 0],
                      [4, 0, 0, 0, 0, 0, 0, 0, 5],
                      [5, 0, 8, 0, 0, 7, 0, 0, 0]], gui)

gui.start(solver)
solver.solve_board()


# Easy
# [[0, 4, 0, 0, 0, 2, 0, 1, 9],
#  [0, 0, 0, 3, 5, 1, 0, 8, 6],
#  [3, 1, 0, 0, 9, 4, 7, 0, 0],
#  [0, 9, 4, 0, 0, 0, 0, 0, 7],
#  [0, 0, 0, 0, 0, 0, 0, 0, 0],
Exemple #20
0
    [0, 1, 0, 0, 0, 0, 0, 0, 8],
    [5, 0, 0, 0, 4, 0, 0, 0, 9],
    [7, 0, 0, 0, 0, 0, 0, 6, 0],
    [4, 0, 0, 0, 0, 0, 7, 0, 0],
    [0, 2, 0, 0, 0, 6, 0, 0, 0],
    [0, 0, 3, 9, 8, 0, 0, 0, 0]
]

input=np.array(input)

self=board.SudokuBoard(input)

#self.getPossibleValues(0,0)


self=solver.SudokuSolver(self)
#
# self.solve()
#
# self.board.isBoardComplete()
#
# self.board.isBoardValid()
#
# self.board.board


import SudokuSolver.SudokuBoardMiracle as boardMiracle

input =[
    [0, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0, 0],
Exemple #21
0
from SudokuSolver import SudokuSolver
from NumberRecognizer import NumberRecognizer
from SudokuAlgorithm import SudokuAlgorithm
import cv2

recognizer = NumberRecognizer('./deeplearning/models/cnn/best_model')
solver = SudokuSolver(recognizer)

paths = [
    "./inputs/c.jpg",
    "./inputs/d.jpg",
    "./inputs/e.jpg",
    "./inputs/g.jpg",
    "./inputs/n.png",
    "./inputs/o.png",
    "./inputs/p.png",
    "./inputs/q.png",
    "./inputs/r.png",
    "./inputs/s.png",
    "./inputs/v.png",
    "./inputs/u.png",
]

for path in paths:
    try:
        img, grid = solver.imageToGrid(cv2.imread(path))
        img = cv2.resize(img, (600, 600))
        h, w, ch = img.shape

        if grid != None:
            algorithm = SudokuAlgorithm(grid)
Exemple #22
0
)

args = parser.parse_args()

conflictPuzzlesPath = 'conflictPuzzles.txt'
conflictTranscriptsPath = 'conflictTranscripts.txt'

# Count the number of lines in the file
if not isfile(args.sudokuPuzzlesFile):
	print('Cannot open', args.sudokuPuzzlesFile)
	exit(1)

totalCount = sum(1 for line in open(args.sudokuPuzzlesFile))

# Load the Sudoku puzzles from the Ruud test set and try to solve them
solver = SudokuSolver()

solvedCount = 0
unsolvedCount = 0
conflictCount = 0

fConflictPuzzles = open(conflictPuzzlesPath, 'w')
fConflictTranscripts = open(conflictTranscriptsPath, 'w')

with open(args.sudokuPuzzlesFile, 'r') as f:
	puzzleString = f.readline().strip()

	pbar = ProgressBar(widgets=['Evaluating: ', Percentage(), ' ', Bar(), ' ', ETA()])
	pbar.start(max_value=totalCount)
	i = 0
	
Exemple #23
0
import os
## Next few lines to uncomment if there is a problem with CUDA
#os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"   # see issue #152
#os.environ["CUDA_VISIBLE_DEVICES"] = "-1"

from keras.models import load_model
from SudokuSolver import SudokuSolver

fileName = 'Sudoku_test.png'
filePath = os.getcwd()+'\\ressources\\SudokuImages\\'+fileName
savePath = os.getcwd()+'\\ressources\\ResultsImages\\solution_'+fileName
digitImagesDirectory = os.getcwd()+'\\ressources\\digitSamples'

model_name = 'digitsModel.h5'


if __name__ == "__main__":
    model = load_model(model_name)    
    solver = SudokuSolver(model, filePath, True, savePath, digitImagesDirectory)
    print("\nSudoku Solved")
Exemple #24
0
	def SolverFromPuzzleNumber(self, number):
		board = puzzles[number][1]
		return SudokuSolver(board, yieldLevel=0)
Exemple #25
0
	def SolverFromDifficulty(self):
		if self.difficulty == Difficulty.Easy:
			board = easyBoard
		else:
			board = hardBoard
		return SudokuSolver(board, yieldLevel=0)
Exemple #26
0
    #medium game
    # game_board =   [[4, 0, 0, 0, 0, 0, 0, 2, 0],
    # 				[8, 0, 0, 7, 0, 9, 0, 0, 0],
    # 				[0, 1, 6, 3, 0, 0, 0, 0, 0],
    # 				[5, 0, 9, 0, 0, 0, 0, 1, 0],
    # 				[3, 7, 4, 2, 0, 1, 5, 8, 6],
    # 				[0, 8, 0, 0, 0, 0, 7, 0, 9],
    # 				[0, 0, 0, 0, 0, 7, 6, 3, 0],
    # 				[0, 0, 0, 8, 0, 5, 0, 0, 4],
    # 				[0, 9, 0, 0, 0, 0, 0, 0, 7]]

    # #Hard game
    # game_board =   [[5, 9, 0, 0, 0, 7, 0, 8, 0],
    # 				[0, 0, 0, 5, 0, 0, 0, 0, 7],
    # 				[4, 1, 0, 8, 0, 0, 5, 0, 6],
    # 				[0, 0, 1, 3, 0, 0, 0, 0, 4],
    # 				[0, 0, 5, 0, 0, 0, 9, 0, 0],
    # 				[8, 0, 0, 0, 0, 4, 2, 0, 0],
    # 				[9, 0, 2, 0, 0, 3, 0, 4, 5],
    # 				[1, 0, 0, 0, 0, 5, 0, 0, 0],
    # 				[0, 5, 0, 4, 0, 0, 0, 6, 9]]

    game = SudokuSolver()

    root = Tk()
    sudokuUI = SudokuUI(root, game)
    root.geometry("%dx%d" %
                  (WIDTH, HEIGHT + 150))  #Extra 200 to add extra attributes
    root.mainloop()
Exemple #27
0
        image_container = ImagePrepper(settings.FILE_NAME)
    except:
        if settings.VERBOSE_EXIT:
            print("ERROR -- Failed to load image. Does the image "
                  "exist? Do you have a typo? Note: only .png, .jpg and "
                  ".jpeg files are supported.")
        exit()
    if settings.ENABLE_DEBUG:
        print("DEBUG GLOBAL -- Image succesfully loaded.")
        print("DEBUG GLOBAL -- Attempting to extract values from image.")
    # Show preview if enabled in the settings
    if settings.ENABLE_PREVIEW or settings.ENABLE_PREVIEW_ALL:
        image_preview(image_container.image)

    extracted_info = ImageExtractor(image_container.image)
    sudoku_solver = SudokuSolver(extracted_info.starting_grid)
    board_is_valid = sudoku_solver.board_is_valid()

    if not board_is_valid:
        if settings.VERBOSE_EXIT:
            print("ERROR -- Starting values found in sudoku were not valid.")
            print("The following board was found: ")
            sudoku_solver.print_sudoku()
        exit()

    if settings.ENABLE_DEBUG:
        print("DEBUG -- Following starting board was found: ")
        sudoku_solver.print_sudoku()

    if settings.ENABLE_DEBUG:
        print("DEBUG -- Attempting to solve the sudoku.")
Exemple #28
0

t = Tester()

i = [
    [5, 3, 0, 0, 7, 0, 0, 0, 0],
    [6, 0, 0, 1, 9, 5, 0, 0, 0],
    [0, 9, 8, 0, 0, 0, 0, 6, 0],
    [8, 0, 0, 0, 6, 0, 0, 0, 3],
    [4, 0, 0, 8, 0, 3, 0, 0, 1],
    [7, 0, 0, 0, 2, 0, 0, 0, 6],
    [0, 6, 0, 0, 0, 0, 2, 8, 0],
    [0, 0, 0, 4, 1, 9, 0, 0, 5],
    [0, 0, 0, 0, 8, 0, 0, 7, 9],
]
t.test(i, True, SudokuSolver().solve(copy.deepcopy(i)))

i = [
    [1, 2, 3, 4, 5, 6, 7, 8, 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, 0, 0],
]
t.test(i, True, SudokuSolver().solve(copy.deepcopy(i)))

i = [
Exemple #29
0

WIDTH = 630
HEIGHT = 730

pygame.init()
window = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption('Sudoku')
pygame.display.set_icon(pygame.Surface((32, 32)))

# Sudoku values
numbers = SpriteSheet("sudoku_numbers.png")
images = SpriteSheet("button_sprites.png")

sudoku = SudokuSolver()
board_num = 0
selected_tile = None

# Sudoku grid
buttons = []
buttons.append(Button((15, 15), (70, 70), images.get_num(3), prev_board))
buttons.append(Button((545, 15), (70, 70), images.get_num(2), next_board))

buttons.append(Button((175, 15), (70, 70), images.get_num(1), solve_board))
buttons.append(
    Button((630 - 175 - 70, 15), (70, 70), images.get_num(0), reset_board))

tiles = set_board(sudoku.board)

lines = []
Exemple #30
0
class SudokuWidget(QtWidgets.QWidget):
    boardText = ""
    valueChanged = QtCore.pyqtSignal(bool)

    def __init__(self, parent=None):
        self.solver = SudokuSolver()
        QWidget.__init__(self, parent)
        self.errors = dict()

        gbox = QGridLayout()

        c1 = QGraphicsView()
        color = QtGui.QColor(0)
        color.setBlue(255)
        gradient = QtGui.QRadialGradient(0, 0, 10)
        gradient.setSpread(QtGui.QGradient.RepeatSpread)
        c1.setForegroundBrush(color)

        c1.setPalette(QtGui.QPalette(QtGui.QColor(250, 250, 200)))
        c1.setAutoFillBackground(True)

        enter = QPushButton("Solve")
        enter.setMaximumHeight(40)
        enter.clicked.connect(self.solve)

        clear = QPushButton("Clear")
        clear.setMaximumHeight(40)
        clear.clicked.connect(self.clear)

        self.label = QLabel()

        self.squares = SquareWidget()
        gbox.addWidget(self.squares, 0, 0)
        hbox = QHBoxLayout()
        gbox.addWidget(self.label, 1, 0)
        hbox.addWidget(clear)
        hbox.addWidget(enter)
        gbox.addLayout(hbox, 2, 0, alignment=Qt.AlignRight)

        self.setLayout(gbox)

    def clear(self):
        self.squares.arr = [[0 for x in range(9)] for y in range(9)]
        self.squares.update()

    def solve(self):
        err_dict, err_str = self.solver.solve_set(self.squares.getArrStr())
        self.squares.arr = self.solver.board.get_board()

        ltext = ""
        if err_dict is not None:
            err = err_dict.popitem()
            if err[1] == Sudoku.Board.ERRORS_BLK:
                ltext = "Block"
            elif err[1] == Sudoku.Board.ERRORS_ROW:
                ltext = "Row"
            elif err[1] == Sudoku.Board.ERRORS_COL:
                ltext = "Col"
            ltext += " error at " + str(err[0])

        self.label.setText(ltext)
        self.squares.update()
Exemple #31
0
from SudokuSolver import SudokuSolver

obj = SudokuSolver()
grid = obj.readSudoku()
obj.solve(grid)
Exemple #32
0
from SudokuSolver import SudokuSolver
import os
import json


solver = SudokuSolver()
rules = solver.get_rules(9)
probs = []
for i in range(1, 81):
    folder = 'data/' + str(i) + '/' 
    total = 100
    counter = 0
    for filename in os.listdir(folder):    
        if 'puzzle' in filename:
            counter += 1 if solver.is_proper(solver.sudoku_to_cnf(folder + filename) + rules) else 0
    prob = counter/total
    probs.append({'givens': i, 'prob': prob})


with open('properness_probs.json', 'w') as fp:
    json.dump({'data': probs}, fp)
Exemple #33
0
from CheckNumber import checkIfNumberOk
from SudokuGen import SudokuGenerator
from SudokuSolver import SudokuSolver

print('generating...')
s1 = SudokuGenerator()
sudoku1 = s1.getSudokuArray(9, 0.3)
print(sudoku1)

print('start solving...')
s = SudokuSolver()
print(s.solve(sudoku1))
Exemple #34
0
def get_solution(puzzle_name, board):
    print("ACTUALLY SOLVING")
    sp = SudokuPuzzle(board)
    ss = SudokuSolver(sp)
    ss.do_work()
    return ss.sudoku_puzzle.get_board()