advent_of_code_2021

day08_part1.py (5698B)

---

 #!/usr/bin/env python
 """Advent of Code 2021, day 8 (part 1): decode the scrambled seven-segment
 displays"""
 
 # This is a fun puzzle. I sat down with pen and paper and proved to myself that
 # you can deduce the mapping from scrambled segments to the full set of digits
 # using just the information provided. It looks like this:
 # * If 2 segments are lit, that's '1'
 # * If 3 segments are lit, that's '7'
 # * If 4 segments are lit, that's '4'
 # * If 7 segments are lit, that's '8'
 # (So far, this was given in the puzzle prompt, nothing new yet)
 # * If 5 segments are lit, it's '2', '3', or '5'
 # * If 6 segments are lit, it's '0', '6', or '9'
 # (Okay, that's not useful... yet)
 # * If 5 segments are lit and they include all the segments in '7', that's '3'
 # * If 6 segments are lit and they don't include all the segments in '7',
 #   that's '6'
 # * If 6 segments are lit and they include the union of the segments comprising
 #   '3' and '4', that's '9'
 # * If 6 segments are lit and it's not a '6' or '9', that's '0'
 # * If 5 segments are lit and it is missing only one of the segments from '6',
 #   that's '5'
 # * If 5 segments are lit and it's not a '5' or a '3', that's '2'
 # So right now in part 1, it's possible to find the four digits displayed for
 # each line of puzzle input! But...
 # I'm not going to implement it yet, because "good programmers are lazy", and
 # maybe part 2 will throw me for a loop? Regardless, figuring this out has
 # influenced my decision about how to represent the data; e.g., we're doing a
 # lot of set operations, so I'm going to use sets for everything, and since
 # it's easy to imagine wanting to use these sets of lit segments as dictionary
 # keys, we'll use immutable `frozenset`s specifically (which can be `dict`
 # keys).
 
 
 import pandas as pd
 from utils import get_puzzle_input, convert_lines_to_series
 
 EXAMPLE_INPUT = \
 """be cfbegad cbdgef fgaecd cgeb fdcge agebfd fecdb fabcd edb | fdgacbe cefdb cefbgd gcbe
 edbfga begcd cbg gc gcadebf fbgde acbgfd abcde gfcbed gfec | fcgedb cgb dgebacf gc
 fgaebd cg bdaec gdafb agbcfd gdcbef bgcad gfac gcb cdgabef | cg cg fdcagb cbg
 fbegcd cbd adcefb dageb afcb bc aefdc ecdab fgdeca fcdbega | efabcd cedba gadfec cb
 aecbfdg fbg gf bafeg dbefa fcge gcbea fcaegb dgceab fcbdga | gecf egdcabf bgf bfgea
 fgeab ca afcebg bdacfeg cfaedg gcfdb baec bfadeg bafgc acf | gebdcfa ecba ca fadegcb
 dbcfg fgd bdegcaf fgec aegbdf ecdfab fbedc dacgb gdcebf gf | cefg dcbef fcge gbcadfe
 bdfegc cbegaf gecbf dfcage bdacg ed bedf ced adcbefg gebcd | ed bcgafe cdgba cbgef
 egadfb cdbfeg cegd fecab cgb gbdefca cg fgcdab egfdb bfceg | gbdfcae bgc cg cgb
 gcafb gcf dcaebfg ecagb gf abcdeg gaef cafbge fdbac fegbdc | fgae cfgab fg bagce
 """
 
 def convert_input_to_df(input_string):
     """Convert the puzzle input to a five-column df: the first a string of
     unique segment sets, and the next four `frozenset` objects representing the
     display digits"""
     display_df= (
         convert_lines_to_series(input_string)
         .str.rsplit(' ', 4, expand=True)
         .rename(columns=dict(enumerate(('segments', 'digit_1', 'digit_2',
                                         'digit_3', 'digit_4'))))
         .assign(segments=lambda x: x['segments'].str.replace(' |', '',
                                                              regex=False))
     )
     display_df.loc[:, 'digit_1':'digit_4'] = (
         display_df.loc[:, 'digit_1':'digit_4'].applymap(frozenset)
     )
     return display_df
 
 def create_mapper_from_segments(segment_sequence):
     """Given the observed sequence of segment sets (which isn't actually used
     for anything here), return a function that maps a `frozenset` of segments
     to a digit"""
     # Another example of getting ready for what part 2 might look like: this is
     # more complicated than necessary but if we do need to decode every line
     # then this function is one of the few that would need to be changed.
     def part_1_mapper(segments):
         """This is the simple mapping function that we need for part 1, that
         identifies the digits '1', '4', '7', and '8' based on the number of
         segments that are lit. Returns the matching digit as a string or `None`
         if its not one of these"""
         return (
             {2: '1', 3: '7', 4: '4', 7: '8'}
             .get(len(segments), None)
         )
     return part_1_mapper
 
 def apply_mappers_to_digits(display_df, mapper_creator):
     """Given a df that contains the unique segment sequence and four columns of
     digits, use the `mapper_creator` function to make a mapping function for
     each row of segment sequences and apply that function to the digits from
     the same row, then return a df with the digits"""
     # I don't love how this is coded, not one bit
     digits_dict = {}
     for col in [f"digit_{i}" for i in range(1, 5)]:
         digits_dict[col] = [f(x) for f, x in \
             zip(display_df['segments'].map(mapper_creator),
                 display_df[col])]
     return pd.DataFrame(digits_dict)
 
 def count_visible_digits(digits_df):
     """Given a four-column df of digit displays, return the number of 'visible'
     digits (one of '1', '4', '7', or '8') present"""
     return int(digits_df.count().sum())
 
 def solve_puzzle(input_string):
     """Return the numeric solution to the puzzle"""
     return count_visible_digits(
         apply_mappers_to_digits(
             convert_input_to_df(input_string),
             create_mapper_from_segments
         )
     )
 
 def main():
     """Run when the file is called as a script"""
     assert solve_puzzle(EXAMPLE_INPUT) == 26
     print("Number of easily decoded digits:",
           solve_puzzle(get_puzzle_input(8)))
 
 if __name__ == "__main__":
     main()