def get_numbers(filepath):
data = []
for line in utils.read_lines(filepath):
num = line.strip()
if num:
data.append(int(num))
return data
def parse(filename: str) -> List[int]:
octopi = []
for line in utils.read_lines(filename, True):
octopi.extend([int(n) for n in line])
return octopi
def part_one(filepath, slope):
tree_count = 0
for line_num, line in enumerate(utils.read_lines(filepath, strip=True)):
index = get_index(len(line), line_num, slope)
if index != -1 and is_tree(line[index]):
tree_count += 1
return tree_count
def parse(filename: str) -> Tuple[List[int], int]:
values = []
width = -1
for line in utils.read_lines(filename, True):
values.extend([int(value) for value in line])
width = len(line)
return values, width
def parse(
filename: str
) -> Generator[Tuple[Tuple[int, int], Tuple[int, int]], None, None]:
for line in utils.read_lines(filename, True):
start, end = [point.strip() for point in line.split("->")]
yield tuple([
tuple(int(value) for value in start.split(",")),
tuple(int(value) for value in end.split(","))
])
def syntax_score(filename: str) -> None:
checkers = []
for line in utils.read_lines(filename, True):
checkers.append(SyntaxChecker(line))
total = 0
for checker in checkers:
checker.process()
if checker.line_status == LineStatus.corrupted:
total += checker.illegal_character_score
print(total)
def build_graph(filepath):
graph = DirectedGraph()
for line in utils.read_lines(filepath):
bag, children = get_bags(line)
graph.add_node(bag)
for child in children:
(count, name) = child
graph.add_node(name)
graph.add_child(bag, name, count)
graph.add_parent(name, bag)
return graph
def part_one_and_two(filpath):
sled_count = 0
santa_count = 0
for line in utils.read_lines(filepath):
rule_part, pwd_part = line.split(":")
rule = Rule.from_rule_str(rule_part)
if rule.is_valid_password_for_sled(pwd_part.strip()):
sled_count += 1
if rule.is_valid_password_for_santa(pwd_part.strip()):
santa_count += 1
return sled_count, santa_count
def part_one(filepath):
sum = 0
group = ""
for line in utils.read_lines(filepath, strip=True):
if line:
group += line
else:
sum += len(set(char for char in group))
group = ""
sum += len(set(char for char in group))
return sum
def part_two(filepath):
sum = 0
group = []
for line in utils.read_lines(filepath, strip=True):
if line:
group.append(set(char for char in line))
else:
sum += len(reduce(lambda x, y: x.intersection(y), group))
group = []
sum += len(reduce(lambda x, y: x.intersection(y), group))
return sum
def part_one_and_two(filepath, rules):
total_valid = 0
regex = re.compile(get_regex(*rules))
passport_lines = []
for line in utils.read_lines(filepath, strip=True):
if line:
passport_lines.append(line)
else:
total_valid += int(is_valid_passpord(passport_lines, regex))
passport_lines = []
total_valid += int(is_valid_passpord(passport_lines, regex))
return total_valid
def parse(filename: str) -> Tuple[str, Dict[str, str]]:
template = ""
insertion_pairs = {}
for line in utils.read_lines(filename, True):
if line:
parts = line.split("->")
if len(parts) == 1:
template = parts[0].strip()
else:
insertion_pairs[parts[0].strip()] = parts[1].strip()
return template, insertion_pairs
def part_two(filepath):
double_pairs = re.compile(r"([a-z][a-z]).*\1")
skip_letter = re.compile(r"([a-z]).{1}\1")
valid_count = 0
for line in utils.read_lines(filepath, strip=True):
has_double_pairs = double_pairs.search(line) is not None
has_skip_letter = skip_letter.search(line) is not None
if has_double_pairs and has_skip_letter:
valid_count += 1
return valid_count
def autocomplete_score(filename: str) -> None:
checkers = []
for line in utils.read_lines(filename, True):
checkers.append(SyntaxChecker(line))
scores = []
for checker in checkers:
checker.process()
if checker.line_status == LineStatus.incomplete:
scores.append(checker.autocomplete_score)
scores.sort()
print(scores[int(len(scores) / 2)])
def part_one(filepath):
double_letters = re.compile(r"(.)\1{1,}")
three_vowels = re.compile(r"^(.*[aeiou].*){3,}$")
does_not_have = re.compile(r"^((?!ab|cd|pq|xy).)*$")
valid_count = 0
for line in utils.read_lines(filepath, strip=True):
has_double_letters = double_letters.search(line) is not None
has_three_vowels = three_vowels.search(line) is not None
has_does_not_have = does_not_have.search(line) is not None
if has_double_letters and has_three_vowels and has_does_not_have:
valid_count += 1
return valid_count
def parser(
filename: str) -> Tuple[Tuple[int, ...], Tuple[Tuple[int, ...], ...]]:
guesses = None
boards = []
current_board = []
for line in utils.read_lines(filename, True):
if guesses is None:
guesses = tuple(int(value) for value in line.split(","))
continue
if line:
current_board.extend([int(value) for value in line.split()])
elif not line and current_board:
boards.append(tuple(board for board in current_board))
current_board = []
boards.append(tuple(board for board in current_board))
return guesses, tuple(boards)
def window_depth_changes(filename: str, window_size: int) -> tuple:
depth_map = []
current_window_values = []
previous = None
for line in utils.read_lines(filename):
if line:
current_window_values.append(int(line))
if len(current_window_values) == window_size:
total = sum(current_window_values)
if previous is None or previous == total:
change = 0
else:
change = 1 if total > previous else -1
depth_map.append((total, change))
previous = total
current_window_values.pop(0)
return tuple(depth_map)
def execute(self, filepath, attempt_fix):
env = RuntimeEnvironment()
lines = []
for line in utils.read_lines(filepath):
operation, argument = line.split(" ")
lines.append([operation, int(argument)])
try:
return self._execute(lines, env)
except InterpreterInfiniteLoopError:
print("Infinite loop found.")
if attempt_fix:
print("Attempting to auto-fix.")
fixed_env = self.attempt_fix(lines, env.executed_lines)
if fixed_env:
print("Successfully auto-fixed program.")
return fixed_env.accumulator
else:
print("Failed to auto-fix program.")
print("Exiting interpreter and returning partially completed runtime accumulator value.")
return env.accumulator
def __init__(self, filename: str) -> None:
self.width = 0
self.height = 0
self._by_row = defaultdict(set)
self._by_col = defaultdict(set)
self._instructions = []
for line in utils.read_lines(filename, True):
if line:
parts = line.split(",")
if len(parts) == 2:
x, y = int(parts[0]), int(parts[1])
if x + 1 > self.width:
self.width = x + 1
if y + 1 > self.height:
self.height = y + 1
self._by_row[y].add(x)
self._by_col[x].add(y)
else:
parts = line.split("=")
self._instructions.append(
(parts[0].split(" ")[-1], int(parts[1])))
co2 = self._filter_co2()[0]
oxy = int(oxy, 2)
co2 = int(co2, 2)
return oxy, co2
def get_power_consumption(self) -> int:
return reduce(lambda x, y: x * y,
self._get_gamma_and_sigma(self.values))
def get_life_support_rating(self) -> int:
return reduce(lambda x, y: x * y, self._get_oxygen_and_co2())
if __name__ == "__main__":
test_filename = "2021/03-test.txt"
filename = "2021/03.txt"
test_values = [
line for line in utils.read_lines(test_filename, True) if line
]
values = [line for line in utils.read_lines(filename, True) if line]
test_diag = Diagnostic(test_values)
print(f"Test Power: {test_diag.get_power_consumption()}")
print(f"Test Life: {test_diag.get_life_support_rating()}")
diag = Diagnostic(values)
print(f"Real Power: {diag.get_power_consumption()}")
print(f"Real Life: {diag.get_life_support_rating()}")
def parse(filename: str) -> Matrix:
data = []
for line in utils.read_lines(filename, True):
data.append(tuple(int(x) for x in line))
return tuple(data)
def parse(filename: str):
for line in utils.read_lines(filename, True):
signal, output = tuple(x.strip() for x in line.split("|"))
yield tuple(s for s in signal.split(" ")), tuple(
o for o in output.split(" "))
def get_directions(filename: str) -> Tuple[Direction, int]:
for line in utils.read_lines(filename):
direction, amount = line.split(" ")
yield (Direction(direction), int(amount))
def get_presents(filepath):
for line in utils.read_lines(filepath):
length, width, height = line.split("x")
yield Present(length=int(length), width=int(width), height=int(height))
