for e in new_cords_equipment:
min_time = move_time(current_time,
new_cords_equipment, e)
if old_time[e] > min_time:
old_time[e] = min_time
changed = True
if changed:
new_positions.add(new_cords)
positions = new_positions
return required_time[target][TORCH]
def solve(m):
return m.shortest_path(m.target)
def parse(lines):
depth = int(lines[0].split(' ')[1])
target = tuple(map(int, lines[1].split(' ')[1].split(',')))
return Maze(depth, target)
if __name__ == '__main__':
import doctest
print(doctest.testmod())
print(solve(parse(readlines())))
position=< 8, 9> velocity=< 0, -1>
position=< 3, 3> velocity=<-1, 1>
position=< 0, 5> velocity=< 0, -1>
position=<-2, 2> velocity=< 2, 0>
position=< 5, -2> velocity=< 1, 2>
position=< 1, 4> velocity=< 2, 1>
position=<-2, 7> velocity=< 2, -2>
position=< 3, 6> velocity=<-1, -1>
position=< 5, 0> velocity=< 1, 0>
position=<-6, 0> velocity=< 2, 0>
position=< 5, 9> velocity=< 1, -2>
position=<14, 7> velocity=<-2, 0>
position=<-3, 6> velocity=< 2, -1>"""
if __name__ == '__main__':
stars = [Star.parse(line) for line in readlines()]
sky = Sky(stars)
previous_diff_x = sky.max_x - sky.min_x
i = 0
while True:
diff_x = sky.max_x - sky.min_x
if diff_x > previous_diff_x:
print(previous_sky)
break
previous_diff_x = diff_x
previous_sky = sky
sky = sky.tick()
i += 1
if i % 1000 == 0:
from collections import Counter
from aoc2018 import readlines
def _generate_all_but_one_letter(word):
for i in range(len(word)):
yield (i, word[:i] + word[i + 1:])
def exercise(lines):
seen = Counter()
for line in lines:
seen.update(_generate_all_but_one_letter(line))
for (_, x), count in seen.items():
if count == 2:
return x
if __name__ == '__main__':
print(exercise(readlines()))
from aoc2018 import readlines
from aoc2018.day12e1 import Pots
if __name__ == '__main__':
lines = list(readlines())
pots = Pots.parse(lines)
previous_pots = None
already_seen_pots = set()
already_seen_pots.add(str(pots))
generation = 0
while True:
generation += 1
previous_pots = pots
pots = pots.next_generation()
str_pots = str(pots)
if str_pots in already_seen_pots:
break
already_seen_pots.add(str_pots)
desired_generation = 50000000000
previous_value = previous_pots.value()
value_difference = pots.value() - previous_value
missing_generations = desired_generation - generation
print(missing_generations * value_difference + pots.value())
9
>>> solve("59414")
2018
>>> solve("92510")
18
"""
recipes = [3, 7]
elf1 = 0
elf2 = 1
searched_sequence = deque([int(c) for c in searched_sequence])
last_recipes = deque(maxlen=len(searched_sequence))
while True:
s = recipes[elf1] + recipes[elf2]
for c in str(s):
recipes.append(int(c))
last_recipes.append(int(c))
if searched_sequence == last_recipes:
return len(recipes) - len(last_recipes)
elf1 = (elf1 + recipes[elf1] + 1) % len(recipes)
elf2 = (elf2 + recipes[elf2] + 1) % len(recipes)
if __name__ == '__main__':
# import doctest
# print(doctest.testmod())
print(solve(list(readlines())[0]))
elif char == '+':
maze[cords] = Roads.INTERSECTION
elif char == '/':
maze[cords] = Roads.TURN_UP
else:
maze[cords] = Roads.TURN_DOWN
elif char in Paths.CARTS:
if char in ['<', '>']:
maze[cords] = Roads.HORIZONTAL
else:
maze[cords] = Roads.VERTICAL
direction = Paths.DIRECTIONS[char]
carts[cords] = Cart(cords, direction)
return Paths(maze, carts, max_x + 1, max_y + 1)
lines = """/->-\
| | /----\
| /-+--+-\ |
| | | | v |
\-+-/ \-+--/
\------/ """.split('\n')
if __name__ == '__main__':
import doctest
print(doctest.testmod())
p = Paths.parse(readlines(strip=False))
while True:
p.tick()
cords = (x, y)
if cords == (500, 0):
row.append('+')
elif cords in self.clay:
row.append('#')
elif cords in self.water:
row.append('~')
elif cords in self.water_streams:
row.append('|')
else:
row.append(' ')
rows.append(''.join(row))
return '\n'.join(rows)
lines = """x=495, y=2..7
y=7, x=495..501
x=501, y=3..7
x=498, y=2..4
x=506, y=1..2
x=498, y=10..13
x=504, y=10..13
y=13, x=498..504""".split('\n')
if __name__ == '__main__':
import doctest
print(doctest.testmod())
clay = Clay(*parse(readlines()))
print(clay.solve())
from aoc2018 import readlines
from aoc2018.day11e1 import Grid
if __name__ == '__main__':
serial = int(list(readlines())[0])
g = Grid(serial)
sums = []
for i in range(1, 301):
sums.append((g.max_power_sum(i), i))
sums = sorted(sums, reverse=True)
((_, (x, y)), i) = sums[0]
print('%d,%d,%d' % (x, y, i))
for before, instruction, after in triples:
works = 0
for o in operations:
if after == o(list(before), *instruction[1:]):
operation_mapping[instruction[0]].add(o)
return operation_mapping
def untangle_mapping(mapping):
already_matched = set()
keys_to_check = deque(mapping.keys())
while keys_to_check:
key = keys_to_check.pop()
mapping[key] -= already_matched
if len(mapping[key]) == 1:
already_matched |= mapping[key]
else:
keys_to_check.appendleft(key)
for key, operations in mapping.items():
mapping[key] = operations.pop()
if __name__ == '__main__':
import doctest
print(doctest.testmod())
tripples, program = parse(readlines())
print(solve(tripples, program))
continue
match = AFTER_RE.match(line)
if match:
after = [int(token) for token in match.groups()]
triples.append((before, instruction, after))
program = []
continue
instruction = [int(token) for token in line.split(' ')]
program.append(instruction)
return triples, program
def solve(triples):
how_many = 0
for before, instruction, after in triples:
works = 0
for o in operations:
if after == o(list(before), *instruction[1:]):
works += 1
if works >= 3:
how_many += 1
return how_many
if __name__ == '__main__':
import doctest
print(doctest.testmod())
triples, _ = parse(readlines())
print(solve(triples))
consumed_numbers = 2
for i in range(num_children):
child_node, child_consumed = build_node(index + consumed_numbers,
numbers[consumed_numbers:])
consumed_numbers += child_consumed
node.add_child(child_node)
node.add_metadata(numbers[consumed_numbers:consumed_numbers +
metadata_size])
consumed_numbers += metadata_size
return node, consumed_numbers
return build_node(0, numbers)
if __name__ == '__main__':
line = list(readlines())[0]
tree, consumed = parse(line)
print(line.split(), consumed)
nodes = [tree]
summed_metadata = 0
while nodes:
node = nodes.pop()
nodes.extend(node.children)
summed_metadata += sum(node.metadata)
print(summed_metadata)
print(tree.value())
line = line.split(' ')
steps[line[7]].after(steps[line[1]])
steps[line[1]].before(steps[line[7]])
return steps
def enqueue_next_steps(ready_step, sequence, queue):
for future_step in ready_step.required_by:
already_done = future_step in sequence
already_enqueued = future_step in queue
all_required_steps_done = all([
required_step in sequence for required_step in future_step.requires
])
if not already_done and not already_enqueued and all_required_steps_done:
queue.append(future_step)
queue.sort(reverse=True)
if __name__ == '__main__':
steps = parse(readlines(), Steps())
sequence = []
queue = steps.ready_to_go(sequence)
while queue:
next_step = queue.pop()
sequence.append(next_step)
enqueue_next_steps(next_step, sequence, queue)
print(''.join([s.name for s in sequence]))
from aoc2018 import readlines
from aoc2018.day09e1 import Game
if __name__ == '__main__':
tokens = list(readlines())[0].split()
players = int(tokens[0])
max_marble = int(tokens[6]) * 100
game = Game(players, max_marble)
while not game.is_finished():
game.turn()
print(game.highest_score())
points_to_check.add(p)
p = Point(point.x, point.y + 1)
if p not in checked:
points_to_check.add(p)
p = Point(point.x + 1, point.y)
if p not in checked:
points_to_check.add(p)
p = Point(point.x, point.y - 1)
if p not in checked:
points_to_check.add(p)
return size
if __name__ == '__main__':
lines = """1, 1
1, 6
8, 3
3, 4
5, 5
8, 9""".split('\n')
points, max_x, max_y = parse(readlines())
result = []
for p in points:
result.append((check(p, points), p))
print("\n".join(map(str, reversed(sorted(result)))))
return LUMBERYARD
return TREE
if lumber_count > 0 and tree_count > 0:
return LUMBERYARD
return EMPTY
def count(data, item):
return len([1 for v in data.values() if v == item])
def solve(lines):
data = parse(lines)
for i in range(10):
data = {
cords: evolve(data, cords, item)
for cords, item in data.items()
}
return count(data, TREE) * count(data, LUMBERYARD)
if __name__ == '__main__':
import doctest
print(doctest.testmod())
print(solve(readlines()))
if __name__ == '__main__':
import doctest
print(doctest.testmod())
loosing_power = 3
winning_power = 200
outcomes = {}
while loosing_power + 1 != winning_power:
difference = winning_power - loosing_power
elves_power = loosing_power + difference // 2
print('Attempting fight with elves power %d.' % elves_power)
m = parse(readlines(), elves_power)
elves_before = len([u for u in m.units if u.is_elf and u.is_alive])
outcome = simulate(m)
outcomes[elves_power] = outcome
elves_after = len([u for u in m.units if u.is_elf and u.is_alive])
all_elves_survived = elves_before == elves_after
if all_elves_survived:
print('All elves survived when their power was %d.' % elves_power)
winning_power = elves_power
else:
print('%d elves died when their power was %d.' %
(elves_before - elves_after, elves_power))
loosing_power = elves_power
print(outcomes[winning_power])
continue
if falls_asleep is None:
raise Exception("xxx", guard)
guards[guard].update(range(falls_asleep, when.minute))
falls_asleep = None
id, _ = sorted(guards.items(), key=lambda kv: kv[1].how_many,
reverse=True)[0]
minute, _ = sorted(guards[id].stats.items(),
key=lambda kv: kv[1],
reverse=True)[0]
print(id, minute, id * minute)
most_frequent_minute_for_guard = list(
map(
lambda kv:
(kv[0],
sorted(kv[1].stats.items(), key=lambda m: m[1], reverse=True)[0]),
guards.items()))
id, (minute, _) = sorted(most_frequent_minute_for_guard,
key=lambda g: g[1][1],
reverse=True)[0]
print(id, minute, id * minute)
if __name__ == '__main__':
exercise(readlines())
#..G#E#
#.....#
#######""".split('\n')
lines1 = """#######
#G..#E#
#E#E.E#
#G.##.#
#...#E#
#...E.#
#######""".split('\n')
def simulate(maze):
rounds = 0
while True:
maze.tick()
if not maze.has_enemies:
break
rounds += 1
return sum([u.hp for u in maze.units if u.is_alive]) * rounds
if __name__ == '__main__':
import doctest
print(doctest.testmod())
m = parse(readlines())
print(simulate(m))
