def main(input_file: IO):
input_lines: List[str] = input_file.readlines()
timers: List[str] = [i for i in input_lines[0].split(',')]
population = be_fruitful(timers, 80)
print_solution(str(population))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
error_lines = find_all_corrupted(input_lines)[1]
points = {"(": 1, "[": 2, "{": 3, "<": 4}
point_tallies = []
for line in input_lines:
if line in error_lines:
continue
brackets = []
for c in line:
if c in "{([<":
brackets.append(c)
continue
brackets.pop()
score = 0
for i in range(len(brackets) - 1, -1, -1):
score = (score * 5) + points[brackets[i]]
point_tallies.append(score)
point_tallies.sort()
answer = point_tallies[(len(point_tallies) // 2)]
print_solution(str(answer))
def main(input_file: IO):
all_points, raw_folds = input_file.read().split('\n\n')
points: Set[Tuple[int, int]] = set()
for raw_point in all_points.splitlines():
x, y = raw_point.split(',')
points.add((int(x), int(y)))
raw_folds = raw_folds.splitlines()
folds: List[Tuple[str, int]] = []
for f in raw_folds:
match = re.findall(r'[xy]=\d+$', f)
axis, number = match[0].split('=')
folds.append((axis, int(number)))
for i in range(1):
fold = folds[i]
for point in points.copy():
x, y = point
if fold[0] == 'x' and fold[1] < point[0]:
translation = (x - fold[1]) * 2
points.remove(point)
points.add((x - translation, y))
if fold[0] == 'y' and fold[1] < point[1]:
translation = (y - fold[1]) * 2
points.remove(point)
points.add((x, y - translation))
print_solution(str(len(points)))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
errors = find_all_corrupted(input_lines)[0]
points = {")": 3, "]": 57, "}": 1197, ">": 25137}
total_score = sum([points[e] for e in errors])
print_solution(str(total_score))
def main(input_file: IO):
input_lines: List[str] = input_file.readlines()
count = 0
for i in input_lines:
output = i.split(' | ')[1].strip().split(" ")
# Find 1, 4, 7, and 8: 1 = 2, 4 = 4, 7 = 3, 8 = 7
output = [o for o in output if len(o) in [2, 4, 3, 7]]
count = count + len(output)
print_solution(str(count))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
grid: Dict[Tuple[int, int], int] = {}
for y, row in enumerate(input_lines):
for x, num in enumerate(row):
grid[(x, y)] = int(num)
low_points = find_low_points(grid)[1]
print_solution(str(sum(low_points) + len(low_points)))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
graph = defaultdict(set)
for line in input_lines:
start, end = line.split('-')
graph[start].add(end)
graph[end].add(start)
paths = []
find_paths(graph, 'start', [], paths)
print_solution(str(len(paths)))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
grid: Grid = {}
for y, row in enumerate(input_lines):
for x, num in enumerate(row):
grid[(x, y)] = int(num)
total_flashes = 0
for _ in range(100):
# Initial increments of the step
for point in grid:
grid[point] += 1
total_flashes += flash(grid)
print_solution(str(total_flashes))
def main(input_file: IO):
input_lines: str = input_file.read()
numbers = [int(i) for i in input_lines.split(',')]
pos_counts = {pos: numbers.count(pos) for pos in numbers}
least_fuel = 0
for alignment in range(max(numbers)):
fuel_needed = sum(
[abs(p - alignment) * c for p, c in pos_counts.items()])
if not least_fuel:
least_fuel = fuel_needed
elif least_fuel > fuel_needed:
least_fuel = fuel_needed
print_solution(str(least_fuel))
def main(input_file: IO):
input_lines: List[str] = input_file.readlines()
output_sum = 0
for line in input_lines:
segments, outputs = line.split(' | ')
segments = segments.split(' ')
digits = [letters_to_bits(seg) for seg in segments]
outputs = [o.strip() for o in outputs.split(' ')]
output_digits = [letters_to_bits(o) for o in outputs]
# Simple, wire count-based
one = find_one(digits)
four = find_four(digits)
seven = find_seven(digits)
eight = find_eight(digits)
# Comparison-based
three = find_three(digits, one)
nine = find_nine(digits, four)
zero, six = find_zero_and_six(digits, one, nine)
two, five = find_two_and_five(digits, three, six)
digit_mappings = {
zero: '0',
one: '1',
two: '2',
three: '3',
four: '4',
five: '5',
six: '6',
seven: '7',
eight: '8',
nine: '9'
}
output_number = ''
for o in output_digits:
output_number += digit_mappings[o]
output_sum += int(output_number)
print_solution(str(output_sum))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
grid: Grid = {}
for y, row in enumerate(input_lines):
for x, num in enumerate(row):
grid[(x, y)] = int(num)
low_points = find_low_points(grid)[0]
basin_sizes = []
for point in low_points:
basin = find_basins(grid, point, set())
basin_sizes.append(len(basin))
basin_sizes.sort(reverse=True)
print_solution(str(prod(basin_sizes[:3])))
def main(input_file: IO):
all_points, raw_folds = input_file.read().split('\n\n')
points: Set[Tuple[int, int]] = set()
for raw_point in all_points.splitlines():
x, y = raw_point.split(',')
points.add((int(x), int(y)))
raw_folds = raw_folds.splitlines()
folds: List[Tuple[str, int]] = []
for f in raw_folds:
match = re.findall(r'[xy]=\d+$', f)
axis, number = match[0].split('=')
folds.append((axis, int(number)))
for fold in folds:
for point in points.copy():
x, y = point
if fold[0] == 'x' and fold[1] < point[0]:
translation = (x - fold[1]) * 2
points.remove(point)
points.add((x - translation, y))
if fold[0] == 'y' and fold[1] < point[1]:
translation = (y - fold[1]) * 2
points.remove(point)
points.add((x, y - translation))
xs, ys = list(zip(*list(points)))
x_max = max(xs) + 1
y_max = max(ys) + 1
display = []
for y in range(y_max):
row = [' '] * (x_max)
for x in range(x_max):
if (x, y) in points:
row[x] = '#'
display.append('\t' + ''.join(row))
print_solution('\n' + '\n'.join(display))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
grid: Grid = {}
for y, row in enumerate(input_lines):
for x, num in enumerate(row):
grid[(x, y)] = int(num)
target_flashes = len(input_lines) * len(input_lines[0])
step = 0
while True:
for point in grid:
grid[point] += 1
if flash(grid) == target_flashes:
break
step += 1
print_solution(str(step + 1))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
solution = find_counts(input_lines, 10)
print_solution(str(solution))
def main(input_file: IO):
input_lines: List[str] = input_file.read().splitlines()
print_solution("Not yet solved.")
