def run_part_1(in_file: str, preamble=25, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
numbers = loadingUtils.importToIntArray(in_file)
result = find_wrong_number(numbers, preamble, debug)
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
seats = loadingUtils.importTo2DArray(in_file)
result = run_until_stable2(seats)
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
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, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
#result = get_number(in_file, 2020)
result = get_number(in_file, 30000000)
# code here
print("Result = {}".format(result))
return result
def run_part_2(in_file: str, _weakness, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
numbers = loadingUtils.importToIntArray(in_file)
result = find_weaknes(numbers, _weakness)
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
treemap = loadingUtils.importTo2DArray(in_file)
if debug: pretty.print2DMap(treemap)
path = get_path_traverse_diagonal(treemap, (1, 3))
result = len(list(filter(lambda x: x == "#", path)))
print("I hit {} trees!".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_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_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
start_map = loadingUtils.importTo2DArray(in_file)
final_map = run2(start_map, 6)
result = count_map(final_map)
# 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
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
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_1(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 1, inspect.stack()[0].function, in_file)
result = 0
adapters = loadingUtils.importToIntArray(in_file)
adapters.sort()
print(adapters)
result = validate_chain(adapters)
# 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
answer_groups = loadingUtils.import_multiline(in_file,
separator="empty Line",
joinString=False)
for answers in answer_groups:
answers = set(itertools.chain.from_iterable(map(list, answers)))
result += len(answers)
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_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
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_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
answer_groups = loadingUtils.import_multiline(in_file,
separator="empty Line",
joinString=False)
for answers in answer_groups:
answers = list(map(set, answers))
intersections = set.intersection(*answers)
result += len(intersections)
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_no_cache(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
_adapters = loadingUtils.importToIntArray(in_file)
_adapters.append(0)
_adapters.sort()
adapters = tuple(_adapters)
print(adapters)
result = get_number_of_chains_no_cache(adapters)
# 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
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_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_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
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)
result = 0
passports = loadingUtils.import_multiline(in_file)
if debug: pretty.print2DMap(passports)
count = 0
for passport in passports:
if complete_passport(passport):
count += 1
# code here
result = count
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_2(in_file: str, debug: bool = False) -> int:
pretty.printHeader(DAY, 2, inspect.stack()[0].function, in_file)
result = 0
treemap = loadingUtils.importTo2DArray(in_file)
if debug: pretty.print2DMap(treemap)
list_of_directions = [(1, 1), (1, 3), (1, 5), (1, 7), (2, 1)]
number_of_trees_per_run = []
for direction in list_of_directions:
number_of_trees_per_run.append(
len(
list(
filter(lambda x: x == "#",
get_path_traverse_diagonal(treemap, direction)))))
print(number_of_trees_per_run)
result = functools.reduce(lambda x, y: x * y, number_of_trees_per_run)
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
