def solve(x_in, window): pop, trial = Puzzle(), Puzzle() trial.init(x_in, "") trial.depth = 0 q = PriorityQueue() q.put(copy.deepcopy(trial)) is_searched = {trial.id: True} if trial.is_target(): return trial.path while not q.empty(): window.update() pop = q.get() sx = int(pop.space % Puzzle.N) sy = int(pop.space / Puzzle.N) for r in range(4): tx = sx + Puzzle.dx[r] ty = sy + Puzzle.dy[r] if tx < 0 or ty < 0 or tx >= Puzzle.N or ty >= Puzzle.N: continue trial.init(pop.x, pop.path) trial.set_depth(pop.depth + 1) trial.swap(trial.space, ty * Puzzle.N + tx) if trial.id not in is_searched.keys(): is_searched[trial.id] = True trial.path = trial.path + Puzzle.dir[r] if trial.is_target(): return trial.path q.put(copy.deepcopy(trial))
def main(): #First show one execution of a puzzle to solve pz = Puzzle('12375846 ') print('Solving the following puzzle and printing steps:') print(pz) jigsaw = JigsawPlay(pz) steps = jigsaw.solve('fair', True) for step in steps: print(Puzzle(step)) #Now time everything and plot the graph number_executions = 10 puzzles = generate_puzzles(number_executions) fair_lambda = Timer(lambda: time_solve_puzzle('fair', puzzles, False)) fair_score = fair_lambda.timeit(number=1) weak_lambda = Timer(lambda: time_solve_puzzle('weak', puzzles, False)) weak_score = weak_lambda.timeit(number=1) bad_lambda = Timer(lambda: time_solve_puzzle('bad', puzzles, False)) bad_score = bad_lambda.timeit(number=1) good_lambda = Timer(lambda: time_solve_puzzle('good', puzzles, False)) good_score = good_lambda.timeit(number=1) print ('Fair evaluation execution time: ', fair_score) print ('Weak evaluation execution time: ', weak_score) print ('Bad evaluation execution time: ', bad_score) print ('Good evaluation execution time: ', good_score) plt.plot(['bad', 'weak', 'fair', 'good'], [bad_score, weak_score, fair_score, good_score]) plt.title('A* evaluation timing') plt.ylabel('Duration') plt.show()
def main(puzzleFile, method, timeLimit): puzzleSize = 3 #print(puzzleSize) #debug problem = Puzzle() problem.loadFile(open(puzzleFile, 'r'), puzzleSize) solution = Puzzle() solution.loadFile(open('solution.txt', 'r'), puzzleSize) solver = None if method == 'BFS': solver = PuzzleAgent(weights.bfsWeight) elif method == 'A*': solver = PuzzleAgent(weights.aStarWeight) elif method == 'GREEDY': solver = PuzzleAgent(weights.manhattanWeight) elif method == 'UNIFORM': solver = PuzzleAgent(weights.uniformWeight) else: print('Invalid method') return #problem.printState() #debug solution = solver.solve(problem, solution, timeLimit) while solution: solutionStep = solution.pop() solutionStep.printState()
def get_children(self, node): child_list = set() dim = node.state.shape[0] i, j = map(np.int, np.where(node.state == 0)) if (j > 0): child = node.state.copy() child[i, j] = node.state[i, j - 1] child[i, j - 1] = 0 p = Puzzle(child) child_list.add(p) if (j < dim - 1): child = node.state.copy() child[i, j] = node.state[i, j + 1] child[i, j + 1] = 0 p = Puzzle(child) child_list.add(p) if (i > 0): child = node.state.copy() child[i, j] = node.state[i - 1, j] child[i - 1, j] = 0 p = Puzzle(child) child_list.add(p) if (i < dim - 1): child = node.state.copy() child[i, j] = node.state[i + 1, j] child[i + 1, j] = 0 p = Puzzle(child) child_list.add(p) return child_list
def test_manhattan_distance(self): puzz = Puzzle() puzz.set_state([[1, 2, 3], [4, 7, 5], [6, 8, 0]]) self.assertEqual(2, puzz.evaluate('fair')) puzz = Puzzle(' 13425678') self.assertEqual(2, puzz.evaluate('fair'))
def puzzle(args): start = Puzzle(np.array([4, 3, 6, 8, 2, 7, 5, 1, 0])) goal = Puzzle(np.array([8, 1, 2, 7, 0, 3, 6, 5, 4])) path = BFS(start, goal) for s in path: print(s[1].board.reshape((3, 3))) if s[0]: print("ACTION: ", s[0])
def test_get_best_fvalue(self): p1 = Puzzle([[2, 4, 8], [5, None, 6], [7, 1, 2]], None) p1.f = 4 p2 = Puzzle([[2, 4, 8], [5, None, 6], [7, 1, 2]], None) p2.f = 8 p3 = Puzzle([[2, 4, 8], [5, None, 6], [7, 1, 2]], None) p3.f = 3 open_list = [p1, p2, p3] index, puzzle = get_best_fvalue(open_list) self.assertEqual(2, index) self.assertEqual(p3, puzzle)
def main_1(): dim = 3 goal = Puzzle( np.insert(np.arange(1, dim * dim), dim * dim - 1, 0).reshape(dim, dim)) time1 = [] time2 = [] space1 = [] space2 = [] for i in range(15): while True: start = Puzzle( np.random.permutation(np.arange(dim * dim)).reshape( (dim, dim))) if start.solvable(): break t_1 = time.time() p1 = Astar('manhattan', start, goal) h1 = p1.search() t_2 = time.time() t_f = t_2 - t_1 time1.append(t_f) space1.append(np.mean([j for i, j in h1])) t_11 = time.time() p2 = Astar('hamming', start, goal) h2 = p2.search() t_22 = time.time() t_ff = t_22 - t_11 time2.append(t_ff) space2.append(np.mean([j for i, j in h2])) a = plt.plot(time1, 'blue') b = plt.plot(time2, 'red') plt.legend(['Manhattan', 'Hamming']) plt.xlabel('puzzle') plt.ylabel('tiempo') plt.title('Tiempo A*') plt.show() a = plt.plot(space1, 'blue') b = plt.plot(space2, 'red') plt.legend(['Manhattan', 'Hamming']) plt.xlabel('puzzle') plt.ylabel('espacio') plt.title('Espacio A*') plt.show() print(time1) print(space1) print(time2) print(space2)
def test_solvable(): """Tests different puzzles to see if they are solvable.""" p1 = Puzzle(puzzle1) p2 = Puzzle(puzzle2) print(p1) print("Solvable:", p1.is_solvable(), '\n') print(p2) print("Solvable:", p2.is_solvable(), '\n') p3 = Puzzle() print(p3) print("Solvable:", p3.is_solvable())
def test_init_actual(self): testpuzzle = Puzzle( 'C:\\Users\\Jono-work\\Git\\personal\\nonosolver\\puzzles\\upright.json' ) self.assertEqual( testpuzzle.puzzleactual, [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
def main(): """ args[0] - method, bfs / dfs / astr args[1] - search order or heuristic e.g. ldur / rldu / manh / hamm args[2] - filename of puzzle file args[3] - filename of solution file args[4] - filename of additional data file """ args = sys.argv[1:] if len(args) == 5: initial_puzzle = load_initial_puzzle(args[2]) print_initial_info(args, initial_puzzle) if puzzle_height != 4 or puzzle_width != 4: correct_puzzle = generate_correct_state(puzzle_height, puzzle_width) Puzzle.correct_state, Puzzle.puzzle_height, Puzzle.puzzle_width = correct_puzzle, puzzle_height, puzzle_width first_state = Puzzle(initial_puzzle) choose_method(args[0], args[1], first_state, args[3], args[4]) else: print("Wrong number of arguments!")
def build(self): root = Widget() puzzle = Puzzle(resolution=(640, 480), play=True) root.add_widget(puzzle) return root
def test_fit_top_bottom(self, piece4: Piece, piece9: Piece) -> None: """A piece with one possible matching side fits 8 ways.""" assert str(piece4) == "Red-♦♣♧♢" assert str(piece9) == "Red-♥♠♤♧" expected_orientations = [ (piece9, False, Turn.TURN_270, piece4, False, Turn.TURN_270), (piece9, False, Turn.TURN_270, piece4, True, Turn.TURN_90), (piece4, False, Turn.TURN_90, piece9, False, Turn.TURN_90), (piece4, False, Turn.TURN_90, piece9, True, Turn.TURN_270), (piece9, True, Turn.TURN_90, piece4, False, Turn.TURN_270), (piece9, True, Turn.TURN_90, piece4, True, Turn.TURN_90), (piece4, True, Turn.TURN_270, piece9, False, Turn.TURN_90), (piece4, True, Turn.TURN_270, piece9, True, Turn.TURN_270), ] expected = [ Puzzle(1, 2, (OrientedPiece(p1, f1, t1), OrientedPiece(p2, f2, t2))) for p1, f1, t1, p2, f2, t2 in expected_orientations ] assert sorted(expected) == expected puzzles = solve_puzzle(1, 2, (piece4, piece9)) assert puzzles == set(expected) assert (str(expected[0]) == """\ ┌♠┐ ♥R♤ ├♣┤ ♦R♧ └♢┘\ """)
def main(puzzle_file): """Main function of our program's driver. Times execution and prints results. Args: puzzle_file: The name of the input file describing the puzzle. """ try: with open(puzzle_file) as f: puzzle_file = f.read() except IOError as e: sys.exit(e) print(puzzle_file.strip()) # print input file start_time = default_timer() # begin timer puzzle_file = puzzle_file.splitlines() try: # unpack puzzle init values, then pass the remainder as the board tree = Tree(Puzzle(*puzzle_file[:7], puzzle_file[7:])) except (TypeError, ValueError) as e: sys.exit(e) # perform A* graph search and print results print(tree.astargs()) print(default_timer() - start_time)
def __init__(self, puzzles=[]): self.current_puzzle = 0 self.puzzle_codes = puzzles pygame.init() # Create a resizable screen area self.screen = pygame.display.set_mode((600, 600), pygame.RESIZABLE) pygame.scrap.init() clock = pygame.time.Clock() if self.puzzle_codes: self.puzzle = decode_pb(self.puzzle_codes[0]) else: # Randomise first puzzle self.puzzle = Puzzle(random.randint(1, 6), random.randint(1, 5)) self.puzzle.randomise() pygame.event.post( pygame.event.Event(pygame.KEYDOWN, {"key": pygame.K_r})) self.initialise() # As soon as the event loop start, begin solving the first puzzle pygame.event.post( pygame.event.Event(pygame.KEYDOWN, {"key": pygame.K_s})) # Start main loop self.quit = False while not self.quit: # Limit frames per second clock.tick(30) self.process_events() pygame.quit()
def test_init_fails_pieces_do_not_fit(self, piece1: Piece, piece2: Piece) -> None: with pytest.raises(ValueError) as err: Puzzle(2, 1, (OrientedPiece(piece1), OrientedPiece(piece2))) assert str(err.value) == ( "Piece Red-♠♦♡♢ does not fit at col 0, row 0: Edge.EAST is Red-♣♥♤♡" )
def mate(puztuple): puza = puztuple[0] puzb = puztuple[1] distsa = puza.distances distsb = puzb.distances movesa = puza.movenums movesb = puzb.movenums n = puza.n outmoves = {} for x in range(1, n + 1): for y in range(1, n + 1): if (distsa[(x, y)] > distsb[(x, y)]): outmoves[(x, y)] = movesa[(x, y)] else: outmoves[(x, y)] = movesb[(x, y)] babypuz = Puzzle(n) babypuz.movenums = outmoves babypuz.calculatemindistances() babypuz.evaluate() return babypuz
def main(): goal = [[1, 2, 3], [4, 5, 6], [7, 8, None]] board = [[3, 4, 8], [5, None, 6], [7, 1, 2]] # board = [[None, 1, 3], [4, 2, 5], [7, 8, 6]] # simple board puzzle = Puzzle(board, None) depth = 100 astar(puzzle, goal, depth)
def test_fit_left_right(self, piece4: Piece, piece9: Piece) -> None: """A piece with one possible matching side fits 8 ways.""" assert str(piece4) == "Red-♦♣♧♢" assert str(piece9) == "Red-♥♠♤♧" expected_orientations = [ (piece4, False, Turn.NO_TURN, piece9, False, Turn.NO_TURN), (piece4, False, Turn.NO_TURN, piece9, True, Turn.TURN_180), (piece9, False, Turn.TURN_180, piece4, False, Turn.TURN_180), (piece9, False, Turn.TURN_180, piece4, True, Turn.NO_TURN), (piece9, True, Turn.NO_TURN, piece4, False, Turn.TURN_180), (piece9, True, Turn.NO_TURN, piece4, True, Turn.NO_TURN), (piece4, True, Turn.TURN_180, piece9, False, Turn.NO_TURN), (piece4, True, Turn.TURN_180, piece9, True, Turn.TURN_180), ] expected = [ Puzzle(2, 1, (OrientedPiece(p1, f1, t1), OrientedPiece(p2, f2, t2))) for p1, f1, t1, p2, f2, t2 in expected_orientations ] assert sorted(expected) == expected puzzles = solve_puzzle(2, 1, (piece4, piece9)) assert puzzles == set(expected) assert (str(expected[0]) == """\ ┌♦┬♥┐ ♢R♣R♠ └♧┴♤┘\ """)
def ast(self,initial_state): start = time.time() max_level = 0 frontier = [] heapq.heapify(frontier) initial_puzzle = Puzzle() initial_puzzle.fill_from_string(initial_state.split(',')) heapq.heappush(frontier,initial_puzzle) explored = [] forbidden = SetQueue() while heapq.nlargest(1, frontier): state = heapq.heappop(frontier) state.set_puzzle_id(len(explored)) explored.append(state) if state.is_solved(): solution = self.get_solution(state,explored,start,max_level) self.write_solution_to_file(solution) break moved_puzzles = self.create_list_of_moved_puzzles( state, forbidden ) if moved_puzzles and moved_puzzles[0].get_level() > max_level: max_level = moved_puzzles[0].get_level() for puzzle in moved_puzzles: heapq.heappush(frontier,puzzle) forbidden.put(puzzle)
def dfs(self, initial_state): start = time.time() max_level = 0 frontier = SetStack() initial_puzzle = Puzzle() initial_puzzle.fill_from_string(initial_state.split(',')) frontier.put(initial_puzzle) explored = [] forbidden = SetQueue() forbidden.put(initial_puzzle) while not frontier.empty(): state = frontier.get() state.set_puzzle_id(len(explored)) explored.append(state) if state.is_solved(): solution = self.get_solution(state,explored,start,max_level) self.write_solution_to_file(solution) break moved_puzzles = self.create_list_of_moved_puzzles( state, forbidden ) if moved_puzzles and moved_puzzles[0].get_level() > max_level: max_level = moved_puzzles[0].get_level() for puzzle in reversed(moved_puzzles): frontier.put(puzzle) forbidden.put(puzzle)
def test_init_fails_too_many_pieces(self, piece1: Piece, piece2: Piece) -> None: with pytest.raises(ValueError) as err: Puzzle(1, 1, (OrientedPiece(piece1), OrientedPiece(piece2))) assert (str( err.value ) == "2 pieces will not fit in a puzzle of size 1 (width 1, height 1)")
def generate_new_states(self, state, search_order): to_reverse = [] if state.depth > self.max_depth: self.max_depth = state.depth for direction in search_order: # Check if move is possible in given direction and if depth is lower than max possible depth if state.check_if_move_possible( direction) and state.check_if_not_reversed( direction) and state.depth < self.max_depth_possible: new_state = Puzzle(state.current_state) new_state.solution_string = state.solution_string new_state.depth = state.depth new_state.previous_direction = direction new_state.make_move(direction) if new_state.depth > self.max_depth: self.max_depth = new_state.depth # If new state is solved, we set params and flag to true if new_state.check_if_solved(): self.result_string = new_state.solution_string self.end_time = time.perf_counter() self.solution_found = True else: to_reverse.append(new_state) to_reverse.reverse() for single in to_reverse: self.frontier.append(single) self.number_of_visited += 1
def post_initialisations(self): """ Do some extra initializations. Display the version if a labelVersion is found. Set defaults (try to load them from a configuration file): - Window size and state (width, height and if maximized) Load other saved custom settings. """ # Set previous size and state width = settings.get('width', 350) height = settings.get('height', 350) self.set_title(self.app.localizedname) self.resize(width, height) if settings.get_bool('maximized', False): self.maximize() # Load any other settings here. if self.app.show_simple: self.boxMenu.set_visible(not self.app.show_simple) self.boxMenu.set_no_show_all(True) if not self.app.show_pieces: self.listboxPieces.set_no_show_all(True) if not self.app.show_timer: self.boxTimer.set_no_show_all(True) self.listboxPieces.set_visible(self.app.show_pieces) self.imageClock.set_visible(self.app.show_timer) self.labelClock.set_visible(self.app.show_timer) if self.app.thehistory: # history passed, user wants replay. self.set_sensitive(False) self.playing_history = True self.puzzle = Puzzle(self.app.puzzle_str, self.app.strings_to_use, self.app.font_scale, self.app.thehistory) else: self.start_puzzle()
def Astar_search(initial_state): count = 0 #lista de noh ja exp´lorados explored = [] #noh inicial start_node = Puzzle(initial_state, None, None, 0, True) #fila de prioridade q = PriorityQueue() #adiciono na fila a funcao de avaliacao f=g+h, contador, e meu noh # a priridade é pelo menor valor da funcao q.put((start_node.evaluation_function, count, start_node)) #enquanto a fila nao for vazia while not q.empty(): #pego os 3 itens da lista node = q.get() #seleciono o noh node = node[2] #adciono o noh a lista de explorados explored.append(node.state) #verifica se o noh atual é o objetivo if node.goal_test(): return node.find_solution() #encontro todos so filhos do meu noh atual children = node.generate_child() #pra cada filho for child in children: #se n foi explorado if child.state not in explored: count += 1 #adiciona novo noh na fila q.put((child.evaluation_function, count, child)) return
def start_puzzle(self): self.picker = NumberPicker(self, thelist=self.app.strings_to_use) self.picker.set_type_hint(Gdk.WindowTypeHint.DIALOG) self.puzzle = Puzzle(self.app.puzzle_str, self.app.strings_to_use, self.app.font_scale) self.timer_started = datetime.datetime.utcnow() GObject.timeout_add(500, self.show_time_passed)
def hillclimbing(dim, iters): puz = Puzzle(dim) puz.printmovenums() puz.printdistances() initialevaluation = puz.evaluation evaluation = puz.evaluation for i in range(1, iters + 1): swp = puz.swaprandommovenum() # Evaluation dropped so revert swap if puz.evaluation < evaluation: print('\nEvaluation worsened... reverting swap') puz.revertswap(swp) continue else: evaluation = puz.evaluation print('\nIteration: ', i) puz.printswap(swp) print('Evaluation: ', evaluation) # UNCOMMENT IF YOU WANT FULL DETAILS OF SWAP # puz.printmovenums() # puz.printdistances() print('\n----- RESULTS -----') print('Initial Evaluation: ', initialevaluation) print('Final Evaluation: ', evaluation) return puz
def breadth_first_search(initial_state): #no inicial start_node = Puzzle(initial_state, None, None, 0) #verifica se o noh é o final if start_node.goal_test(): #se sim volta pra encontrar a solucao return start_node.find_solution() #fila pra auxilar na vusca do bfs q = Queue() #inicia com o noh inicial q.put(start_node) #lista de noh ja explorados explored = [] #enquanto existir nohs na fila while not(q.empty()): #pega o primeiro noh da fila node = q.get() #adicionada o noh na lista de explorados explored.append(node.state) #pego todos on noh filhos do meu noh atual children=node.generate_child() #pra cada filho na lista eu faço for child in children: #verifico se o filho encontrado ja foi explorado if child.state not in explored: #verifico se esse filho é meu objetivo if child.goal_test(): return child.find_solution() #adiciono o filho na lista de noh para explorar q.put(child) return
def test_incomplete_state(self): puzzle_input = [x for x in range(9)] for _ in range(10): while puzzle_input == [1,2,3,4,5,6,7,8,0]: random.shuffle(puzzle_input) puzzle = Puzzle(puzzle_input) self.assertFalse(puzzle.puzzle_check())
def swap_solve(self): """ swap solve is the method called when the swap_button is clicked. Once clicked, makes sure that the buttons representing the swapping puzzle tiles are a valid puzzle. If they are, it initializes the solving algorithm and sets the resulting solution set as the input to change from a puzzle frame to a soln frame. If the tiles aren't validated, produces an error message box. Returns ------- None. """ self.swap_btn['state'] = 'disabled' self.shift_btn['state'] = 'disabled' if Puzzle.validate(self._get_tiles()): puzzle = Puzzle(self._get_tiles()) puzzle = H.heuristic_swap(puzzle) soln_set = puzzle.get_soln_states() self.master.get_soln_frame(soln_set) else: #input that's failed validation throws error messagebox messagebox.showerror(title="Input error", message=ERROR_MSG) self.swap_btn['state'] = 'normal' self.shift_btn['state'] = 'normal'