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

@@ -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
+
+"""

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()