def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
paths = parse(loadingUtils.importToArray(in_file))
tiles = defaultdict(Tile)
for path in paths:
idx = walk_path(path, False)
if debug:
print("gonna flip Tile {}: from {}".format(idx, tiles[idx]),
end="")
tiles[idx].flip()
if debug: print(" to {}".format(tiles[idx]))
print_floor(tiles)
print(count_black(tiles))
#tiles = step(tiles)
#print_floor(tiles)
#print(count_black(tiles))
for i in range(1, 101):
#for i in range(1, 5):
tiles = step(tiles)
#print_floor(tiles)
print("Step {:3}: {}".format(i, count_black(tiles)))
result = count_black(tiles)
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
in_text = loadingUtils.importToArray(in_file)
tile_id = 0
tile_content = []
tile_counter = 0
tiles = []
for line in in_text:
if line == "":
tiles.append(Tile(tile_id, tile_content))
tile_id = 0
tile_content = []
continue
if "Tile" in line:
tile_id = int(line.split(" ")[1][:-1])
tile_counter += 1
else:
tile_content.append(list(line))
tiles.append(Tile(tile_id, tile_content))
print("We have {} Tiles".format(tile_counter))
print(len(tiles))
assert len(tiles) == tile_counter
for tile in tiles:
print()
tile.print()
print(tile.edges)
find_edges(tiles)
print("Start Assembling Image")
image = assemble_image(tiles)
# now remove all monsters
result = remove_monsters(image)
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
in_text = loadingUtils.importToArray(in_file)
tile_id = 0
tile_content = []
tile_counter = 0
tiles = []
for line in in_text:
if line == "":
tiles.append(Tile(tile_id, tile_content))
tile_id = 0
tile_content = []
continue
if "Tile" in line:
tile_id = int(line.split(" ")[1][:-1])
tile_counter += 1
else:
tile_content.append(list(line))
tiles.append(Tile(tile_id, tile_content))
print("We have {} Tiles".format(tile_counter))
print(len(tiles))
assert len(tiles) == tile_counter
for tile in tiles:
print()
tile.print()
print(tile.edges)
find_edges(tiles)
result = 1
for tile in tiles:
if tile.is_edge:
result = result * tile.id
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
cups = list(map(int, list(loadingUtils.importToArray(in_file)[0])))
print(cups)
result = run_b(cups)
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
notes = loadingUtils.importToArray(in_file)
rules, my_ticket, nearby = parser(notes)
result = sum_wrong(rules, nearby)
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
eqns = loadingUtils.importToArray(in_file)
for eqn in eqns:
res = evaluate(eqn)
print(res)
result += res
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
nav_instr = loadingUtils.importToArray(in_file)
print(nav_instr)
goal = get_end_point_real(nav_instr)
print("Endpoint {}".format(goal))
result = abs(goal[0]) + abs(goal[1])
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
boardingpasses = loadingUtils.importToArray(in_file)
seatIDs = []
for boardingpass in boardingpasses:
(row_i, col_i, seatID) = calc_row_column(boardingpass)
seatIDs.append(seatID)
result = max(seatIDs)
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
prog_array = loadingUtils.importToArray(in_file)
handheld = cp.Computer()
handheld.hard_reset()
handheld.debug = debug
handheld.load_program(prog_array)
result = handheld.run_day08_2()
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
p1, p2 = parse(loadingUtils.importToArray(in_file))
_, winner = play_advanced(p1, p2, debug)
print(winner)
winner.reverse()
for i, v in enumerate(winner):
result += (i + 1) * v
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
_starttime, _busses = loadingUtils.importToArray(in_file)
starttime = int(_starttime)
print(starttime)
busses = get_valid_busses(_busses)
print(busses)
result = next_to_airport(starttime, busses)
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
passwords_list = loadingUtils.importToArray(in_file)
results = []
for password_line in passwords_list:
(password, min_number, max_number, test_char) = parse_input(password_line)
if validate_password_rules2(password, min_number, max_number, test_char):
results.append(password)
result = len(results)
print("We have found {} valid passwords.".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
notes = loadingUtils.importToArray(in_file)
rules, my_ticket, nearby = parser(notes)
#print_rules(rules)
clean_nearby = cleanup(rules, nearby)
print("before cleanup = {}; after cleanup {}".format(len(nearby), len(clean_nearby)))
match_columns(rules, clean_nearby)
# code here
result = 97*163*101*73*53*131
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
foodlist = loadingUtils.importToArray(in_file)
list_ingredients, allergens, mapping = parse_input(foodlist)
# all values of the values of the dict
exclude = set(v for vs in mapping.values() for v in vs)
print(exclude)
result = 0
for ingredients in list_ingredients:
for ingredient in ingredients:
result += ingredient not in exclude
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
lines = loadingUtils.importToArray(in_file)
rules, messages = split(lines)
#print(rules)
regexp = generate_regex(rules)
print(regexp)
#print(messages)
result = count_matches(regexp, messages, debug)
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
foodlist = loadingUtils.importToArray(in_file)
list_ingredients, allergens, mapping = parse_input(foodlist)
solution = solve(mapping)
print(solution)
solution.sort()
print(solution)
result = ",".join([x[1] for x in solution])
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
eqns = loadingUtils.importToArray(in_file)
for eqn in eqns:
print(eqn)
new_eqn = transform(eqn)
print(new_eqn)
res = evaluate(new_eqn)
print(res)
result += res
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
paths = parse(loadingUtils.importToArray(in_file))
tiles = defaultdict(Tile)
for path in paths:
idx = walk_path(path, debug)
if debug:
print("gonna flip Tile {}: from {}".format(idx, tiles[idx]),
end="")
tiles[idx].flip()
if debug: print(" to {}".format(tiles[idx]))
print(tiles)
result = Counter([x.print() for x in tiles.values()])['BLACK']
print()
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
_starttime, _busses = loadingUtils.importToArray(in_file)
starttime = int(_starttime)
print(starttime)
busses = []
for i, bus in enumerate(_busses.split(",")):
print(i, bus)
if bus == "x":
continue
busses.append(((int(bus) - i) % int(bus), int(bus)))
print(busses)
solution = solve_congruence(*busses)
print(solution)
# code here
result = solution[0]
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
lines = loadingUtils.importToArray(in_file)
rules, messages = split(lines)
print(rules["8"])
print(rules["11"])
new_rules = transform(rules)
print(new_rules["8"])
print(new_rules["11"])
max_len = 0
for message in messages:
max_len = max(max_len, len(message))
print(max_len)
regexp = gen_regex2(rules)
#print(regexp)
result = count_matches(regexp, messages, debug)
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
pub_keys = loadingUtils.importToArray(in_file)
door_pub = int(pub_keys[0])
card_pub = int(pub_keys[1])
print("Intercepted Public keys: door = {}; card = {}".format(
door_pub, card_pub))
door_secret = crack_loopsize_2(door_pub, 7)
card_secret = crack_loopsize_2(card_pub, 7)
print("Cracked secret loop number: door = {}; card = {}".format(
door_secret, card_secret))
door_encryption = transform(door_pub, card_secret)
card_encryption = transform(card_pub, door_secret)
print("Encyption Keys: door = {}; card = {}".format(
door_encryption, card_encryption))
assert door_encryption == card_encryption
result = door_encryption
# code here
print("Result = {}".format(result))
return result
def run_part_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
rules = loadingUtils.importToArray(in_file)
rule_dict = {}
for rule_str in rules:
parent, child_list = rule_to_dict(rule_str)
if child_list == []:
if debug: print("no children")
rule_dict[str(parent)] = []
continue
if debug:
print("{} --> {}".format(
parent, ", ".join(map(str,
list(zip(*child_list))[1]))))
rule_dict[str(parent)] = list(map(str, list(zip(*child_list))[1]))
if debug: print(rule_dict)
valid_bags = find_valid_bags(rule_dict, "shiny gold")
print(valid_bags)
result = len(valid_bags)
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
boardingpasses = loadingUtils.importToArray(in_file)
seatIDs = []
for boardingpass in boardingpasses:
(row_i, col_i, seatID) = calc_row_column(boardingpass)
seatIDs.append(seatID)
seatIDs.sort()
print(seatIDs)
minSeat = min(seatIDs)
maxSeat = max(seatIDs)
results = []
for seat in range(minSeat, maxSeat):
if seat in seatIDs: continue
if seat+1 not in seatIDs: continue
if seat-1 not in seatIDs: continue
print(seat)
results.append(seat)
assert len(results) == 1
result = results[0]
print("Result = {}".format(result))
return result
def test_importToArrayRaises():
with pytest.raises(FileNotFoundError):
loadingUtils.importToArray("non_exisiting_filename")
def test_importToArray():
out = loadingUtils.importToArray("helper/test_input_importToArray")
assert out == ['2', '4', '6', '8', '99', '-42']
