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))
