def get_score(game): players, marbles = parse_game(game) game = Game() pos = 0 # position of last placed marble. scores = dict() for i in range(marbles): p = (i % players) + 1 # 1-indexed m = i + 1 # marble value game_size = game.size() if i != 0 and i % 100000 == 0: print("loop", i, "done: ", int(m/marbles * 100), "%", get_time(start)) # Special cases. if m % 23 == 0: # now find the marble 7 steps left. or it's position. pos = (game_size + pos - 7) % game_size # add score of marble + the pos 7 left. scores = add_score(scores, p, m + game.get(pos)) game.remove(pos) else: pos = ((pos + 1) % game_size) + 1 game.add(pos, m) return max(scores.items(), key=operator.itemgetter(1))[1]
def run_compiled_code(input_path, output_dir_path, args, stdin): ''' Run complied c source code executable. Arguments: input_path {str} -- File path of compiled c source code output_dir_path {str} -- File path to store `time` command output args {list} -- Arguments required to run c program stdin {list} -- Passwords required to run c program Returns: float -- [description] ''' input_file = fs.details(input_path) run_output_file = FILE_NAME['run'].format(name=input_file['name']) run_output_file_path = os.path.join(output_dir_path, run_output_file) execute = CMD['run'].format(input=input_path, args=' '.join(args), stdin='\n'.join(stdin)) time = CMD['time'].format(cmd=execute, output=run_output_file_path) cmd = CMD['bash'].format(time) output = str(os.popen(cmd).read()) content = fs.read(run_output_file_path) print(output) return { 'time-taken': get_time(content), }
pos = (game_size + pos - 7) % game_size # add score of marble + the pos 7 left. scores = add_score(scores, p, m + game.get(pos)) game.remove(pos) else: pos = ((pos + 1) % game_size) + 1 game.add(pos, m) return max(scores.items(), key=operator.itemgetter(1))[1] def add_score(scores, p, v): if p in scores: scores[p] = scores[p] + v else: scores[p] = v return scores if __name__ == "__main__": with open('input/day09.txt') as f: lines = f.read().splitlines() part1 = lines[0] part2 = lines[1] start = timer() print("result day 09 part 1: ", get_score(part1), " in ", get_time(start)) start = timer() print("result day 09 part 2: ", get_score(part2), " in ", get_time(start))
from utils.time import get_time def parse_answer_anyone(answer): return set(answer.replace("\n", "").strip()) def parse_answer_everyone(answer): everyone = len(answer.splitlines()) chars = answer.replace("\n", "").strip() return [c for c in set(chars) if chars.count(c) == everyone] def count_sums(answers): return sum([len(a) for a in answers]) if __name__ == "__main__": with open('input/day06.txt') as f: answers = f.read().split("\n\n") start = timer() answers_anyone = [parse_answer_anyone(a) for a in answers] print("result day 06 part 1: {} in {}".format(count_sums(answers_anyone), get_time(start))) start = timer() answers_everyone = [parse_answer_everyone(a) for a in answers] print("result day 06 part 2: {} in {}".format(count_sums(answers_everyone), get_time(start)))
def is_valid(password): char_min, char_max, char, password = password char_curr = password.count(char) return char_min <= char_curr and char_max >= char_curr def valid_passwords(passwords): return len([p for p in passwords if is_valid(p)]) def is_valid_toboggan(password): pos_1, pos_2, char, password = password return (password[pos_1 - 1] == char) != (password[pos_2 - 1] == char) def valid_passwords_toboggan(passwords): return len([p for p in passwords if is_valid_toboggan(p)]) if __name__ == "__main__": with open('input/day02.txt') as f: passwords = [parse_password(p) for p in f.read().splitlines()] start = timer() print("result day 02 part 1: {} in {}".format(valid_passwords(passwords), get_time(start))) start = timer() print("result day 02 part 2: {} in {}".format( valid_passwords_toboggan(passwords), get_time(start)))
for c in self.child_nodes: met += c.get_metadata() return met def get_value(self): if self.qty_child < 1: return sum(self.metadata) else: val = 0 for m in self.metadata: # m is the index of child + 1. if self.qty_child > m - 1: val += self.child_nodes[m - 1].get_value() return val def get_nodes(license): return Node(list(map(int, license.split(" ")))) if __name__ == "__main__": with open('input/day08.txt') as f: params = f.read().splitlines()[0] start = timer() nodes = get_nodes(params) print("result day 08 part 1: ", sum(nodes.get_metadata()), " in ", get_time(start)) start = timer() print("result day 08 part 2: ", nodes.get_value(), " in ", get_time(start))
last = polymer else: break return polymer # return a set of all unique units (just lowercase) def get_units(polymer): return set(polymer.lower()) def remove(polymer, unit): p = polymer.replace(unit, "").replace(unit.swapcase(), "") return len(react(p)) def shortest(polymer): return min([remove(polymer, x) for x in get_units(polymer)]) if __name__ == "__main__": with open('input/day05.txt') as f: params = f.read().splitlines()[0] start = timer() print("result day 05 part 1: ", len(react(params)), " in ", get_time(start)) start = timer() print("result day 05 part 2: ", shortest(params), " in ", get_time(start))
# compare all grids to all others and store unique intersection def duplicates(grids): return [coo for coo, v in grids.items() if len(v) > 1] # unique grid simply mean non of the coordinates we had in duplicates. def unique(grids): ids = set() bad = set() for coo, v in grids.items(): ids = ids | set(v) if len(v) > 1: bad = bad | set(v) return ids.difference(bad).pop() if __name__ == "__main__": with open('input/day03.txt') as f: params = f.read().splitlines() start = timer() grids = get_grids(params) print("got grids ", len(grids), " in ", get_time(start)) start = timer() print("result day 03 part 1: ", len(duplicates(grids)), " in ", get_time(start)) start = timer() print("result day 03 part 2: ", unique(grids), " in ", get_time(start))
for t in ts: if is_alone(t, ts): alone = True break if alone: continue else: print("Message shown after ", step, " seconds.") break min_x, min_y, max_x, max_y = get_limits(ts) ret = "" for x in range(min_x, max_x + 1): for y in range(min_y, max_y + 1): if (x, y) in ts: ret += "#" else: ret += "." ret += "\n" return ret if __name__ == "__main__": with open('input/day10.txt') as f: lines = f.read().splitlines() start = timer() print("result day 10 part 1+2: \n") print(sky(get_points(lines)), " in ", get_time(start))
# Create an (inverted) mask of the diff. 0 means match, 1 means drop def diff_mask(box_a, box_b): return [0 if x == y else 1 for x, y in zip(box_a, box_b)] # get the match according to mask. def unmask(box, mask): return "".join(v for m, v in zip(mask, box) if m != v) if __name__ == "__main__": with open('input/day02.txt') as f: params = f.read().splitlines() start = timer() print("result day 02 part 1: ", list_checksum(params), " in ", get_time(start)) start = timer() print("result day 02 part 2: ", diff_one(set(params)), " in ", get_time(start)) # Speed measurement, python is way faster working on sets than on lists. #for i in range(10): # start = timer() # print("[", i, "] result day 02 part 2: ", diff_one(params), " in ", get_time(start)) # #paramset = set(params) #for i in range(10): # start = timer() # print("[", i, "] result day 02 part 2 with set: ", diff_one(paramset), " in ", get_time(start)) #
max_x = len(geo[0]) max_y = len(geo) if curr_y >= max_y: return acc if geo[curr_y][curr_x % max_x] == TREE: acc += 1 return count_trees(geo, curr_x + slope_x, curr_y + slope_y, acc, slope_x, slope_y) if __name__ == "__main__": with open('input/day03.txt') as f: geo = f.read().splitlines() start = timer() print("result day 03 part 1: {} in {}".format(count_trees(geo), get_time(start))) start = timer() slope_1 = count_trees(geo, slope_x=1, slope_y=1) slope_2 = count_trees(geo, slope_x=3, slope_y=1) slope_3 = count_trees(geo, slope_x=5, slope_y=1) slope_4 = count_trees(geo, slope_x=7, slope_y=1) slope_5 = count_trees(geo, slope_x=1, slope_y=2) print("result day 03 part 2: {} in {}".format( (slope_1 * slope_2 * slope_3 * slope_4 * slope_5), get_time(start)))
else: row = int(RE_MEM_LINE.findall(target)[0]) mem[row] = mask_dec(int(value), mask) return sum(mem.values()) def run_mad(program: str) -> int: mask = None mem = {} for line in program: target, value = line.split(" = ") if target == 'mask': mask = value else: row = int(RE_MEM_LINE.findall(target)[0]) addresses = mask_mem(int(row), mask) for address in addresses: mem[address] = int(value) return sum(mem.values()) if __name__ == "__main__": with open('input/day14.txt') as f: program = f.read().splitlines() start = timer() print("result day 14 part 1: {} in {}".format(run_program(program), get_time(start))) start = timer() print("result day 14 part 2: {} in {}".format(run_mad(program), get_time(start)))
return list(set(bags)) def can_carry(tree, color="shiny gold"): # simplify the tree to a color tree for speed. color_tree = {} for bag in tree: color_tree[bag] = [color for color, count in tree[bag]] return set(get_carrier(color_tree, color)) def count_children(tree, color): cnt = 1 for child_color, count in tree[color]: cnt += int(count) * count_children(tree, child_color) return cnt if __name__ == "__main__": with open('input/day07.txt') as f: rules = f.read().splitlines() start = timer() tree = build_tree(rules) print("result day 07 part 1: {} in {}".format( len(can_carry(tree, "shiny gold")), get_time(start))) start = timer() print("result day 07 part 2: {} in {}".format( count_children(tree, "shiny gold") - 1, get_time(start)))
pos = (direction, x + (value * w_x), y + (value * w_y)) elif action in ['L', 'R']: waypoint = turn_waypoint(waypoint, action, value) return pos, waypoint def navigate_waypoint(instructions): pos = ('E', 0, 0) # facing east, position 0, 0 waypoint = (1, 10) # 1 north, 10 east for instruction in parse_instructions(instructions): pos, waypoint = step_waypoint(pos, waypoint, instruction) return pos def distance_waypoint(instructions): _, x, y = navigate_waypoint(instructions) return abs(x) + abs(y) if __name__ == "__main__": with open('input/day12.txt') as f: nav_instructions = f.read().splitlines() start = timer() print("result day 12 part 1: {} in {}".format(distance(nav_instructions), get_time(start))) start = timer() print("result day 12 part 2: {} in {}".format( distance_waypoint(nav_instructions), get_time(start)))
return number def chunk_list(lst, size): return [lst[i:i + size] for i in range(0, len(lst), size)] def find_contigous(numbers, target): for i in range(2, len(numbers) - 1): for offset in range(0, i): sets = chunk_list(numbers[offset:], i) for s in sets: if len(s) > 1: if sum(s) == target: return min(s) + max(s) if __name__ == "__main__": with open('input/day09.txt') as f: numbers = f.read().splitlines() numbers = list(map(int, numbers)) start = timer() target = find_first(numbers, 25) print("result day 09 part 1: {} in {}".format(target, get_time(start))) start = timer() print("result day 09 part 2: {} in {}".format( find_contigous(numbers, target), get_time(start)))
if not byr(p['byr']): continue if not iyr(p['iyr']): continue if not eyr(p['eyr']): continue if not hgt(p['hgt']): continue if not hcl(p['hcl']): continue if not ecl(p['ecl']): continue if not pid(p['pid']): continue cnt += 1 return cnt if __name__ == "__main__": with open('input/day04.txt') as f: passports = f.read().split("\n\n") passports = [parse_passport(p) for p in passports] start = timer() print("result day 04 part 1: {} in {}".format( p1_valid_passports(passports), get_time(start))) start = timer() print("result day 04 part 2: {} in {}".format( p2_valid_passports(passports), get_time(start)))
# Return the minute this guard slept the most. def top_minute(logs, guard): return max(logs[guard].items(), key=operator.itemgetter(1))[0] # Return id of the guard with max frequence. def max_freq(logs): dmax = dict() for g in logs: dmax[g] = max(logs[g].values()) return max(dmax.items(), key=operator.itemgetter(1))[0] if __name__ == "__main__": with open('input/day04.txt') as f: params = f.read().splitlines() start = timer() logs = read_log(params) sleep_guard = max_sleep(logs) sleep_minute = top_minute(logs, sleep_guard) print("result day 04 part 1: guard: ", sleep_guard, " minute: ", sleep_minute, " answer: ", sleep_guard * sleep_minute, " in ", get_time(start)) start = timer() freq_guard = max_freq(logs) freq_minute = top_minute(logs, freq_guard) print("result day 04 part 2: guard: ", freq_guard, " minute: ", freq_minute, " answer: ", freq_guard * freq_minute, " in ", get_time(start))
def find_iter(arr, size, target=2020): for combination in combinations(arr, size): if sum(combination) == target: return combination if __name__ == "__main__": with open('input/day01.txt') as f: expense_report = [int(m) for m in f.read().splitlines()] expense_report.sort() start = timer() (x, y) = find_pair(expense_report) print("result day 01 part 1: pair={}, product={} in {}".format( (x, y), x * y, get_time(start))) start = timer() (x, y, z) = find_triple(expense_report) print("result day 01 part 2: triple={}, product={} in {}".format( (x, y, z), x * y * z, get_time(start))) # using itertools. slower but cleaner. (x, y) = find_iter(expense_report, 2) print("result day 01 part 1 using itertools: pair={}, product={} in {}". format((x, y), x * y, get_time(start))) start = timer() (x, y, z) = find_iter(expense_report, 3) print("result day 01 part 2 using itertools: triple={}, product={} in {}". format((x, y, z), x * y * z, get_time(start)))
step_buses = [target_bus] is_valid = False while not is_valid: is_valid = True # think positive! step = get_step(step_buses) time = time + step for bus_id in bus_ids: bus_t = time + bus_offsets[bus_id] if bus_t % bus_id == 0: if bus_id not in step_buses: step_buses.append(bus_id) else: is_valid = False break if is_valid: break return time if __name__ == "__main__": with open('input/day13.txt') as f: notes = f.read().splitlines() start = timer() print("result day 13 part 1: {} in {}".format(find_earliest_bus(notes), get_time(start))) start = timer() print("result day 13 part 2: {} in {}".format( find_sequence_timestamp(notes[1]), get_time(start)))
# try changing one jmp/nop at a time and run to see if it exists normally. normal_exit = False pos = 0 result = 0 while not normal_exit: op, arg = program[pos] new_program = program.copy() if op == "jmp": new_program[pos] = ("nop", arg) result, normal_exit = run(new_program) elif op == "nop": new_program[pos] = ("jmp", arg) result, normal_exit = run(new_program) pos = pos + 1 return result if __name__ == "__main__": with open('input/day08.txt') as f: instructions = f.read().splitlines() start = timer() program = parse_instructions(instructions) result, _ = run(program) print("result day 07 part 1: {} in {}".format(result, get_time(start))) start = timer() program = parse_instructions(instructions) print("result day 07 part 2: {} in {}".format(run_fixed(program), get_time(start)))
return sum(params_as_int(parameters)) # Return the first value we'll reach twice. def twice(parameters): values = params_as_int(parameters) pos = 0 result = 0 history = set() history.add(0) while True: pos = pos % len(values) result = values[pos] + result if result in history: return result else: pos = pos + 1 history.add(result) if __name__ == "__main__": with open('input/day01.txt') as f: params = f.read().splitlines() start = timer() print("result day 01 part 1: ", sum_array(params), " in ", get_time(start)) start = timer() print("result day 01 part 2: ", twice(params), " in ", get_time(start))
if len(set(v) - set(done)) == 0: o += k o.sort() # Add work if we have free workers. while len(w) < workers and len(o) > 0: job = o[0] w[job] = offset + get_char_time(job) o.remove(job) print("time:", time, " w: ", w, " done: ", "".join(done)) return time, "".join(done) def get_char_time(c): return ord(c) - 64 if __name__ == "__main__": with open('input/day07.txt') as f: params = f.read().splitlines() start = timer() instructions = read_inst(params) print("result day 07 part 1: ", timed_order_inst(instructions), " in ", get_time(start)) start = timer() print("result day 07 part 2: ", timed_order_inst(instructions, 5, 60), " in ", get_time(start))