Solve puzzle 2 of day 3

Author: bielsnohr

03/binary_diagnostic.py

@@ -1,18 +1,19 @@
 #! /usr/bin/env python3
 from pathlib import Path
-import math
+from typing import Callable
+
 
 def gamma_epsilon_product(report: "list[str]") -> int:
     bin_digit_count = sum_bin_digits(report)
     gamma = gamma_rate(bin_digit_count, len(report))
     # epsilon rate is the unsigned complement, but because Python has two's
     # complement representation, this isn't the simple unary bitwise negation
     # (~)
-    epsilon = ~gamma & (2**(len(bin(gamma)) - 2) - 1)
+    epsilon = invert_bin_num(gamma)
     return gamma * epsilon
 
 
-def gamma_rate(bit_counts: "list[int]", report_length : int) -> int:
+def gamma_rate(bit_counts: "list[int]", report_length: int) -> int:
     threshold = report_length // 2
     most_common_bit = ['1' if x > threshold else '0' for x in bit_counts]
     bin_string = '0b' + ''.join(most_common_bit)
@@ -27,6 +28,69 @@ def sum_bin_digits(bin_numbers: "list[str]") -> "list[int]":
     return bin_digit_count
 
 
+def invert_bin_num(bin_num: int) -> int:
+    """Invert a positive binary number (i.e. no consideration of two's complement implementation)
+
+    Args:
+        bin_num (int): the binary number
+
+    Returns:
+        int: the complement/inverse of bin_num
+    """
+    return ~bin_num & (2**(len(bin(bin_num)) - 2) - 1)
+
+
+def bin_list_to_int(bin_list: "list[int]") -> int:
+    bin_string = '0b' + ''.join([str(x) for x in bin_list])
+    return int(bin_string, base=2)
+
+
+def filter_readings(report_section: "list[list[int]]", column: int,
+                    digit: int) -> "list[list[int]]":
+    return list(filter(valid_reading_functor(column, digit), report_section))
+
+
+def valid_reading_functor(column: int, digit: int) -> Callable:
+    def valid_reading(reading: "list[int]") -> bool:
+        return reading[column] == digit
+
+    return valid_reading
+
+
+def most_common_digit(report_section: "list[list[int]]", column: int) -> int:
+    sum = 0
+    threshold = len(report_section) // 2
+    even_length = len(report_section) % 2 == 0
+    for reading in report_section:
+        sum += reading[column]
+    if sum == threshold and even_length:
+        most_common_digit = 1
+    elif sum > threshold:
+        most_common_digit = 1
+    else:
+        most_common_digit = 0
+    return most_common_digit
+
+
+def least_common_digit(report_section: "list[list[int]]", column: int) -> int:
+    return invert_bin_num(most_common_digit(report_section, column))
+
+
+def find_unique_rating(report: "list[list[int]]", column: int, digit_selector: Callable) -> int:
+    digit = digit_selector(report_section=report, column=column)
+    report_subsection = filter_readings(report_section=report, column=column, digit=digit)
+    if len(report_subsection) == 1:
+        return report_subsection[0]
+    else:
+        return find_unique_rating(report=report_subsection, column=column + 1, digit_selector=digit_selector)
+
+
+def life_support_rating(report: "list[list[int]]") -> int:
+    oxygen_generator_rating = find_unique_rating(report=report, column=0, digit_selector=most_common_digit)
+    co2_scrubber_rating = find_unique_rating(report=report, column=0, digit_selector=least_common_digit)
+    return bin_list_to_int(oxygen_generator_rating) * bin_list_to_int(co2_scrubber_rating)
+
+
 def puzzle_1(inputfile: Path) -> int:
     report = open(inputfile, 'r')
     with open(inputfile, 'r') as file:
@@ -35,13 +99,16 @@ def puzzle_1(inputfile: Path) -> int:
 
 
 def puzzle_2(inputfile: Path) -> int:
-    pass
+    report = open(inputfile, 'r')
+    with open(inputfile, 'r') as file:
+        report = [[int(digit) for digit in line.rstrip('\n')] for line in file]
+    return life_support_rating(report)
 
 
 def main():
     inputfile = Path("puzzle_1_input.txt")
     print(f"Puzzle 1 Answer = {puzzle_1(inputfile)}")
-    #print(f"Puzzle 2 Answer = {puzzle_2(inputfile)}")
+    print(f"Puzzle 2 Answer = {puzzle_2(inputfile)}")
 
 
 if __name__ == "__main__":

03/test_binary_diagnostic.py

@@ -1,5 +1,8 @@
 from binary_diagnostic import gamma_epsilon_product, gamma_rate, sum_bin_digits
-from binary_diagnostic import puzzle_1, Path
+from binary_diagnostic import puzzle_1, puzzle_2, Path
+from binary_diagnostic import valid_reading_functor, filter_readings
+from binary_diagnostic import most_common_digit, least_common_digit
+from binary_diagnostic import find_unique_rating, life_support_rating
 import pytest
 
 
@@ -13,6 +16,13 @@ def bin_report():
     return ['00100', '11110', '10110', '10111', '10101', '01111', '00111',
             '11100', '10000', '11001', '00010', '01010']
 
+@pytest.fixture
+def int_report(bin_report):
+    readings = []
+    for reading in bin_report:
+        readings.append([int(x) for x in reading])
+    return readings
+
 
 def test_gamma_rate(bin_digit_count):
     assert gamma_rate(bin_digit_count, 12) == 22
@@ -21,9 +31,45 @@ def test_gamma_rate(bin_digit_count):
 def test_sum_bin_digits(bin_report, bin_digit_count):
     assert sum_bin_digits(bin_report) == bin_digit_count
 
+
 def test_gamma_epsilon_product(bin_report):
     assert gamma_epsilon_product(bin_report) == 198
 
 
 def test_puzzle_1():
     assert puzzle_1(Path(__file__).parent / "puzzle_1_test_input.txt") == 198
+
+
+@pytest.mark.parametrize(("column", "digit"), [
+    [0, 1], [1, 0], [2, 1], [3, 1], [4, 1]
+])
+def test_valid_reading_functor(column, digit):
+    assert valid_reading_functor(column, digit)([1, 0, 1, 1, 1])
+
+
+def test_filter_readings(int_report):
+    filtered_readings = [[1, 1, 1, 1, 0], [1, 0, 1, 1, 0], [1, 0, 1, 1, 1],
+                         [1, 0, 1, 0, 1], [1, 1, 1, 0, 0], [1, 0, 0, 0, 0],
+                         [1, 1, 0, 0, 1]]
+    assert filter_readings(int_report, 0, 1) == filtered_readings
+
+
+def test_common_digit_selectors(int_report):
+    assert most_common_digit(report_section=int_report, column=0) == 1
+    assert least_common_digit(report_section=int_report, column=0) == 0
+    split_report = [[0], [0], [0], [1], [1], [1]]
+    assert most_common_digit(report_section=split_report, column=0) == 1
+    assert least_common_digit(report_section=split_report, column=0) == 0
+
+
+def test_find_unique_rating(int_report):
+    assert find_unique_rating(report=int_report, column=0, digit_selector=most_common_digit) == [1, 0, 1, 1, 1]
+    assert find_unique_rating(report=int_report, column=0, digit_selector=least_common_digit) == [0, 1, 0, 1, 0]
+
+
+def test_life_support_rating(int_report):
+    assert life_support_rating(report=int_report) == 230
+
+
+def test_puzzle_2():
+    assert puzzle_2(Path(__file__).parent / "puzzle_1_test_input.txt") == 230