def from_file(cls, filename):
lines = read_strs(filename, sep="\n")
program = []
for line in lines:
op, param = line.strip().split()
program.append((op, int(param)))
return cls(program)
def create_ranges(file):
'''
Creates a list of ranges for the fields.
Inputs:
file (file): The file containing the ranges and field names
Returns: rv (list of tuples): list containing tuples of (lb, ub)
'''
rv = []
field = util.read_strs(file, sep = '\n')
for line in field:
words = line.split()
int_1 = words[-3]
int_2 = words[-1]
intv_1, intv_2 = text_to_range(int_1), text_to_range(int_2)
rv.append(intv_1)
rv.append(intv_2)
return rv
"""
ids = get_ids(boarding_passes)
min_id = min(ids)
max_id = max(ids)
sum_all_ids = ((max_id - min_id + 1) / 2) * (min_id + max_id)
sum_ids = sum(ids)
return int(sum_all_ids) - sum_ids
if __name__ == "__main__":
util.set_debug(False)
boarding_passes = util.read_strs("input/05.in", sep="\n")
print("TASK 1")
util.call_and_print(decode, "FBFBBFF", "F", "B")
util.call_and_print(decode, "RLR", "L", "R")
util.call_and_print(decode, "BFFFBBF", "F", "B")
util.call_and_print(decode, "RRR", "L", "R")
util.call_and_print(decode, "FFFBBBF", "F", "B")
util.call_and_print(decode, "RRR", "L", "R")
util.call_and_print(decode, "BBFFBBF", "F", "B")
util.call_and_print(decode, "RLL", "L", "R")
util.call_and_print(task1, ["FBFBBFFRLR"])
util.call_and_print(task1, boarding_passes)
'''
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)
# 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)
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)
commds.append([command, int(val)])
n = len(commds)
acc, last_instruction, j, to_change = run_program(commds)
for com, i in to_change:
if com == 'nop':
to_change_back = 'nop'
commds[i][0] = 'jmp'
elif com == 'jmp':
to_change_back = 'jmp'
commds[i][0] = 'nop'
else:
print("ERROR")
acc, _, j, _ = run_program(commds)
if j == n - 1:
return acc
else:
commds[i][0] = to_change_back
if __name__ == "__main__":
tst = util.read_strs('inputs/day8_test.txt', sep='\n')
inpt = util.read_strs('inputs/day8_input.txt', sep='\n')
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)
max_magnitude = 0
for lst1 in input:
for lst2 in input:
if lst1 is not lst2:
tree1 = Tree.from_list(eval(lst1))
tree2 = Tree.from_list(eval(lst2))
res = tree1.add(tree2)
magnitude = res.magnitude()
if magnitude > max_magnitude:
max_magnitude = magnitude
return max_magnitude
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/18.in", sep="\n")
input = util.read_strs("input/18.in", sep="\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)
parser = lark.Lark(grammar)
messages = input[1].split("\n")
correct = 0
for message in messages:
try:
parser.parse(message.strip())
correct += 1
except lark.exceptions.LarkError:
pass
return correct
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/19-1.in", sep="\n\n")
sample2 = util.read_strs("input/sample/19-2.in", sep="\n\n")
input = util.read_strs("input/19.in", sep="\n\n")
print("TASK 1")
util.call_and_print(count_correct, sample1)
util.call_and_print(count_correct, input)
print("\nTASK 2")
util.call_and_print(count_correct, sample2)
util.call_and_print(count_correct, sample2, True)
util.call_and_print(count_correct, input, True)
def solve(program, target_digit):
"""
Solve the problem for a given target digit (i.e., we want as many
of the digits to be equal to that target)
"""
# Find the differences between the digits
digit_map = code_analysis(program)
# Generate the model number
model_number = generate_model_number(digit_map, target_digit)
# Make sure it's actually valid
assert validate(program, model_number)
return model_number
if __name__ == "__main__":
util.set_debug(False)
input = util.read_strs("input/24.in", sep="\n")
print("TASK 1")
util.call_and_print(solve, input, 9)
print("TASK 2")
util.call_and_print(solve, input, 1)
for _ in range(6):
cc = cc.cycle3d()
return cc.count_active()
def task2(input):
cc = ConwayCube()
cc.from_grid(input)
for _ in range(6):
cc = cc.cycle4d()
return cc.count_active()
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/17.in", sep="\n")
grid = util.read_strs("input/17.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, sample)
util.call_and_print(task1, grid)
print("\nTASK 2")
util.call_and_print(task2, sample)
util.call_and_print(task2, grid)
common = wires_intersect(dirs1, dirs2)
smallest_steps = None
for x, y in common:
steps1 = trace(dirs1, x, y)
steps2 = trace(dirs2, x, y)
total_steps = steps1 + steps2
if smallest_steps is None or total_steps < smallest_steps:
smallest_steps = total_steps
return smallest_steps
if __name__ == "__main__":
wire1, wire2 = util.read_strs("input/03.in")
sample1_wire1 = "R75,D30,R83,U83,L12,D49,R71,U7,L72"
sample1_wire2 = "U62,R66,U55,R34,D71,R55,D58,R83"
sample2_wire1 = "R98,U47,R26,D63,R33,U87,L62,D20,R33,U53,R51"
sample2_wire2 = "U98,R91,D20,R16,D67,R40,U7,R15,U6,R7"
print("TASK 1")
util.call_and_print(task1, sample1_wire1, sample1_wire2)
util.call_and_print(task1, sample2_wire1, sample2_wire2)
util.call_and_print(task1, wire1, wire2)
print("\nTASK 2")
util.call_and_print(task2, sample1_wire1, sample1_wire2)
util.call_and_print(task2, sample2_wire1, sample2_wire2)
new_layer = [[0] * (col_num + 2)]
for row in layer:
new_row = [0]
new_row += row
new_row.append(0)
new_layer.append(new_row)
new_layer.append([0] * (col_num + 2))
new_grid.append(new_layer)
new_grid.append([[0] * (col_num + 2)] * (row_num + 2))
return new_grid
if __name__ == "__main__":
lines = util.read_strs("inputs/day17_inputs.txt")
# creates the list of lists
init_inpt = []
for line in lines:
init_line = []
for val in line:
if val == '.':
init_line.append(0)
else:
init_line.append(1)
init_inpt.append(init_line)
# given test data
tst = [[[0, 1, 0], [0, 0, 1], [1, 1, 1]]]
or (digt >= "a" and digt <= "f")):
num_correct += 1
else:
invalid = True
if (not invalid and num_correct == 6):
needed += 1
elif (field_name == "ecl" and value
in ["amb", "blu", "brn", "gry", "grn", "hzl", "oth"]):
needed += 1
elif (field_name == "pid" and len(value) == 9
and unicode(value).isnumeric()):
needed += 1
if needed == 7:
num_valid += 1
return num_valid
if __name__ == "__main__":
inpt = util.read_strs("inputs/day4_input.txt", sep="\n\n")
tst = util.read_strs("inputs/day4_test_input.txt", sep="\n\n")
tst2_valid = util.read_strs("inputs/day4_test_valid.txt", sep="\n\n")
tst2_invalid = util.read_strs("inputs/day4_test_invalid.txt", sep="\n\n")
print("TASK 1")
util.call_and_print(task1, tst)
util.call_and_print(task1, inpt)
print("\nTASK 2")
util.call_and_print(task2, tst2_valid)
util.call_and_print(task2, tst2_invalid)
util.call_and_print(task2, inpt)
for s in passwords:
indices, letter, password = s.strip().split()
i, j = (int(x) for x in indices.split("-"))
letter = letter[0]
li = password[i - 1]
lj = password[j - 1]
# Really wish Python had an "xor" operator
if (li == letter
or lj == letter) and not (li == letter and lj == letter):
valid += 1
return valid
if __name__ == "__main__":
sample = util.read_strs("input/sample/02.in", sep="\n")
passwords = util.read_strs("input/02.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, sample)
util.call_and_print(task1, passwords)
print("\nTASK 2")
util.call_and_print(task2, sample)
util.call_and_print(task2, passwords)
for i in range(2):
for j in range(4):
num_sea_creature = 0
for y in range(n - 3):
for x in range(n - 20):
if is_sea_creature(stitched_grid[y:y + 3, x:x + 20]):
num_sea_creature += 1
if num_sea_creature > 0:
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)):
A tuple (int, int, str, str) containing:
lb (int): the lower bound/first position
ub (int): the upper bound/second position
ltr (str): the letter of interest
pswrd (str): the password in question
'''
line_splt = line.split()
lb, ub = line_splt[0].split('-')
ltr = line_splt[1][0]
pswrd = line_splt[2]
return (int(lb), int(ub), ltr, pswrd)
if __name__ == "__main__":
inpt = util.read_strs("inputs/day2_input.txt", sep = '\n')
tst = util.read_strs("inputs/day2_testinput.txt", sep = '\n')
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)
for _, outputs in patterns:
for o in outputs:
if len(o) in (2, 3, 4, 7):
n += 1
return n
def task2(input):
"""
All the heavy lifting happens in decode()
"""
return decode(read_input(input))
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/08-1.in", sep="\n")
sample2 = util.read_strs("input/sample/08-2.in", sep="\n")
input = util.read_strs("input/08.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, sample1)
util.call_and_print(task1, sample2)
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, input)
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)
dic[dic_key] = generate_number(current_mask, num)
return sum(dic.values())
def task2(inpt):
dic = {}
current_mask = None
for line in inpt:
key, _, num = line.split()
if key[1] == 'a':
current_mask = num
else:
assert key[1] == 'e'
dic_key = key[4:-1]
index_lst = generate_number_task2(current_mask, dic_key)
for index in index_lst:
dic[index] = int(num)
return sum(dic.values())
if __name__ == "__main__":
inpt = util.read_strs("inputs/day14_input.txt", '\n')
tst = util.read_strs("inputs/day14_test.txt", '\n')
print("TASK 1")
util.call_and_print(task1, tst)
util.call_and_print(task1, inpt)
print("TASK 2")
util.call_and_print(task2, tst)
util.call_and_print(task2, inpt)
def task2(tiles):
'''
Runs the simulation for 100 days and finds the number of black tiles at
the end
Inputs:
- tiles (lst of strs): list of directions to tiles to be fliped initally
Outputs: an int, number of black tiles at the end of the simulation
'''
_, _, tile_dict = task1(tiles)
for i in range(1, 101):
tile_dict = one_day(tile_dict)
num_black, _ = find_black_tiles(tile_dict)
num_black, _ = find_black_tiles(tile_dict)
return num_black
if __name__ == "__main__":
tst = util.read_strs('inputs/day24_test.txt')
inpt = util.read_strs('inputs/day24_input.txt')
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)
elif action == "W":
move_dir = Direction.WEST()
for _ in range(value):
wayp_coords = move_dir.move_grid_coordinates(wayp_coords)
elif action == "F":
ship_coords = (ship_coords[0] + value * wayp_coords[0], ship_coords[1] + value * wayp_coords[1])
elif action == "L":
wayp_coords = rotate_counterclockwise(wayp_coords, value, origin=(0,0))
elif action == "R":
wayp_coords = rotate_clockwise(wayp_coords, value, origin=(0,0))
log(f"New coordinates {ship_coords} {wayp_coords}\n")
return abs(int(ship_coords[0])) + abs(int(ship_coords[1]))
if __name__ == "__main__":
util.set_debug(False)
sample = util.read_strs("input/sample/12.in", sep="\n")
actions = util.read_strs("input/12.in", sep="\n")
print("TASK 1")
util.call_and_print(task1, sample)
util.call_and_print(task1, actions)
print("\nTASK 2")
util.call_and_print(task2, sample)
util.call_and_print(task2, actions)
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)
for s in strings:
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)
Outputs: number (int) of valid passwords
'''
gram = create_lark_grammer(rules_inpt)
parser = lark.Lark(gram)
num_correct = 0
for line in passw_inpt:
try:
parser.parse(line.strip())
num_correct += 1
except lark.exceptions.LarkError:
pass
return num_correct
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)
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)
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)
def sum_expressions(exprs, precedence=equal_precedence):
"""
Evaluate a list of expressions and return the sum
"""
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",
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)
decks = read_input(input_txt)
winner, _ = play_game_r(decks, 1, recursive)
log("== Post-game results ==")
log("Player 1's deck:", ", ".join([str(x) for x in decks[1]]))
log("Player 2's deck:", ", ".join([str(x) for x in decks[2]]))
score = 0
for card, n in zip(decks[winner], range(len(decks[winner]), 0, -1)):
score += card * n
return score
if __name__ == "__main__":
util.set_debug(False)
sample1 = util.read_strs("input/sample/22-1.in", sep="\n\n")
sample2 = util.read_strs("input/sample/22-2.in", sep="\n\n")
input = util.read_strs("input/22.in", sep="\n\n")
print("TASK 1")
util.call_and_print(play_game, sample1, False)
util.call_and_print(play_game, input, False)
print("\nTASK 2")
util.call_and_print(play_game, sample1, True)
util.call_and_print(play_game, sample2, True)
util.call_and_print(play_game, input, True)
