passport = Passport.passport_from_str(s, passport_type=REGULAR_PASSPORT)
log(passport.fields)
if passport.validate(validate_values):
log("VALID")
valid += 1
log()
return valid
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/04.in", sep="\n\n")
sample_invalid = util.read_strs("input/sample/04-invalid.in", sep="\n\n")
sample_valid = util.read_strs("input/sample/04-valid.in", sep="\n\n")
passports = util.read_strs("input/04.in", sep="\n\n")
print("TASK 1")
util.call_and_print(validate, sample, False)
util.call_and_print(validate, passports, False)
print("\nTASK 2")
util.call_and_print(validate, sample, True)
util.call_and_print(validate, sample_invalid, True)
util.call_and_print(validate, sample_valid, True)
util.call_and_print(validate, passports, True)
0xx
00x
000
Returns: Tuple with product of pair and triple
'''
n = len(df_lst)
df_lst.sort()
soln_1 = None
soln_2 = None
for i in range(n - 1):
for j in range(i + 1, n):
if (df_lst[i] + df_lst[j] == 2020):
soln_1 = df_lst[i] * df_lst[j]
elif (df_lst[i] + df_lst[j] > 2020):
break
for k in range(j + 1, n):
if (df_lst[i] + df_lst[j] + df_lst[k] == 2020):
soln_2 = df_lst[i] * df_lst[j] * df_lst[k]
elif (df_lst[i] + df_lst[j] + df_lst[k] > 2020):
break
return soln_1, soln_2
if __name__ == "__main__":
inpt = util.read_ints("inputs/day1_input.txt")
print("TASK 1 and 2")
start = time.time()
util.call_and_print(find_product, inpt)
end = time.time()
print(end - start)
'''
Converts list of strings to numpy array
Inputs:
str_lst (lst of str): Initial input from text file
Returns: (arr) numpy array corresponding to str_lst
'''
lst = []
for line in str_lst:
temp_lst = list(line)[:]
lst.append(temp_lst)
return np.array(lst)
if __name__ == "__main__":
tst = util.read_strs('inputs/day3_test_input.txt')
inpt = util.read_strs('inputs/day3_input.txt')
tst_arr = convert_to_array(tst)
arry = convert_to_array(inpt)
print("TASK 1")
util.call_and_print(task_1, tst_arr, 3, 1)
util.call_and_print(task_1, arry, 3, 1)
print("\nTASK 2")
tests = [(1, 1), (3, 1), (5, 1), (7, 1), (1, 2)]
util.call_and_print(task_2, tst_arr, tests)
util.call_and_print(task_2, arry, tests)
sum += x
return sum
def task2(numbers):
sum = 0
for n in numbers:
while n > 0:
n = int(math.floor(n / 3) - 2)
if n > 0:
sum += n
return sum
if __name__ == "__main__":
nums = util.read_ints("input/01.in")
print("TASK 1")
util.call_and_print(task1, [12])
util.call_and_print(task1, [14])
util.call_and_print(task1, [1969])
util.call_and_print(task1, [100756])
util.call_and_print(task1, nums)
print("\nTASK 2")
util.call_and_print(task2, [12])
util.call_and_print(task2, [14])
util.call_and_print(task2, [1969])
util.call_and_print(task2, [100756])
util.call_and_print(task2, nums)
llist.head = first_node
prior_node = first_node
next_node = None
d[lst[0]] = first_node
for elt in lst[1:]:
next_node = Node(elt)
d[elt] = next_node
prior_node.next = next_node
next_node.previous = prior_node
prior_node = next_node
if extra:
for elt in range(10, 1000001):
next_node = Node(elt)
d[elt] = next_node
prior_node.next = next_node
next_node.previous = prior_node
prior_node = next_node
prior_node.next = first_node
first_node.previous = prior_node
return llist, d
if __name__ == "__main__":
tst = [3, 8, 9, 1, 2, 5, 4, 6, 7]
inpt = [7, 1, 6, 8, 9, 2, 5, 4, 3]
print("TASK 1")
util.call_and_print(task1, tst)
util.call_and_print(task1, inpt)
print("\nTASK 2")
util.call_and_print(task2, tst)
util.call_and_print(task2, inpt)
person_answer = set(person)
all_answer = all_answer.intersection(person_answer)
return len(all_answer)
def task2(inpt):
'''
Counts the number of common answers from the input
Inputs:
inpt (lst of strs): a list of all of the groups and their answers
Output: an integer, the number of common answers
'''
tot_all = 0
for group in inpt:
tot_all += num_all_answer(group)
return tot_all
if __name__ == "__main__":
groups_tst = util.read_strs("inputs/day6_test.txt", sep = "\n\n")
groups = util.read_strs("inputs/day6_input.txt", sep = "\n\n")
print("TASK 1")
util.call_and_print(task1, groups_tst)
util.call_and_print(task1, groups)
print("\nTASK 2")
util.call_and_print(task2, groups_tst)
util.call_and_print(task2, groups)
if __name__ == "__main__":
tst = util.read_strs("inputs/day19_tst.txt", sep="\n")
for i, val in enumerate(tst):
if val == "":
break
tst_rules = tst[:i]
tst_codes = tst[i + 1:]
inpt = util.read_strs("inputs/day19_input.txt", sep="\n")
for j, val in enumerate(inpt):
if val == "":
break
inpt_rules = inpt[:j]
inpt_codes = inpt[j + 1:]
print("TASK 1")
util.call_and_print(task_solver, tst_rules, tst_codes)
util.call_and_print(task_solver, inpt_rules, inpt_codes)
task_2_rules = []
for line in inpt_rules:
if line == "8: 42":
line = "8: 42 | 42 8"
elif line == "11: 42 31":
line = "11: 42 31 | 42 11 31"
task_2_rules.append(line)
print("\nTASK 2")
util.call_and_print(task_solver, task_2_rules, inpt_codes)
if op in ("nop", "jmp"):
# Reset console back to original state and program
# (undoing any previous changes to program)
console.reset()
# Replace instruction
if op == "nop":
console.prog[i] = ("jmp", param)
elif op == "jmp":
console.prog[i] = ("nop", param)
# Run console and check for normal termination
console.run()
if console.normal_termination():
return console.acc
if __name__ == "__main__":
util.set_debug(False)
sample = Console.from_file("input/sample/08.in")
real = Console.from_file("input/08.in")
print("TASK 1")
util.call_and_print(task1, sample)
util.call_and_print(task1, real)
print("\nTASK 2")
util.call_and_print(task2, sample)
util.call_and_print(task2, real)
def count_valid_password(lb, ub, require_standalone_pair):
"""
Count the number of valid passwords in a given range
"""
n = 0
for password in range(lb, ub + 1):
if is_valid(password, require_standalone_pair):
n += 1
return n
if __name__ == "__main__":
min_value = 264360
max_value = 746325
print("TASK 1")
util.call_and_print(is_valid, 111111, False)
util.call_and_print(is_valid, 223450, False)
util.call_and_print(is_valid, 123789, False)
util.call_and_print(count_valid_password, min_value, max_value, False)
print("\nTASK 2")
util.call_and_print(is_valid, 112233, True)
util.call_and_print(is_valid, 123444, True)
util.call_and_print(is_valid, 111122, True)
util.call_and_print(count_valid_password, min_value, max_value, True)
j += 1
door_loop = j
val = 1
for i in range(card_loop):
val = one_loop(val, door)
return val
def one_loop(val, subject):
'''
Does one loop of transformation
Inputs:
val (int): the current value
subject (int): the subject number to multiply by
Outputs: an int, the new value
'''
val = val * subject
return val % 20201227
if __name__ == "__main__":
tst = util.read_strs('inputs/day25_test.txt')
inpt = util.read_strs('inputs/day25_input.txt')
tst_card, tst_door = int(tst[0]), int(tst[1])
inpt_card, inpt_door = int(inpt[0]), int(inpt[1])
print('TASK 1')
util.call_and_print(task1, tst_card, tst_door)
util.call_and_print(task1, inpt_card, inpt_door)
Inputs:
intg (str): Not my best variable name, the string 'lb-ub'
Returns: list of ints contaning lower bound and upper bound
'''
splt_intv = intg.split("-")
return [int(splt_intv[0]), int(splt_intv[1])]
if __name__ == "__main__":
# Read in data
ranges = create_ranges("inputs/day16_inputranges.txt")
test_ranges = [[1, 3], [5, 7], [6, 11], [33, 44], [13, 40],[45, 50]]
test_tickets = [[7,3,47], [40,4,50], [55,2,20], [38,6,12]]
df = pd.read_csv("inputs/day16_input.csv")
nearby_tickets = df.values.tolist()
util.call_and_print(task1, test_tickets, test_ranges)
util.call_and_print(task1, nearby_tickets, ranges)
names = ['departure location', 'departure station', 'departure platform',
'departure track', 'departure date', 'departure time',
'arrival location', 'arrival station', 'arrival platform',
'arrival track', 'class', 'duration', 'price', 'route', 'row', 'seat',
'train', 'type', 'wagon', 'zone']
answer, valid_tickets = task1(nearby_tickets, ranges)
valid_tickets.append([89,139,79,151,97,67,71,53,59,149,127,131,103,
109,137,73,101,83,61,107])
util.call_and_print(task2, valid_tickets, ranges, names)
return total_octathorps - (num_sea_creature * 15)
stitched_grid = np.rot90(stitched_grid)
stitched_grid = np.fliplr(stitched_grid)
return total_octathorps
if __name__ == "__main__":
tst = util.read_strs("inputs/day20_test.txt", sep="\n\n")
inpt = util.read_strs("inputs/day20_input.txt", sep="\n\n")
tst_tiles = create_tiles(tst)
tst_sqr = len(tst_tiles)**.5
inpt_tiles = create_tiles(inpt)
len_sqr = len(inpt_tiles)**.5
print("TASK 1")
util.call_and_print(task1, tst_tiles)
util.call_and_print(task1, inpt_tiles)
full_grid = []
for i in range(int(len_sqr)):
full_grid.append([None] * int(len_sqr))
tst_grid = []
for i in range(int(tst_sqr)):
tst_grid.append([None] * int(tst_sqr))
tst_tiles[1].mirror_tile()
tst_tiles[1].rotate_tile()
tst_tiles[1].rotate_tile()
tst_grid[0][0] = tst_tiles[1]
tst_tiles.pop(1)
starting_tile = None
"""
v = 0
for expr in exprs:
v += eval_expression(expr, precedence)
return v
if __name__ == "__main__":
util.set_debug(False)
expressions = util.read_strs("input/18.in", sep="\n")
print("TASK 1")
util.call_and_print(eval_expression, "1 + 2 * 3 + 4 * 5 + 6")
util.call_and_print(eval_expression, "1 + (2 * 3) + (4 * (5 + 6))")
util.call_and_print(eval_expression, "2 * 3 + (4 * 5)")
util.call_and_print(eval_expression, "5 + (8 * 3 + 9 + 3 * 4 * 3)")
util.call_and_print(eval_expression,
"5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))")
util.call_and_print(eval_expression,
"((2 + 4 * 9) * (6 + 9 * 8 + 6) + 6) + 2 + 4 * 2")
util.call_and_print(sum_expressions, expressions)
print("\nTASK 2")
util.call_and_print(eval_expression, "1 + 2 * 3 + 4 * 5 + 6",
addition_precedence)
util.call_and_print(eval_expression, "1 + (2 * 3) + (4 * (5 + 6))",
addition_precedence)
util.call_and_print(eval_expression, "2 * 3 + (4 * 5)",
return rv
def get_score(q):
queue_lst = []
result = 0
mult_lst = [i for i in range(1, q.qsize() + 1)]
for i in range(q.qsize()):
queue_lst = [q.get()] + queue_lst
for i, elt in enumerate(queue_lst):
result += (i+1) * elt
return result
if __name__ == "__main__":
tst_player_1, tst_player_2 = util.read_strs("inputs/day22_test.txt", sep = "\n\n")
player_1, player_2 = util.read_strs("inputs/day22_input.txt", sep = "\n\n")
print("TASK 1")
util.call_and_print(task1, tst_player_1, tst_player_2)
util.call_and_print(task1, player_1, player_2)
print("\nTASK 2")
util.call_and_print(task2, tst_player_1, tst_player_2)
start = time.time()
util.call_and_print(task2, player_1, player_2)
end = time.time()
print(end - start)
Output: int, the sum of a contiguous set maxinum and minimum element of the
set of at least two numbers in your list which sum to the invalid
number from task 1
'''
for i,_ in enumerate(inpt):
sum = 0
sum_lst = []
j = 1
while sum < num:
sum += inpt[i + j]
sum_lst.append(inpt[i+j])
j += 1
if sum == num:
return max(sum_lst) + min(sum_lst)
if __name__ == "__main__":
tst = util.read_ints('inputs/day9_test.txt', sep = '\n')
inpt = util.read_ints('inputs/day9_input.txt', sep = '\n')
print('TASK 1')
util.call_and_print(task1, tst, 5)
util.call_and_print(task1, inpt, 25)
print('\nTASK 2')
util.call_and_print(task2, tst, 127)
util.call_and_print(task2, inpt, 556543474)
def find_stable_state(grid, immediate_only, threshold):
"""
Find the number of occupied seats in the stable state.
"""
while True:
grid, changes = update_grid(grid, immediate_only, threshold)
if changes == 0:
occupied = 0
for x in range(grid.max_x):
for y in range(grid.max_y):
if grid.get(x, y) == "#":
occupied += 1
return occupied
if __name__ == "__main__":
util.set_debug(False)
sample = util.Grid.from_file("input/sample/11.in")
grid = util.Grid.from_file("input/11.in")
print("TASK 1")
util.call_and_print(find_stable_state, sample, True, 4)
util.call_and_print(find_stable_state, grid, True, 4)
print("\nTASK 2")
util.call_and_print(find_stable_state, sample, False, 5)
util.call_and_print(find_stable_state, grid, False, 5)
"""
import util
from intcode import IntCode
def run_test(prog, system_id):
"""
Inputs a system id to the IntCode VM, and then runs it
until it outputs a non-zero code (and returns the code)
"""
vm = IntCode(input)
vm.input(system_id)
while True:
code = vm.output()
if code != 0:
return code
if __name__ == "__main__":
util.set_debug(False)
input = util.read_ints("input/05.in", sep=",")
print("TASK 1")
util.call_and_print(run_test, input, 1)
print("\nTASK 2")
util.call_and_print(run_test, input, 5)
return rv
def multiply_list(lst):
'''
Simple helper function to multiply elements of a list together. For some
reason the one in the math library wasn't working.
Inputs:
lst (lst): a list of numbers
Returns: result (int/float) the product of all the elements in the list
'''
result = 1
for elt in lst:
result *= elt
return result
if __name__ == "__main__":
smpl_tst = "1 + (2 * 3) + (4 * (5 + 6))"
smpl_tst2 = "1 + 2 * 3 + 4 * 5 + 6"
smpl_tst3 = "5 * 9 * (7 * 3 * 3 + 9 * 3 + (8 + 6 * 4))"
inpt = util.read_strs("inputs/day18_input.txt", sep="\n")
print("TESTING")
util.call_and_print(complicated_solver, smpl_tst3, True)
util.call_and_print(simple_solver_task2, smpl_tst2)
print("\nTASK 1")
util.call_and_print(task_solver, inpt, False)
print("\nTASK 2")
util.call_and_print(task_solver, inpt, True)
grid, moves1 = half_step(grid, ">")
grid, moves2 = half_step(grid, "v")
return grid, moves1 + moves2
def solve(grid):
"""
Find the step number when no moves take place.
"""
num_steps = 1
while True:
grid, moves = step(grid)
if moves == 0:
return num_steps
num_steps += 1
if __name__ == "__main__":
util.set_debug(False)
sample = util.Grid.from_file("input/sample/25.in")
input = util.Grid.from_file("input/25.in")
print("TASK 1")
util.call_and_print(solve, sample)
util.call_and_print(solve, input)
cups = [int(x) for x in cups_txt]
one_node = play_game(cups, moves)
assert one_node.value == 1
return one_node.to_str(sep="")[1:]
def task2(cups_txt, moves):
cups = [int(x) for x in cups_txt]
cups += list(range(max(cups)+1, 1000001))
one_node = play_game(cups, moves)
assert one_node.value == 1
return one_node.next.value * one_node.next.next.value
if __name__ == "__main__":
util.set_debug(False)
print("TASK 1")
util.call_and_print(task1, "389125467", 10)
util.call_and_print(task1, "389125467", 100)
util.call_and_print(task1, "952316487", 100)
print("\nTASK 2")
util.call_and_print(task2, "389125467", 10000000)
util.call_and_print(task2, "952316487", 10000000)
"""
Find a contiguous set of at least two numbers
that add up to the invalid number from the previous task.
"""
target = task1(numbers, preamble_len)
for i in range(len(numbers)):
range_sum = numbers[i]
for j in range(i + 1, len(numbers)):
range_sum += numbers[j]
if range_sum == target:
sublist = numbers[i:j + 1]
return min(sublist) + max(sublist)
elif range_sum > target:
break
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_ints("input/sample/09.in")
numbers = util.read_ints("input/09.in")
print("TASK 1")
util.call_and_print(task1, sample, 5)
util.call_and_print(task1, numbers, 25)
print("\nTASK 2")
util.call_and_print(task2, sample, 5)
util.call_and_print(task2, numbers, 25)
fishes[x] = fishes.get(x, 0) + 1
for _ in range(days):
new_fishes = {x: 0 for x in range(0, 9)}
for timer, n in fishes.items():
if timer == 0:
new_fishes[8] += n
new_fishes[6] += n
else:
new_fishes[timer - 1] += n
fishes = new_fishes
return sum(v for v in fishes.values())
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_ints("input/sample/06.in", sep=",")
input = util.read_ints("input/06.in", sep=",")
print("TASK 1")
util.call_and_print(count_fishes, sample, 80)
util.call_and_print(count_fishes, input, 80)
print("\nTASK 2")
util.call_and_print(count_fishes, sample, 256)
util.call_and_print(count_fishes, input, 256)
def task1(input):
"""
Task 1: Do 10 steps
"""
template, rules = read_input(input)
return count_polymer(template, rules, 10)
def task2(input):
"""
Task 2: Do 40 steps
"""
template, rules = read_input(input)
return count_polymer(template, rules, 40)
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/14.in", sep="\n\n")
input = util.read_strs("input/14.in", sep="\n\n")
print("TASK 1")
util.call_and_print(task1, sample)
util.call_and_print(task1, input)
print("\nTASK 2")
util.call_and_print(task2, sample)
util.call_and_print(task2, input)
it finds the largest value of y, and also counts up the number of probes
that end up in the target area.
"""
best_y = 0
best_vel_x = 0
best_vel_y = 0
num_in_target = 0
for vel_x in range(lb_x, ub_x):
for vel_y in range(lb_y, ub_y):
in_target, largest_y = launch(vel_x, vel_y, target_min_x,
target_max_x, target_min_y,
target_max_y)
if in_target:
num_in_target += 1
if largest_y > best_y:
best_y = largest_y
best_vel_x = vel_x
best_vel_y = vel_y
return best_y, best_vel_x, best_vel_y, num_in_target
if __name__ == "__main__":
util.set_debug(False)
print("TASK 1 + 2")
util.call_and_print(check_velocities, 20, 30, -10, -5, -250, 250, -250,
250)
util.call_and_print(check_velocities, 155, 182, -117, -67, -250, 250, -250,
250)
# Finally, find the fields that start with "departure"
# and get their respective values in my ticket
values = []
for position, choices in candidate_fields:
assert len(choices) == 1
field_name = choices.pop()
if field_name.startswith("departure"):
values.append(my_ticket[position])
return math.prod(values)
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/16-1.in", sep="\n\n")
sample2 = util.read_strs("input/sample/16-2.in", sep="\n\n")
notes = util.read_strs("input/16.in", sep="\n\n")
print("TASK 1")
util.call_and_print(task1, sample1)
util.call_and_print(task1, notes)
print("\nTASK 2")
util.call_and_print(test_get_valid_tickets, sample1)
util.call_and_print(test_get_valid_tickets, sample2)
util.call_and_print(task2, notes)
to_flip.append(coords)
elif tile.color == Tile.WHITE and (n_black == 2):
to_flip.append(coords)
for coords in to_flip:
all_tiles[coords].flip()
n_black = 0
for tile in all_tiles.values():
if tile.color == Tile.BLACK:
n_black += 1
return n_black
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/24.in", sep="\n")
input = util.read_strs("input/24.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, ["esew"])
util.call_and_print(task1, ["nwwswee"])
util.call_and_print(task1, sample)
util.call_and_print(task1, input)
print("\nTASK 2")
util.call_and_print(task2, sample, 100)
util.call_and_print(task2, input, 100)
def task2(input):
"""
Task 2: Second visits allowed
"""
graph = read_graph(input)
paths = gen_paths(graph, "start", "end", allow_second_visit=True)
return len(paths)
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/12-1.in", sep="\n")
sample2 = util.read_strs("input/sample/12-2.in", sep="\n")
sample3 = util.read_strs("input/sample/12-3.in", sep="\n")
input = util.read_strs("input/12.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, sample1)
util.call_and_print(task1, sample2)
util.call_and_print(task1, sample3)
util.call_and_print(task1, input)
print("\nTASK 2")
util.call_and_print(task2, sample1)
util.call_and_print(task2, sample2)
util.call_and_print(task2, sample3)
util.call_and_print(task2, input)
new_value = ""
for digit, mask_digit in zip(bin_value, mask):
if mask_digit in ("1", "X"):
new_value += mask_digit
elif mask_digit == "0":
new_value += digit
addrs = expand_floating(new_value)
for addr in addrs:
log(f"mem[{addr}] = {value}")
mem[addr] = value
return sum(mem.values())
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/14-1.in", sep="\n")
sample2 = util.read_strs("input/sample/14-2.in", sep="\n")
commands = util.read_strs("input/14.in", sep="\n")
print("TASK 1")
util.call_and_print(update_memory, sample1, 1)
util.call_and_print(update_memory, commands, 1)
print("\nTASK 2")
util.call_and_print(update_memory, sample2, 2)
util.call_and_print(update_memory, commands, 2)
image = stitch_image(tiles, adjacencies)
# Try four rotations, flip, try four rotations
for i in range(8):
if i == 4:
image = np.flip(image, 0)
num_sea_creatures = count_sea_creatures(image)
if num_sea_creatures > 0:
return np.sum(image) - (num_sea_creatures * SEA_CREATURE_SIZE)
image = np.rot90(image)
return None
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/20.in", sep="\n\n")
input = util.read_strs("input/20.in", sep="\n\n")
print("TASK 1")
util.call_and_print(find_corners, sample)
util.call_and_print(find_corners, input)
print("\nTASK 2")
util.call_and_print(compute_roughness, sample)
util.call_and_print(compute_roughness, input)
"""
value = 1
for _ in range(loop_size):
value *= subject_number
value %= 20201227
return value
def crack_keys(card_pk, door_pk):
"""
Extract the encryption key from the public keys
"""
card_loop = find_loop_size(card_pk)
door_loop = find_loop_size(door_pk)
card_key = transform(door_pk, card_loop)
door_key = transform(card_pk, door_loop)
assert card_key == door_key
return card_key
if __name__ == "__main__":
util.set_debug(False)
print("TASK 1")
util.call_and_print(crack_keys, 5764801, 17807724)
util.call_and_print(crack_keys, 14788856, 19316454)
