def part2():
for noun in range(100):
for verb in range(100):
data = get_input(2)
# before running the program, replace position 1 with the value 12 and replace position 2 with the value 2
data[1] = noun
data[2] = verb
for instructions in map(
lambda digits: InstructionSet(*digits),
(x for x in (data[i:i + 4] for i in range(0, len(data), 4)))):
if instructions.opcode == 1:
data[instructions.dest_pos] = data[
instructions.pos1] + data[instructions.pos2]
elif instructions.opcode == 2:
data[instructions.dest_pos] = data[
instructions.pos1] * data[instructions.pos2]
elif instructions.opcode == 99:
# print("Process complete.\nFinal state: {}".format(data))
break
else:
print("Execution error! Unknown opcode: {}".format(
instructions.opcode))
if data[0] == 19690720:
return 100 * noun + verb
def part2():
wires, d = [], {}
wires.extend(list(map(lambda wire: wire.split(','), get_input(3))))
for i, wire in enumerate(wires):
x = y = steps = 0
for instruction in wire:
direction, distance = instruction[0], int(instruction[1:])
if direction in ('L', 'R'):
delta = (1 if direction == 'R' else -1, 0)
else:
delta = (0, 1 if direction == 'U' else -1)
for _ in range(distance):
steps += 1
x += delta[0]
y += delta[1]
if (x, y) not in d:
d[(x, y)] = {'seen': set(), 'steps': {i: steps}}
if i not in d[(x, y)]['steps']:
d[(x, y)]['steps'][i] = steps
d[(x, y)]['seen'].add(i)
intersections = list(
filter(lambda coord: len(coord[1]['seen']) > 1, d.items()))
return min(
map(lambda coord: sum(coord[1]['steps'].values()), intersections))
def test_get_input():
text_input = TEST_INPUT[:3] + (None, ) + TEST_INPUT[3:]
get_row = Mock(side_effect=text_input)
print_func = Mock()
result = get_input(get_row_func=get_row, print_func=print_func)
assert result == TEST_INPUT
assert get_row.call_count == 6
assert print_func.call_count == 1
def part2():
data = get_input(1)
total_fuel_needed = 0
for mass in data:
incremental_fuel = int(int(mass) / 3) - 2
while (incremental_fuel > 0):
total_fuel_needed += incremental_fuel
incremental_fuel = int(incremental_fuel / 3) - 2
print(total_fuel_needed)
def main():
board = Board()
import atexit
original_terminal_state = lib.set_terminal_mode()
atexit.register(lib.restore_terminal, original_terminal_state)
# game loop
while board.alive:
board.draw()
delay = board.stats.delay
# if nothing's falling, wait a bit then spawn a piece
if board.kind is None:
lib.get_input(lib.now() + delay)
if board.clear_lines():
lib.get_input(lib.now() + delay)
board.spawn()
continue
# let the player shift and rotate freely before the next down-step
deadline = lib.now() + delay
key = None
while key != 'down':
key = lib.get_input(deadline)
if key == 'left':
board.shift(-1)
elif key == 'right':
board.shift(1)
elif key == 'up':
board.rotate()
elif key == 'space':
board.hard_drop()
break
else:
break
# down-step
if board.kind is not None:
board.descend()
board.draw()
print()
print('GAME OVER!')
def part1():
input = (int(x) for x in get_input(8)[0])
layer, layers = None, []
for i, num in enumerate(input):
if i % 150 == 0:
if layer:
layers.append(layer)
layer = []
layer.append(num)
chosen_layer = sorted(layers, key=lambda x: x.count(0))[0]
return chosen_layer.count(1) * chosen_layer.count(2)
def prep_data():
data = []
data.extend(list(map(lambda wire: wire.split(','), get_input(3))))
h_lines, v_lines = [], []
x, y = 0, 0
for line in chain(data[0], data[1]):
print(line)
(x2, y2), horizontal = parse_instruction(line)
if horizontal:
h_lines.append(Line(x, x2, y, y2))
else:
v_lines.append(Line(x, x2, y, y2))
x = x2
y = y2
return h_lines, v_lines
def part1():
d = {}
for phase_group in permutations(range(5)):
out = 0
for phase_setting in phase_group:
_input = [int(x) for x in get_input(7, log=False)[0].split(',')]
i = Intcode(_input=_input,
use_phase_settings=True,
phase_setting=phase_setting,
input_signal=out)
i.run()
out = i.diagnostic_codes[0]
d[phase_group] = out
print(next(filter(lambda item: item[1] == max(d.values()), d.items())))
def __init__(self,
day=2,
_input=None,
use_phase_settings=False,
phase_setting=0,
input_signal=0,
print_output=False):
self.instruction_pointer = 0
self.input = get_input(day) if not _input else _input
self.diagnostic_codes = []
self.use_phase_settings = use_phase_settings
self.phase_setting = phase_setting
self.input_signal = input_signal
self.first_input = True
self.print_output = print_output
def part2():
# 0 is black, 1 is white, and 2 is transparent
input = [int(x) for x in get_input(8)[0]]
length = 150 # 25 * 6
master = [2] * 150
layers = [input[i:i + 150] for i in range(0, len(input), 150)]
for layer in layers:
for i, num in enumerate(layer):
if master[i] == 2:
master[i] = num
s = ''
for i in range(length):
if i % 25 == 0:
s += "\n"
s += str(master[i]) + " "
print(s)
def part1():
wires, d = [], {}
wires.extend(list(map(lambda wire: wire.split(','), get_input(3))))
for i, wire in enumerate(wires):
x = y = 0
for instruction in wire:
direction, distance = instruction[0], int(instruction[1:])
if direction in ('L', 'R'):
delta = (1 if direction == 'R' else -1, 0)
else:
delta = (0, 1 if direction == 'U' else -1)
for _ in range(distance):
x += delta[0]
y += delta[1]
if (x, y) not in d:
d[(x, y)] = {'seen': set(), 'm_dist': abs(x) + abs(y)}
d[(x, y)]['seen'].add(i)
intersections = list(
filter(lambda coord: len(coord[1]['seen']) > 1, d.items()))
return min(map(lambda coord: coord[1]['m_dist'], intersections))
def test_regressions():
assert part_1(lib.get_input(13)) == 1895
assert part_2(lib.get_input(13)) == 840493039281088
def part1():
data = get_input(2)
# before running the program, replace position 1 with the value 12 and replace position 2 with the value 2
data[1] = 12
data[2] = 2
run(data)
def part1():
data = get_input(1)
total_fuel_needed = 0
for mass in data:
total_fuel_needed += int(int(mass) / 3) - 2
print(total_fuel_needed)
def calc(self):
a, b, c = get_input('a: '), get_input('b: '), get_input('c: ')
s = (a + b + c) / 2
return (s * (s - a) * (s - b) * (s - c))**0.5
def test_regression():
assert part_1(SAMPLE) == 25
assert part_2(SAMPLE) == 286
assert part_1(lib.get_input(12)) == 2280
assert part_2(lib.get_input(12)) == 38693
ticket_rules, your_ticket, other_tickets = parse_input(raw)
bad_tickets = set(get_bad_tickets(ticket_rules, other_tickets))
other_tickets = set(other_tickets) - bad_tickets
constraints = {rule: set(range(len(your_ticket))) for rule in ticket_rules}
while any(len(indices) != 1 for indices in constraints.values()):
for rule in ticket_rules:
for ticket in other_tickets:
for index, num in enumerate(ticket):
if not rule.matches(num):
constraints[rule].discard(index)
if len(constraints[rule]) == 1:
index = list(constraints[rule])[0]
for other_rule in ticket_rules:
if rule != other_rule:
constraints[other_rule].discard(index)
defined = {list(indices)[0]: rule.name for rule, indices in constraints.items()}
return lib.product(
[val for i, val in enumerate(your_ticket) if defined[i].startswith("departure")]
)
if __name__ == "__main__":
print(part_1(lib.get_input(16)))
print(part_2(lib.get_input(16)))
def calc(self) -> float:
radius = get_input('Set radius: ')
return radius**2 * pi
def execute(self):
for id in self.pull:
self.get_from_pull(id).hi()
figure = self.get_from_pull(get_input('Select:'))
print(figure.calc())
row.append(variation)
for row in tile_grid:
for t1, t2 in lib.window(row, 2):
assert t1.right() == t2.left()
for i in range(len(tile_grid)):
column = [row[i] for row in tile_grid]
for t1, t2 in lib.window(column, 2):
assert t1.bottom() == t2.top()
pixel_ids = [tile.tile_id for row in tile_grid for tile in row]
assert len(set(pixel_ids)) == len(list(pixel_ids))
tile_size = len(tiles[0].pixels)
pixels: List[List[bool]] = []
for row in tile_grid:
for i in range(1, tile_size - 1):
pixels.append([])
for tile in row:
for pixel in tile.pixels[i][1:-1]:
pixels[-1].append(pixel)
mega_tile = ImageTile(1, tuple(tuple(row) for row in pixels))
return min(map(count_monsters, mega_tile.variations()))
if __name__ == "__main__":
print(part_1(lib.get_input(20)))
print(part_2(lib.get_input(20)))
a, b = orbit.split(")")
g[b] = {'planet': a, 'distance': None if a != "COM" else 1}
return g
def calc_distance(planet):
if graph[planet]['distance']:
return graph[planet]['distance']
else:
graph[planet]['distance'] = calc_distance(graph[planet]['planet']) + 1
return graph[planet]['distance']
def part1(graph):
pprint(graph)
for planet in filter(lambda p: graph[p]['distance'] is None, graph.keys()):
calc_distance(planet)
print(sum(map(lambda v: v['distance'], graph.values())))
def part2(graph):
print("You are orbiting {}".format(graph['YOU']))
print("Santa is orbiting {}".format(graph['SAN']))
if __name__ == "__main__":
data = get_input(6)
graph = build_graph(data)
part1(graph)
part2(graph)
def prep_wires():
data = get_input(3)
wire1 = data[0].split(',')
wire2 = data[1].split(',')
data = [wire1, wire2]
return data
from lib import get_input
def get_clues(input):
tens = 1
units = 1
row = col = None
item = 11
while tens != row or units != col:
yield item
row = tens
col = units
item = input[row - 1][col - 1]
tens = item // 10
units = item - (tens * 10)
if __name__ == '__main__':
input = get_input()
print(' '.join(map(str, get_clues(input))))
def calc() -> int:
width, length = get_input('width: '), get_input('length: ')
return width * length
def test_regressions():
assert part_1(lib.get_input(14)) == 13865835758282
assert part_2(lib.get_input(14)) == 4195339838136
instruction, steps = line[0], int(line[1:])
if instruction in "NESW":
displacement = Orientation.from_char(instruction).as_coords().times(steps)
self.waypoint = self.waypoint.displace(*displacement)
elif instruction in "LR":
degrees = -1 * steps if instruction == "R" else steps
self.waypoint = self.waypoint.rotate(degrees)
elif instruction == "F":
displacement = self.waypoint.times(steps)
self.position = self.position.displace(*displacement)
return self
def part_1(raw: str):
ship = ShipState()
[ship.move(line) for line in raw.splitlines()]
return Point(0, 0).manhattan_distance_to(ship.position)
def part_2(raw: str):
ship = ShipState()
[ship.move_waypoint(line) for line in raw.splitlines()]
return Point(0, 0).manhattan_distance_to(ship.position)
if __name__ == "__main__":
print(part_1(get_input(12)))
print(part_2(get_input(12)))
