def test_solve_puzzle1(self): similarity = TaxonomySimilarity(self.example) puzzle = OddOneOutPuzzle("red", ['orange', 'lemon'], "citrus") expected = (0.5, 'citrus', 'red') assert solve_puzzle(puzzle, similarity) == expected
def doBasic(grid, size, iters, prob=0): grid2, value, solution = solver.solve_puzzle(grid, size) best_val = value best_found = False best_grid = list(grid) grid_gen = list(grid) best_grid_s = list(grid2) best_sol = solution iter_vals = [] for i in range(iters): rand_val = random.uniform(0, 1) prev_grid = deepcopy(grid_gen) grid_gen, grid_s, value_gen, solution_s = generate_grid(grid_gen, size) # print("BEST: " + str(best_val) + "\nGEN: " + str(value_gen) + "\nRAND: " + str(rand_val) + "\n------------") if value_gen >= best_val: if not value_gen == best_val: best_found = True best_val = value_gen best_grid = grid_gen best_grid_s = grid_s best_sol = solution_s elif best_found and rand_val > prob: grid_gen = prev_grid iter_vals.append(best_val) best_grid = np.array(best_grid).tolist() best_grid = [item for sublist in best_grid for item in sublist] best_grid_s = np.array(best_grid_s).tolist() best_grid_s = [item for sublist in best_grid_s for item in sublist] if best_val > 0: best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol # best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol + "\nIterations: " + str(i) + "\nCompute Time: " + "{0:.2f}".format(end - start) + "s" return best_grid, best_grid_s, best_val, best_sol, i + 1, iter_vals
def doRestart(grid, size, iters, iters_per): grid2, value, solution = solver.solve_puzzle(grid, size) best_val = value new_best = False best_grid = list(grid) grid_gen = list(grid) best_grid_s = list(grid2) best_sol = solution start = time.time() it = 0 iter_vals = [] for i in range(iters): grid_gen = generate_rand_grid(size) grid_g, grid_s, value_gen, solution_s, iters, iter_vals = doBasic( grid_gen, size, iters_per) it += iters if value_gen >= best_val: new_best = True best_val = value_gen best_grid = grid_gen best_grid_s = grid_s best_sol = solution_s iter_vals.append(best_val) end = time.time() best_grid = np.array(best_grid).tolist() best_grid = [item for sublist in best_grid for item in sublist] best_grid_s = np.array(best_grid_s).tolist() if len(best_grid_s) <= size: best_grid_s = [item for sublist in best_grid_s for item in sublist] if not new_best: best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol return best_grid, best_grid_s, best_val, best_sol, it, iter_vals
def test_solve_puzzle(self): similarity = TaxonomySimilarity(self.taxonomy) puzzle = OddOneOutPuzzle("Golden Retriever", [ "Poodle", "Irish Water Spaniel", "Wetterhoun", "Lagotto Romagnolo" ], "Water dogs") result = solve_puzzle(puzzle, similarity) assert result == (0.25, "Water dogs", "Golden Retriever")
def test_solve_puzzle(self): similarity = TaxonomySimilarity(self.taxonomy) puzzle = OddOneOutPuzzle("beagle", [ 'large_poodle', 'miniature_poodle', 'standard_poodle', 'toy_poodle' ], "poodle") result = solve_puzzle(puzzle, similarity) assert result == (0.25, 'poodle.n.01', 'beagle')
def test_solve_puzzle(self): similarity = TaxonomySimilarity(self.taxonomy) puzzle = OddOneOutPuzzle("'Turkey_Wrap'", ["'Candied_Sweet_Potatoes'", "'Holiday_Stuffing'", "'Whole,_Roasted_Turkey_with_Stuffing'", "'Yam_Casserole'"], "'Thanksgiving_recipes'") result = solve_puzzle(puzzle, similarity) assert result == (0.1, "'Thanksgiving_recipes'", "'Turkey_Wrap'")
def solve_puzzle_optimized(): rows, columns, tiles = get_board_state() solution = solve_puzzle(rows, columns, tiles) assert solution is not None, 'Failed to solve puzzle.' solution = optimize_solution(solution) if rospy.get_param('verbose'): print('\n') display_solution(rows, columns, solution, scale=4, offset=4) print('\n') for tile in solution: rospy.loginfo('Tile: ({}, {}), type={}, rotations={}'.format(tile.row, tile.column, tile.tile_name, tile.rotations)) return solution
def generate_rand_grid(n): while True: num_arr = [] for i in range(0, n): row = [] for j in range(0, n): row.append(random.randint(1, n - 1)) num_arr.append(row) num_arr[n - 1][n - 1] = 0 grid2, value, solution = solver.solve_puzzle(num_arr, n) if value > 0: return num_arr
def generate_grid(grid, size): orig_grid = list(grid) while True: rand_coord = [random.randint(0, size - 1), random.randint(0, size - 1)] rand_mag = random.randint(1, size - 1) if not (rand_coord == [size - 1, size - 1] ) and rand_mag != grid[rand_coord[0]][rand_coord[1]]: grid_gen = grid[:] grid_gen[rand_coord[0]][rand_coord[1]] = rand_mag grid_s, value_gen, solution_s = solver.solve_puzzle(grid_gen, size) if value_gen > 0: return grid_gen, grid_s, value_gen, solution_s else: grid = list(orig_grid)
def solve_a_puzzle(puz_file, component_list_path,mode=1,limit=300,score_adjust=20): print puz_file all_output,comps_eval = components_eval.run_all_components(puz_file, component_list_path, False) print "TESTING JFAN" print "ALL OUTPUT" print all_output print "COMPS EVAL" print comps_eval print " ____________________" p = puzzle.Puzzle(puz_file) print p.get_initial_state() print p.get_all_clues() print p.get_grid() solver_evaluation,solution = solver.solve_puzzle(p,all_output,mode,limit,score_adjust) return p.get_side_by_side_comparison(), solver_evaluation, comps_eval, solution
def solve_a_puzzle(puz_file, component_list_path,mode=1,limit=300,score_adjust=20, n=1, second_round=True): print puz_file picklefile = 'cache/' + puz_file.replace('.', '').replace('/', '') + '.dat' try: all_output, comps_eval = pickle.load(open(picklefile)) except IOError: # doesn't exist all_output,comps_eval = components_eval.run_all_components(puz_file, component_list_path, False) pickle.dump((all_output, comps_eval), open(picklefile, 'w')) print "####################### finished component ####################### " p = puzzle.Puzzle(puz_file) print p.get_initial_state() print p.get_all_clues() print p.get_grid() solver_evaluation,solution = solver.solve_puzzle(p,all_output,mode,limit,score_adjust, n=n, second_round=second_round) return p.get_side_by_side_comparison(), solver_evaluation, comps_eval, solution
def solve_a_puzzle(puz_file, component_list_path,mode=1,limit=300,score_adjust=20): start = time.time() print puz_file #get all candidate words all_output,comps_eval = components_eval.run_all_components(puz_file, component_list_path, False) #all_output,comps_eval = components_eval_multi.run_all_components(puz_file, component_list_path, False) p = puzzle.Puzzle(puz_file) print p.get_initial_state() print p.get_all_clues() print p.get_grid() solver_evaluation,solution = solver.solve_puzzle(p,all_output,mode,limit,score_adjust) end = time.time() print "Overall time: ", end-start return p.get_side_by_side_comparison(), solver_evaluation, comps_eval, solution
def doAnneal(grid, size, iters, temp_init, decay): grid2, value, solution = solver.solve_puzzle(grid, size) best_val = value prev_val = best_val best_found = False best_grid = list(grid) grid_gen = list(grid) best_grid_s = list(grid2) best_sol = solution accept_prob = 1 iter_vals = [] for i in range(iters): prev_grid = deepcopy(grid_gen) grid_gen, grid_s, value_gen, solution_s = generate_grid(grid_gen, size) try: accept_prob = math.exp((value_gen - prev_val) / (1.0 * temp_init)) except: accept_prob = 1 rand_val = random.uniform(0, 1) # print("Prev Val: " + str(prev_val) + "\nGen Val: " + str(value_gen) + "\nTemp: " + str(temp_init) + "\nAccept prob: " + str(accept_prob) + "\nRandom Value: " + str(rand_val) + "\n---------------") prev_val = value_gen if value_gen >= best_val: best_found = True best_val = value_gen best_grid = grid_gen best_grid_s = grid_s best_sol = solution_s elif best_found and rand_val > accept_prob: grid_gen = prev_grid temp_init *= decay iter_vals.append(best_val) temp_init = max(.01, temp_init) best_grid = np.array(best_grid).tolist() best_grid = [item for sublist in best_grid for item in sublist] best_grid_s = np.array(best_grid_s).tolist() best_grid_s = [item for sublist in best_grid_s for item in sublist] if best_val > 0: best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol # best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol + "\nIterations: " + str(i) + "\nCompute Time: " + "{0:.2f}".format(end - start) + "s" return best_grid, best_grid_s, best_val, best_sol, i + 1, iter_vals
def main(): """Run the end to end solver program. This will run a loop to continually re-capture images when SPACE is pressed until the solver finds a valid solution If a GPU is available, this will be used to run real-time inference displayed back on the input image at ~20 FPS """ logger.info('-' * 10 + ' new run ' + '-' * 10) # load puzzle semantic segmentation model, download from GCS if not done already p = Predictor('../models/best_model_3.pth') auto_capture = False while True: try: image = p.video_overlay(capture=True, pred_size=False, auto_capture=auto_capture) boxes = process_image(image, debug=True) # process captured image start_numbers, inequals = scan_images(boxes) # run ocr logger.debug(f'inequals: {inequals}') print('Solutions:') status = solve_puzzle(start_numbers, inequals) if status != 0: logger.info('-' * 10 + ' run exiting ' + '-' * 10) return status except KeyboardInterrupt: raise except Exception: auto_capture = True pass
def solve(): print(clusters) solution = solver.solve_puzzle(clusters) return json.dumps(str(solution))
used[tile] = (new_letter, new_color) current += 1 letter, color = used[tile] print(colored(letter, color), end='') print('') parser = argparse.ArgumentParser() parser.add_argument('difficulty', choices=list(puzzles.keys())) parser.add_argument('level', type=int) args = parser.parse_args() difficulty = args.difficulty level = args.level - 1 if (level not in range(len(puzzles[difficulty]))) or ( puzzles[difficulty][level]['puzzle'] is None): parser.error( f"Level {args.level} does not have a puzzle for difficulty {difficulty}" ) begin = time.monotonic() puzzle = puzzles[difficulty][level]['puzzle'] solution = solve_puzzle(puzzle) end = time.monotonic() print_puzzle(puzzle) print( f'Solved puzzle {args.level} of the {args.difficulty} levels in {round(end - begin, 2)} seconds' ) print_solution(solution)
def main(): global solved, run solved = False DISPLAY_WI, DISPLAY_HE = 680, 570 FPS = 30 WIN = pygame.display.set_mode((DISPLAY_WI, DISPLAY_HE)) pygame.display.set_caption("My Sudoku") clock = pygame.time.Clock() main_font = pygame.font.SysFont("comicsans", 30) # Variables mistakes = 0 won = False board = make_puzzle() grid = Grid(board) solved_board = deepcopy(board) solve_puzzle(solved_board) run = True def redraw_window(): WIN.fill((200, 200, 200)) # Draw grid if not solved: grid.draw(WIN) else: solved_grid = Grid(solved_board) solved_grid.draw(WIN) # Draw text mistakes_label = main_font.render(f"Mistakes: {mistakes}", True, (255, 255, 255)) WIN.blit(mistakes_label, (10, DISPLAY_HE - 30)) # Draw buttons button(WIN, "New Puzzle", DISPLAY_WI - 135, 10, 120, 50, (255, 255, 255), (127, 152, 240), new_puzzle) button(WIN, "Solve Puzzle", DISPLAY_WI - 135, 70, 120, 50, (255, 255, 255), (127, 152, 240), do_solve) button(WIN, "Quit Game", DISPLAY_WI - 135, DISPLAY_HE - 90, 120, 50, (255, 255, 255), (127, 152, 240), quit_game) # Draw victory text if won: victory_label = main_font.render("Completed", True, (127, 152, 240)) WIN.blit(victory_label, (DISPLAY_WI - victory_label.get_width() - 30, 130)) # Update pygame.display.update() while run: clock.tick(FPS) redraw_window() # Activate select function in grid grid.select() # Key press for event in pygame.event.get(): if event.type == pygame.QUIT: run = False if event.type == pygame.KEYDOWN and grid.selected_square.real_value == 0: if event.key == pygame.K_1: grid.selected_square.temp_value = 1 if event.key == pygame.K_2: grid.selected_square.temp_value = 2 if event.key == pygame.K_3: grid.selected_square.temp_value = 3 if event.key == pygame.K_4: grid.selected_square.temp_value = 4 if event.key == pygame.K_5: grid.selected_square.temp_value = 5 if event.key == pygame.K_6: grid.selected_square.temp_value = 6 if event.key == pygame.K_7: grid.selected_square.temp_value = 7 if event.key == pygame.K_8: grid.selected_square.temp_value = 8 if event.key == pygame.K_9: grid.selected_square.temp_value = 9 if event.key == pygame.K_DELETE: grid.selected_square.temp_value = 0 if event.key == pygame.K_BACKSPACE: grid.selected_square.temp_value = 0 if event.key == pygame.K_RETURN and grid.selected_square.temp_value != 0: row = grid.selected_square.row col = grid.selected_square.col if grid.selected_square.temp_value == solved_board[row][ col]: grid.selected_square.real_value = grid.selected_square.temp_value grid.selected_square.temp_value = 0 board[row][col] = solved_board[row][col] else: mistakes += 1 grid.selected_square.temp_value = 0 if 0 not in [board[row][col] for col in range(9) for row in range(9)]: won = True
def setUp(self): self.p = solve_puzzle('000801000000000430500000000000070800000000100020030000600000075003400000000200600', "Puzzle Name")
def test_search_solve(): solution = solver.solve_puzzle(search_puzzle) str_solution = solver.convert_solution(solution) assert str_solution == search_solution
def test_solve_puzzle3(self): similarity = TaxonomySimilarity(self.example) puzzle = OddOneOutPuzzle("red", ['orange', 'lime'], "citrus") assert solve_puzzle(puzzle, similarity) is None
def setUp(self): self.p = solve_puzzle('286000004530208100000030082000400610002315800054006000640070000005904068300000479', "Puzzle Name")
def test_solve_puzzle2(self): similarity = TaxonomySimilarity(self.example) puzzle = OddOneOutPuzzle("apple", ['orange', 'peach', 'red'], "color") assert solve_puzzle(puzzle, similarity) is None
def doGenetic(grid, size, iters, initial_pop, num_child, mutation_rate): current_pop = [] if initial_pop % 2 == 1: initial_pop += 1 for i in range(initial_pop): grid_gen, value_gen = generate_rand_grid(size) current_pop.append([grid_gen, value_gen]) current_pop.sort(key=itemgetter(1), reverse=True) iter_vals = [] for j in range(iters): children = [] for k in range(0, len(current_pop) - 1, 2): for ch in range(num_child): curr_parent1 = deepcopy(current_pop[k][0]) curr_parent2 = deepcopy(current_pop[k + 1][0]) while True: rand_x = random.sample(range(0, (size)), 2) rand_y = random.sample(range(0, (size)), 2) rand_x_start = rand_x[0] rand_x_end = rand_x[1] rand_y_start = rand_y[0] rand_y_end = rand_y[1] if rand_x_start >= rand_x_end: temp = rand_x_start rand_x_start = rand_x_end rand_x_end = temp if rand_y_start >= rand_y_end: temp = rand_y_start rand_y_start = rand_y_end rand_y_end = temp if [rand_x_end, rand_y_end] != [size - 1, size - 1]: break tmp_chromo1 = [] tmp_chromo2 = [] for num in range(rand_x_start, rand_x_end): for num2 in range(rand_y_start, rand_y_end): tmp_chromo1.append(curr_parent1[num][num2]) tmp_chromo2.append(curr_parent2[num][num2]) count = 0 rand_val1 = random.uniform(0, 1) rand_val2 = random.uniform(0, 1) for num in range(rand_x_start, rand_x_end): for num2 in range(rand_y_start, rand_y_end): if rand_val1 < mutation_rate: tmp_chromo1[count] = random.randint(1, (size) - 1) if rand_val2 < mutation_rate: tmp_chromo2[count] = random.randint(1, (size) - 1) curr_parent1[num][num2] = tmp_chromo2[count] curr_parent2[num][num2] = tmp_chromo1[count] count += 1 children.append(curr_parent1) children.append(curr_parent2) if len(children) % 2 == 1: children = children[:len(children) - 2] current_pop = [] for l in children: grid2, value, solution = solver.solve_puzzle(l, size) current_pop.append([l, value]) current_pop.sort(key=itemgetter(1), reverse=True) iter_vals.append(current_pop[0][1]) # for i in current_pop: # print(i[1]) # print("--------------------") current_pop = current_pop[:initial_pop] best_grid = np.array(current_pop[-1][0]).tolist() best_grid_s, best_val, best_sol = solver.solve_puzzle(best_grid, size) best_grid = [item for sublist in best_grid for item in sublist] best_grid_s = np.array(best_grid_s).tolist() best_grid_s = [item for sublist in best_grid_s for item in sublist] if best_val > 0: best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol # best_sol = "Puzzle Value: " + str(best_val) + "\n" + best_sol + "\nIterations: " + str(i) + "\nCompute Time: " + "{0:.2f}".format(end - start) + "s" return best_grid, best_grid_s, best_val, best_sol, iter_vals