From 811d2cb224bc510c9a15ceabba927aa6d941f31f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Anders=20Ytterstr=C3=B6m?= Date: Wed, 8 Dec 2021 11:28:31 +0100 Subject: [PATCH] Solve 2021:8 "Seven Segment Search" For part 1, it took way longer than necessary since I read the instructions over and over again. Gotta love AOC WOT. Part 2 was a PITA. I got stuck at the last 2 examples since I at the time did not find any clever way to determine which of the 2 outputs for '1' mapped to c and f. Since I already spent far too much time and effort, a try/except with ValueError (digits.index will fail if c and f are flipped wrong) will do for now. There is probably a more efficient and smart way to do this. --- 2021-python/solutions/day_08.py | 113 +++++++++++++++++++++++++++++++ 2021-python/tests/test_day_08.py | 66 ++++++++++++++++++ 2 files changed, 179 insertions(+) create mode 100644 2021-python/solutions/day_08.py create mode 100644 2021-python/tests/test_day_08.py diff --git a/2021-python/solutions/day_08.py b/2021-python/solutions/day_08.py new file mode 100644 index 0000000..185d932 --- /dev/null +++ b/2021-python/solutions/day_08.py @@ -0,0 +1,113 @@ +from solutions import BaseSolution + + +class Solution(BaseSolution): + input_file = "08.txt" + + def __str__(self): + return "Day 8: Seven Segment Search" + + def parse_input(self, data): + def parse(l): + i, o = l.split(" | ") + return i.split(), o.split() + + return [parse(l) for l in data.strip().splitlines()] + + def solve(self, puzzle_input): + return sum(sum(len(d) in (2, 3, 4, 7) for d in l[1]) for l in puzzle_input) + + def solve_again(self, puzzle_input): + digits = [ + "abcefg", + "cf", + "acdeg", + "acdfg", + "bcdf", + "abdfg", + "abdefg", + "acf", + "abcdefg", + "abcdfg", + ] + outs = [] + + def outsum(n): + out = ["".join(sorted(n[s] for s in d)) for d in digits] + outs.append( + int( + "".join( + map( + str, + [out.index(i) for i in ["".join(sorted(oo)) for oo in o]], + ) + ) + ) + ) + + for i, o in puzzle_input: + n = {} + v1, v7, v4, v8 = sorted( + list(filter(lambda o: len(o) in (2, 3, 4, 7), i)), key=lambda x: len(x) + ) + c, f = v1 + n["a"] = a = (set(v7) - set(v1)).pop() + v235 = list(filter(lambda d: len(d) == 5, i)) + for v in v235: + diff = set(v) - set(v4 + a) + if len(diff) == 1: + n["g"] = g = diff.pop() + break + n["c"] = c + n["f"] = f + n["e"] = e = (set(v8) - set(v4 + a + g)).pop() + for v in v235: + diff = set(v) - set(n.values()) + if len(diff) == 1: + n["d"] = d = diff.pop() + break + n["b"] = b = (set(v4) - set([d, c, f])).pop() + + try: + outsum(n) + except ValueError: + n["c"] = f + n["f"] = c + outsum(n) + + return sum(outs) + + +if __name__ == "__main__": + solution = Solution() + solution.show_results() + +""" + dddd +e a +e a + ffff +g b +g b + cccc + + + 0: 1: 2: 3: 4: + aaaa .... aaaa aaaa .... +b c . c . c . c b c +b c . c . c . c b c + .... .... dddd dddd dddd +e f . f e . . f . f +e f . f e . . f . f + gggg .... gggg gggg .... + + 5: 6: 7: 8: 9: + aaaa aaaa aaaa aaaa aaaa +b . b . . c b c b c +b . b . . c b c b c + dddd dddd .... dddd dddd +. f e f . f e f . f +. f e f . f e f . f + gggg gggg .... gggg gggg + +""" diff --git a/2021-python/tests/test_day_08.py b/2021-python/tests/test_day_08.py new file mode 100644 index 0000000..508b514 --- /dev/null +++ b/2021-python/tests/test_day_08.py @@ -0,0 +1,66 @@ +import unittest + +from solutions.day_08 import Solution + + +class Day08TestCase(unittest.TestCase): + def setUp(self): + self.solution = Solution() + self.puzzle_input = self.solution.parse_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 test_parse_puzzle_input(self): + data = """ + be cfbegad | fdgacbe cefdb +edbfga begcd cbg | fcgedb cgb dgebacf + """ + assert self.solution.parse_input(data) == [ + (["be", "cfbegad"], ["fdgacbe", "cefdb"]), + (["edbfga", "begcd", "cbg"], ["fcgedb", "cgb", "dgebacf"]), + ] + + def test_solve_first_part(self): + assert self.solution.solve(self.puzzle_input) == 26 + + def test_solve_second_part(self): + assert ( + self.solution.solve_again( + [ + ( + [ + "acedgfb", + "cdfbe", + "gcdfa", + "fbcad", + "dab", + "cefabd", + "cdfgeb", + "eafb", + "cagedb", + "ab", + ], + ["cdfeb", "fcadb", "cdfeb", "cdbaf"], + ), + ] + ) + == 5353 + ) + assert self.solution.solve_again(self.puzzle_input) == 61229 + + +if __name__ == "__main__": + unittest.main()