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