def main() -> None:
serial_number = int(next(get_data(today)))
grid = [[cell_power_level(x, y, serial_number) for x in range(1, 301)]
for y in range(1, 301)]
print(f'{today} star 1 = {fmt(max(measure_grid_power(grid)))}')
print(f'{today} star 2 = {variable_grid_size(grid)}')
def main() -> None:
track = list(get_data(today))
carts = setup_carts(track)
it = simulate(carts)
print(f'{today} star 1 = {next(it)}')
print(f'{today} star 2 = {deque(it, maxlen = 1).pop()}')
def main() -> None:
data = list(get_data(today, [('func', fun)]))
star1, m = map_all_claims(data)
print(f'{today} star 1 = {star1}')
all_claimers = [claimer for claimer, _, _ in data]
print(f'{today} star 2 = {find_unique_claim(m, all_claimers)}')
def main() -> None:
test_data, source_code = parse_input(list(get_data(today)))
star1, opcode_table = reverse_engineer(test_data, cpu)
program = compile_program(source_code, opcode_table)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {execute(program, cpu)}')
def main() -> None:
all_components = set(get_data(today, [('func', parse)]))
loops = set((a,b) for a,b in all_components if a==b)
table = set(bridges(all_components-loops, set(a for a, _ in loops)))
print(f'{today} star 1 = {max(table, key=itemgetter(1))[1]}')
print(f'{today} star 2 = {max(table)[1]}')
def main():
global forest, map_width, slope_length
forest = list(get_data(today))
slope_length, map_width = len(forest), len(forest[0])
star1, star2 = solve()
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
instrs = {
'sub': sub, 'set': put,
'mul': mul, 'jnz': jnz
}
stack = list(get_data(today, [('asmbunny', instrs)]))
print(f'{today} star 1 = {run(stack)}')
print(f'{today} star 2 = {run(stack, star2=True)}')
def main() -> None:
data = get_data(today)
gs = tuple()
for x in data:
gs += int(x[-3:]),
star1, star2 = duel(*gs)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
data = list(get_data(today))
initial_state, _, *rules = data
initial_state = initial_state[15:]
rules = {rule[:5]: rule[-1] for rule in rules}
it = garden_generator(initial_state, rules)
print(f'{today} star 1 = {next(it)}')
print(f'{today} star 2 = {next(it)}')
def main() -> None:
path_regex = next(get_data(today))[1:-1]
build_map(path_regex)
path_lengths = shortest_path_length(graph, Point(0, 0)).values()
print(f'{today} star 1 = {max(path_lengths)}')
print(
f'{today} star 2 = {sum(1 for length in path_lengths if length >= 1000)}'
)
def main() -> None:
data = get_data(today, [('split', '\t'), ('func', fmt)])
star1 = 0
star2 = 0
for row in data:
star1 += row[-1]-row[0] # sorted list
star2 += find_even_div(row)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
instructions = get_data(today, [('func', lambda l: (l[5], l[-13]))])
steps = defaultdict(list)
for required, before in sorted(instructions):
steps[before] += [required]
steps[required] += []
print(f'{today} star 1 = {singlesledded(steps)}')
print(f'{today} star 2 = {multisledded(steps)}')
def main() -> None:
particles = list(get_data(today, [('func', Particle)]))
time, result = calculate_sky_message(particles)
if result is None:
print('for cooler results, please install Pillow and pytesseract\n' \
+ '(along with a tesseract-ocr distribution)\n')
print(f'{today} star 1 printed in block letters')
else:
print(f'{today} star 1 = {result}')
print(f'{today} star 2 = {time}')
def main() -> None:
artbook = get_data(today, [('func', parse)])
for pattern, becomes in artbook:
book[pattern] = becomes
for _ in range(1, 4):
pattern = rotate(pattern)
book[pattern] = becomes
book[mirror(pattern)] = becomes
grid = ['.#.', '..#', '###']
print(f'{today} star 1 = {pixels(grid)}')
print(f'{today} star 2 = {pixels(grid, 18)}')
def main() -> None:
original_input.extend(list(get_data(today)))
reset()
infection_eliminated = run()
print(f'{today} star 1 = {total_units()}')
boost = 1
while not infection_eliminated:
reset(boost)
infection_eliminated = run()
boost += 1
print(f'{today} star 2 = {total_units()}')
def main() -> None:
global the_map
data = list(get_data(today, base_ops + [('func', list)]))
reference = {}
for y, row in enumerate(data):
for x, val in enumerate(row):
the_map[(x, y)] = val
reference[(x, y)] = val
start_pos = len(data) // 2, len(data) // 2
print(f'{today} star 1 = {infect(start_pos)}')
the_map = reference
print(f'{today} star 2 = {infect(start_pos, evolved=True)}')
def main() -> None:
machine = {}
for l in get_data(today, [('func', lambda l: l.strip())]):
if l[:3] == 'Beg': machine['start'] = l[-2]
elif l[:3] == 'Per': machine['check'] = int(l.split(' ')[-2])
elif l[:3] == 'In ': c_s, machine[c_s] = l[-2], {}
elif l[:3] == 'If ': c_v = int(l[-2])
elif l[:3] == '- W': machine[c_s][c_v] = (int(l[-2]), )
elif l[:3] == '- M': machine[c_s][c_v] += (1 if l[-6] == 'r' else -1, )
elif l[:3] == '- C': machine[c_s][c_v] += (l[-2], )
print(f'{today} star 1 = {turing(machine)}')
print(f'{today} star 2 = Merry Christmas!')
def main() -> None:
data = get_data(today, base_ops + [('split', ' '), ('func', sorted)])
star1 = 0
star2 = 0
for passphrase in data:
s1, s2 = valid(passphrase)
if s1: star1 += 1
if s2: star2 += 1
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
global target, x, y
target = int(list(get_data(today))[0])
side_length = 2
while not star1:
y -= 1
for direction in Direction:
move(side_length, direction)
x += 1
side_length += 2
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
instrs = {
'snd': snd,
'set': put,
'add': add,
'mul': mul,
'mod': mod,
'rcv': rcv,
'jgz': jgz
}
stack = list(get_data(today, [('asmbunny', instrs)]))
print(f'{today} star 1 = {run(stack)}')
print(f'{today} star 2 = {run(stack, threads=2)}')
def main() -> None:
global depth, target
it = get_data(today, [('split', ' '), ('func', lambda l: l[1].strip())])
depth = int(next(it))
target = Point(*map(int, next(it).split(',')))
cavern.extend(
Point(x, y)
for x, y in product(range(target.x + 50), range(target.y + 50)))
calculate_erosion()
print(
f'{today} star 1 = {sum([erosion[p] % 3 for p in erosion if p <= target])}'
)
print(f'{today} star 2 = {rescue()}')
def main():
data = list(get_data(today, [('func', Node)]))
carried = []
for x in data:
if len(x.carrying) != 0:
carried += x.carrying
root = None
for x in data:
if x.name not in carried:
root = build_tree(x, data)
print(f'{today} star 1 = {root.name}')
print(f'{today} star 2 = {balance(root)}')
def main() -> None:
global ymax, ymin
inp = list(get_data(today, [('func', parse)]))
for p in [p for ps in inp for p in ps]:
clay[p] = True
ymax = max(clay).y
ymin = min(clay).y
flow(Point(500, 0))
print(
f'{today} star 1 = {len([p for p in settled | flowing if ymin <= p.y <= ymax])}'
)
print(
f'{today} star 2 = {len([p for p in settled if ymin <= p.y <= ymax])}')
def main() -> None:
stream = next(get_data(today))
star1, star2 = process(stream)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
def main() -> None:
data = get_data(today, [('split', ',')])
routine = list(next(data))
progs = [chr(x) for x in range(ord('a'), ord('p') + 1)]
print(f'{today} star 1 = {dance(routine, progs)}')
print(f'{today} star 2 = {dance(routine, progs, 1000000000)}')
def main() -> None:
r2_value = int(list(get_data(today))[8].split()[1])
it = optimised_activation_system(r2_value)
print(f'{today} star 1 = {next(it)}')
print(f'{today} star 2 = {deque(it, maxlen = 1).pop()}')
def main() -> None:
log_entries = [fmt(entry) for entry in sorted(list(get_data(today)))]
star1, minutes_sleeping = find_lazy_guard(log_entries)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {find_consistently_lazy_guard(minutes_sleeping)}')
def main() -> None:
it = game_runner(list(get_data(today)))
print(f'{today} star 1 = {next(it)}')
print(f'{today} star 2 = {next(it)}')
def main() -> None:
data = get_data(today, [('split', ' '), ('func', Instruction)])
star2 = solve(data)
print(f'{today} star 1 = {regs[max(regs, key=regs.get)]}')
print(f'{today} star 2 = {star2}')
def main() -> None:
data = iter(next(get_data(today, [('split', ' '), ('map', int)])))
star1, star2 = parse_child(data)
print(f'{today} star 1 = {star1}')
print(f'{today} star 2 = {star2}')
