async def intcode_eval(auto_input: List[int] = None) -> int:
memory = [int(i) for i in utils.load_data(5)[0].split(",")]
processor = IntCodeProcessor(memory)
for i in auto_input:
await processor.input(i)
return await processor.run(return_last_output=True)
def part1() -> int:
total_fuel_mass = 0
for module_mass in utils.load_data(1):
module_mass = int(module_mass)
total_fuel_mass += fuel_needed(module_mass)
return total_fuel_mass
def part2() -> int:
total_fuel_mass = 0
for module_mass in utils.load_data(1):
module_mass = int(module_mass)
extra_fuel_mass = fuel_needed(module_mass)
total_fuel_mass += extra_fuel_mass
while extra_fuel_mass := fuel_needed(extra_fuel_mass):
total_fuel_mass += extra_fuel_mass
def load_data():
orbits = {}
inverse_orbits = {}
for d in utils.load_data(6):
centre, orbiter = d.split(")")
orbits[orbiter] = centre
inverse_orbits.setdefault(centre, []).append(orbiter)
return orbits, inverse_orbits
def part1():
data = utils.load_data(8)[0]
width = 25
height = 6
pixels_per_layer = width * height
min_zero_layer = None
for layer in chunked(data, pixels_per_layer):
layer_counter = Counter(layer)
if min_zero_layer is None or layer_counter["0"] < min_zero_layer["0"]:
min_zero_layer = layer_counter
return min_zero_layer["1"] * min_zero_layer["2"]
def part2():
data = utils.load_data(8)[0]
width = 25
height = 6
pixels_per_layer = width * height
output_map = {"0": " ", "1": "#"}
output: List[Optional[str]] = [None] * pixels_per_layer
for layer in chunked(data, pixels_per_layer):
for i, value in enumerate(layer):
if output[i] is None and value != "2":
output[i] = output_map[value]
for row in chunked(output, width):
print("".join(row))
def part2() -> int:
data = utils.load_data(3)
wire1 = data[0].split(",")
wire2 = data[1].split(",")
w1_points = get_points(wire1)
w2_points = get_points(wire2)
intersections = set(w1_points).intersection(set(w2_points))
min_dist = None
for intersection in intersections:
dist = w1_points[intersection] + w2_points[intersection]
min_dist = utils.safe_min(min_dist, dist)
return min_dist
def intcode_eval(noun: int, verb: int) -> int:
data = utils.load_data(2)[0]
memory = [int(i) for i in data.split(",")]
memory[1] = noun
memory[2] = verb
ip = 0
while (opcode := memory[ip]) in OPCODES:
nargs, op = OPCODES[opcode]
args = memory[ip + 1:ip + nargs]
result = op(memory[args[0]], memory[args[1]])
memory[args[2]] = result
ip += nargs
async def intcode_eval(phase_settings) -> int:
memory = [int(i) for i in utils.load_data(7)[0].split(",")]
processors = []
for phase_setting in phase_settings:
processor = IntCodeProcessor(memory)
processors.append(processor)
asyncio.create_task(processor.run())
await processor.input(phase_setting)
output = 0
for processor in cycle(processors):
if processor.state is RunState.TERMINATED:
break
await processor.input(output)
output = await processor.output()
return output
def main() -> None:
data = utils.load_data(10)
asteroid_coords = []
for y, row in enumerate(data):
for x, sector in enumerate(row):
if sector == "#":
asteroid_coords.append((x, y))
visible_asteroids = {}
all_vectors = {}
for origin, destination in product(asteroid_coords, asteroid_coords):
if origin == destination:
continue
vector = Vector(origin, destination)
visible_asteroids.setdefault(origin, set()).add(vector.direction)
all_vectors.setdefault(origin, []).append(vector)
max_visible, max_coord = max(
(len(directions), coord) for coord, directions in visible_asteroids.items()
)
print(f"Part 1: {max_visible}")
other_asteroids = sorted(all_vectors[max_coord], key=lambda x: x.magnitude)
asteroids_by_angle = {}
for asteroid in other_asteroids:
asteroids_by_angle.setdefault(asteroid.angle, collections.deque()).append(
asteroid.destination
)
count = 0
while asteroids_by_angle:
for angle in list(sorted(asteroids_by_angle.keys())):
coords = asteroids_by_angle[angle]
count += 1
coord = coords.popleft()
if count == 200:
print(f"Part 2: {100 * coord[0] + coord[1]}")
return
if not len(coords):
asteroids_by_angle.pop(angle)
def part1() -> int:
data = utils.load_data(3)
wire1 = data[0].split(",")
wire2 = data[1].split(",")
origin = (0, 0)
w1_points = get_points(wire1, origin)
w2_points = get_points(wire2, origin)
intersections = set(w1_points).intersection(set(w2_points))
min_dist = None
for intersection in intersections:
# if intersection == origin:
# continue
dist = manhattan_distance(intersection, origin)
min_dist = utils.safe_min(min_dist, dist)
return min_dist
async def run():
memory = [int(i) for i in utils.load_data(13)[0].split(",")]
arcade = Arcade(memory, add_credit=True)
result = await arcade.run()
return result
async def run(start):
memory = [int(i) for i in utils.load_data(11)[0].split(",")]
painter = Painter(memory, start)
result = await painter.run()
print(str(painter))
return result
