def problem2_solution():
data = tuple(map(int, load_input(9, 2)))
for y in range(2, len(data) + 1):
for x in range(y, len(data) + 1):
if sum(data[x - y:x]) == P1_SOL:
return min(data[x - y:x]) + max(data[x - y:x])
return "Solution not found"
def problem2_solution():
count = 0
for i1, i2, char, pword in tuple(map(get_params, load_input(2, 2))):
char = char[0]
if (char == pword[i1 - 1]) != (char == pword[i2 - 1]):
count += 1
return count or "Solution not found."
def problem2_solution():
data = tuple(map(int, load_input(1, 2)))
for num1, num2 in combinations(data, 2):
num3 = 2020 - num1 - num2
if num3 in data:
return num1 * num2 * num3
return "Solution not found."
def problem1_solution():
data = tuple(map(int, load_input(1, 1)))
for num1 in data:
num2 = 2020 - num1
if num2 in data:
return num1 * num2
return "Solution not found."
def problem2_solution():
seat_ids = [compute_seat_id(t.strip()) for t in load_input(5, 2)]
seat_ids.sort()
for x in range(len(seat_ids) - 1):
if seat_ids[x + 1] - seat_ids[x] == 2:
return seat_ids[x] + 1
return "No solution found"
def problem1_solution():
data = tuple(map(int, load_input(9, 1)))
for x in range(25, len(data) + 1):
curr_num = data[x]
previous_nums = data[x - 25:x]
if not any(abs(curr_num - p) in previous_nums for p in previous_nums):
global P1_SOL
P1_SOL = curr_num
return curr_num
return "Solution not found"
def problem1_solution():
raw_rules, _, other_t = ''.join(load_input(16, 1)).split('\n\n')
rules = get_rules(raw_rules)
other_tickets = [get_ticket(t) for t in other_t.split('\n')[1:]]
ticket_error_rate = 0
for ticket in other_tickets:
_, invalid_values = split_ticket_values(ticket, rules)
if invalid_values:
ticket_error_rate += sum(invalid_values)
return ticket_error_rate
def problem1_solution():
data = load_input(13, 1)
ts = int(data[0])
bus_ids = [int(i) for i in data[1].strip().split(',') if i != 'x']
earliest_bus_id = 0
min_wait_time = min(bus_ids)
for bus_id in bus_ids:
wait_time = bus_id - divmod(ts, bus_id)[1]
if wait_time <= min_wait_time:
min_wait_time = wait_time
earliest_bus_id = bus_id
return earliest_bus_id * min_wait_time
def problem2_solution():
prog = {n: parse_instruction(i) for n, i in enumerate(load_input(8, 2), 1)}
for num, (op, val) in prog.items():
op = {'nop': 'jmp', 'jmp': 'nop'}.get(op)
if not op:
continue
patched_instructions = prog.copy()
patched_instructions[num] = (op, val)
console = Console(patched_instructions)
console.run()
if console.stop == 100:
return console.accumulator
return "Solution not found"
def problem1_solution():
mask = ''
mem = {}
for line in map(lambda x: x.strip(), load_input(14, 1)):
if line.startswith('mask'):
mask = line.replace('mask = ', '')
continue
# Retrieve address and value in base 10
addr, decval = line.replace('mem[', '').replace(']', '').split(' = ')
# Convert value to base 2, fill chars to make its length reach 36
binval = decimalstr_to_binarystr(decval).zfill(36)
# Apply mask rules
newbinval = ''.join(b if m == 'X' else m for b, m in zip(binval, mask))
# Convert back to base 10, set in memory to its address
mem[addr] = binarystr_to_decimalstr(newbinval)
return sum([int(v) for v in mem.values()])
def problem2_solution():
raw_rules, my_t, other_t = ''.join(load_input(16, 1)).split('\n\n')
rules = get_rules(raw_rules)
my_ticket = get_ticket(my_t.split('\n')[1])
other_tickets = [get_ticket(t) for t in other_t.split('\n')[1:]]
valid_tickets = []
for ticket in other_tickets:
_, invalid_values = split_ticket_values(ticket, rules)
if not invalid_values:
valid_tickets.append(ticket)
fields_position = get_fields_position(rules, valid_tickets)
result = 1
for field, pos in fields_position.items():
if field.startswith('departure'):
result *= my_ticket[pos]
return result
def problem2_solution():
data = load_input(13, 2)
bus_ids = [int(i) if i != 'x' else i for i in data[1].strip().split(',')]
bus_ids_delta = [] # List of tuples made as (Bus ID, offset)
for n, bus_id in tuple(filter(lambda i: i[1] != 'x', enumerate(bus_ids))):
if n == 0:
bus_ids_delta.append((bus_id, 0))
else:
bus_ids_delta.append((bus_id, bus_id - (n % bus_id)))
# Going to use the LCM: sort the deltas so that we start right away with
# big numbers, instead of cycling through small ones
bus_ids_delta.sort(key=lambda i: i[1], reverse=True)
lcm = 1
ts = bus_ids_delta[0][1]
for n, delta in enumerate(bus_ids_delta[:-1]):
lcm *= delta[0]
while ts % bus_ids_delta[n + 1][0] != bus_ids_delta[n + 1][1]:
ts += lcm
return ts
def problem2_solution():
mask = ''
mem = {}
for line in map(lambda x: x.strip(), load_input(14, 2)):
if line.startswith('mask'):
mask = line.replace('mask = ', '')
continue
# Retrieve address and value in base 10
addr, decval = line.replace('mem[', '').replace(']', '').split(' = ')
# Convert address to base 2, fill chars to make its length reach 36
binaddr = decimalstr_to_binarystr(addr).zfill(36)
# Apply mask rules
maskedaddr = ''.join(b if m == '0' else m if m == '1' else 'X'
for b, m in zip(binaddr, mask))
# For each X in the masked address, apply once 0 and once 1 (so, for 2
# Xs, we'll have 4 possible substitutions: (0, 0), (0, 1), (1, 0),
# (1, 1), giving 4 different addresses)
for bits in product(*[(0, 1) for _ in range(maskedaddr.count('X'))]):
newaddr = maskedaddr.replace('X', '{}').format(*bits)
# Convert back to base 10, set its value in memory
mem[binarystr_to_decimalstr(newaddr)] = decval
return sum([int(v) for v in mem.values()])
def problem1_solution():
return max([compute_seat_id(t.strip()) for t in load_input(5, 1)])
def problem1_solution():
expressions = [''.join(e.split()) for e in load_input(18, 1)]
return sum([evaluate_expr(e) for e in expressions])
def problem2_solution():
expressions = [''.join(e.split()) for e in load_input(18, 2)]
return sum([evaluate_expr(e, 'add_first') for e in expressions])
def problem2_solution():
data = dict(enumerate(map(lambda l: l.strip(), load_input(3, 2))))
res = 1
for x, y in [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]:
res *= tree_counter(data, x=x, y=y)
return res or "Solution not found."
def problem1_solution():
data = dict(enumerate(map(lambda l: l.strip(), load_input(3, 1))))
return tree_counter(data, x=3, y=1) or "Solution not found."
def problem2_solution():
policies = tuple(map(lambda x: x.strip(), load_input(7, 2)))
cmap = map_policies_to_colors(policies)
return count_inner_colors(cmap, MY_COLOR)
def problem2_solution():
passports = convert2passports(load_input(4, 2))
return len(tuple(filter(has_all_valid_fields, passports)))
def problem2_solution():
return get_arrangements(list(map(int, load_input(10, 2))))
def problem1_solution():
count = 0
for n1, n2, char, pword in tuple(map(get_params, load_input(2, 1))):
if n1 <= Counter(pword).get(char, 0) <= n2:
count += 1
return count or "Solution not found."
def problem1_solution():
return memory(list(map(int, load_input(15, 1)[0].split(','))), 2020)
def problem2_solution():
old_map = {}
new_map = get_seat_map(load_input(11, 2))
while old_map != new_map:
old_map, new_map = new_map, evolve_map(new_map, 'first_seen')
return len([s for s in new_map.values() if s['type'] == '#'])
def problem1_solution():
policies = tuple(map(lambda x: x.strip(), load_input(7, 1)))
cmap = map_policies_to_colors(policies)
return len([c for c in cmap if contains_color(cmap, c, MY_COLOR)])
def problem1_solution():
prog = {n: parse_instruction(i) for n, i in enumerate(load_input(8, 1), 1)}
console = Console(prog)
console.run()
return console.accumulator if console.stop == 300 else "Solution not found"
def problem1_solution():
jumps = get_jumps(list(map(int, load_input(10, 1))))
return jumps[1] * jumps[3]
def problem2_solution():
return memory(list(map(int, load_input(15, 2)[0].split(','))), 30000000)
def problem1_solution():
data = load_input(19, 1)
rules = dictify_rules(data[:data.index('\n')])
valid_msgs = set(get_valid_msgs(rules))
msgs = [m.strip() for m in data[data.index('\n') + 1:]]
return len(valid_msgs.intersection(msgs))
def problem1_solution():
passports = convert2passports(load_input(4, 1))
return len(tuple(filter(has_all_mandatory_fields, passports)))
