def print_state_representation(self, state): horse, available_positions = state elements = { "C": horse, "X": available_positions, } print_grid(ROWS, COLUMNS, elements)
def print_result(result): elements = {} for position, value in result.items(): row, column = position elements[str(value)] = [(int(row), int(column))] print_grid(4, 4, elements, 3)
def print_state_representation(self, state): monkey, chair = state elements = { "M": [(0, monkey)], "C": [(0, chair)], "B": [(0, BANANA_POSITION)], } print_grid(1, ROOM_SLOTS, elements)
def print_state(self, state): elements = { str(element): [(row_i, column_i)] for row_i, row in enumerate(state) for column_i, element in enumerate(row) } print_grid(SQUARE_SIZE, SQUARE_SIZE, elements)
def print_state_representation(self, state): elements = defaultdict(list) for position, digit in enumerate(state): elements[str(digit)].append((0, position)) print("the elements are:", elements) print("the state is:", state) print_grid(1, 3, elements)
def print_result(result): elements = { "D": DOORS, "X": RESTRICTED_AREAS, } for robot, position in result.items(): elements[robot] = [position] print_grid(ROWS, COLUMNS, elements)
def print_state_representation(self, state): rat, food = state elements_to_print = { "R": [rat], "C": food, "XXX": WALLS_POSTITIONS, "E": [(3, 5)] } print_grid(ROWS, COLUMNS, elements_to_print)
def print_state_representation(self, state): hero, enemy, base = state elements = {"H": [hero]} if enemy: elements["He"] = [enemy] if base: elements["Be"] = [base] print_grid(ROWS, COLUMNS, elements)
def print_result(result): elements = defaultdict(list) for position, person in result.items(): elements[person].append(position) print_grid(BOARD_SIZE, BOARD_SIZE, elements, 9) values = list(result.values()) kings_qty = values.count(KING) soldiers_qty = values.count(SOLDIER) print("Total kings:", kings_qty) print("Total soldiers:", soldiers_qty)
def print_state_representation(self, state): cell_size = len(ALL_PEOPLE * 4) + 2 cells = 5 left, right, torch_side, time = state elements = { str(left): [(0, 0)], str(right): [(0, cells - 1)], "T": [(0, 1) if torch_side == 0 else (0, cells - 2)], str(time): [(0, round(cells / 2))], } print_grid(1, cells, elements, cell_size)
def print_state_representation(self, state): position, samples, helicopter_launched = state if helicopter_launched: robot_symbol = "R" else: robot_symbol = "RH" elements = { "X": INTERESTING_ZONES, "O": OBSTACLES, "S": samples, robot_symbol: [position], } print_grid(4, 4, elements)
def solve(grid, index, total): print("\nSudoku {}/{} : \n{}".format(index, total, print_grid(grid))) print("{}/{} : AC3 starting".format(index, total)) # instanciate Sudoku sudoku = Sudoku(grid) # launch AC-3 algorithm of it AC3_result = AC3(sudoku) # Sudoku has no solution if not AC3_result: print("{}/{} : this sudoku has no solution".format(index, total)) else: # check if AC-3 algorithm has solve the Sudoku if sudoku.isFinished(): print("{}/{} : AC3 was enough to solve this sudoku !".format( index, total)) print("{}/{} : Result: \n{}".format(index, total, sudoku)) # continue the resolution else: print("{}/{} : AC3 finished, Backtracking starting...".format( index, total)) assignment = {} # for the already known values for cell in sudoku.cells: if len(sudoku.possibilities[cell]) == 1: assignment[cell] = sudoku.possibilities[cell][0] # start backtracking assignment = recursive_backtrack_algorithm(assignment, sudoku) # merge the computed values for the cells at one place for cell in sudoku.possibilities: sudoku.possibilities[cell] = assignment[cell] if len( cell) > 1 else sudoku.possibilities[cell] if assignment: print("{}/{} : Result: \n{}".format(index, total, sudoku)) else: print("{}/{} : No solution exists".format(index, total))
# # ## ## ### # # # # # # """ m_pos = [] for y, row in enumerate(MONSTER.split('\n')): for x, c in enumerate(row): if c == '#': m_pos.append((x, y)) # Search for sea monsters! for image in orientations(IMG): occupied = set() for y in range(m * 8 - max(y for x, y in m_pos)): for x in range(m * 8 - max(x for x, y in m_pos)): if all(image[y + j][x + i] == '#' for i, j in m_pos): for i, j in m_pos: occupied.add((x + i, y + j)) if occupied: final_img = {} for y in range(m * 8): for x in range(m * 8): if image[y][x] == '#': final_img[x, y] = 'O' if (x, y) in occupied else '~' print_grid(final_img) print "\nWater roughness:", sum(1 for c in final_img.values() if c == '~')
if tentative_g_score < g_score[neighbor]: came_from[neighbor] = current g_score[neighbor] = tentative_g_score f_score[ neighbor] = tentative_g_score + heuristic_cost_estimate( neighbor, goal_position) # rebuild the path from the end while current in came_from: current = came_from[current] path.append(current) path.reverse() # return the path and the number of nodes expanded return path, len(closed_set) if __name__ == "__main__": files = ["part1/mediumMaze.txt", "part1/bigMaze.txt", "part1/openMaze.txt"] for file in files: grid, graph, pacman_position, goal_positions = utils.load_puzzle(file) path, nodes_expanded = a_star(graph, pacman_position, goal_positions[0]) utils.draw_solution_to_grid(grid, path) utils.print_grid(grid) print("path cost is : ", len(path) - 1) print("nodes expanded: ", nodes_expanded) print()
def _print_all(self): """ For debugging only. """ print_grid(self.all_view())
def _print_player_view(self): print_grid(self.get_player_grid_view())
def print_state_representation(self, state): elements = { "K": [state], "X": ENEMIES, } print_grid(BOARD_SIZE, BOARD_SIZE, elements)
def print_state_representation(self, state): elements = defaultdict(list) for vase_position, vase_content in enumerate(state): elements["X" * vase_content].append((0, vase_position)) print_grid(1, VASES, elements, VASES)
from utils import read_input, update_grid, print_grid, score_grid if __name__ == "__main__": grid = read_input() print_grid(grid) for _ in range(10): grid = update_grid(grid) print_grid(grid) ntree, nlumberjard, ntotal = score_grid(grid) print(f"There are {ntree} trees and {nlumberjard} for a value of {ntotal}")
# print "monster!" m_count += 1 for i, j in minds: occupied.add((x + i, y + j)) if m_count > 1: # print m_count, occupied final_monster = {} tot = 0 for y in range(m * 8): for x in range(m * 8): p = Point(x, y) if monster[y][x] == '#': if (x, y) not in occupied: tot += 1 final_monster[p] = '~' else: final_monster[p] = 'O' else: final_monster[p] = ' ' print_grid(final_monster) print print "Water roughness:", tot monster = rotated(monster) monster = transposed(monster)
for line in groups[1]: axis, n = line.split()[2].split('=') FOLDS.append((axis, int(n))) for i, (axis, n) in enumerate(FOLDS): new_dots = {} for p in DOTS: if axis == 'x': if p.x < n: new_dots[p] = '#' else: dx = abs(n - p.x) nx = n - dx new_dots[Point(nx, p.y)] = '#' else: if p.y < n: new_dots[p] = '#' else: dy = abs(n - p.y) ny = n - dy new_dots[Point(p.x, ny)] = '#' DOTS = new_dots if i == 0: print "Part 1:", len(DOTS) print "Part 2:\n", '\n'.join(print_grid(DOTS, quiet=True))