Format files

2025-05-06 20:14:58 +02:00 · 2025-05-06 20:14:58 +02:00 · 5b754381b0
commit 5b754381b0
parent fcbeb4bfdd
46 changed files with 391 additions and 329 deletions
--- a/2017-python/aoc.py
+++ b/2017-python/aoc.py
@ -7,8 +7,9 @@ except ValueError:
    name = None

 if day_no and name:
-    with open('solutions/day_{}.py'.format(day_no.zfill(2)), 'w') as s:
-        s.write('''
+    with open("solutions/day_{}.py".format(day_no.zfill(2)), "w") as s:
+        s.write(
+            """
 from solutions import BaseSolution


@ -28,9 +29,14 @@ class Solution(BaseSolution):
 if __name__ == '__main__':
    solution = Solution()
    solution.show_results()
-'''.strip().format(day=day_no, day_no=day_no.zfill(2), name=name) + '\n')
-        with open('tests/day_{}_tests.py'.format(day_no.zfill(2)), 'w') as t:
-            t.write('''
+""".strip().format(
+                day=day_no, day_no=day_no.zfill(2), name=name
+            )
+            + "\n"
+        )
+        with open("tests/day_{}_tests.py".format(day_no.zfill(2)), "w") as t:
+            t.write(
+                """
 import unittest

 from solutions.day_{day_no} import Solution
@ -46,18 +52,24 @@ class Day{day_no}TestCase(unittest.TestCase):

 if __name__ == '__main__':
    unittest.main()
-    '''.strip().format(day_no=day_no.zfill(2)) + '\n')
-    with open('inputs/{}.txt'.format(day_no.zfill(2)), 'w') as i:
-        i.write('')
+    """.strip().format(
+                    day_no=day_no.zfill(2)
+                )
+                + "\n"
+            )
+    with open("inputs/{}.txt".format(day_no.zfill(2)), "w") as i:
+        i.write("")
    exit(0)

-print('\nAdvent of Code 2017'
-      '\n###################'
-      '\n\nby Anders Ytterström (@madr)')
+print(
+    "\nAdvent of Code 2017" "\n###################" "\n\nby Anders Ytterström (@madr)"
+)

 for i in [str(n).zfill(2) for n in range(1, 26)]:
    try:
-        solution = __import__('solutions.day_{}'.format(i), globals(), locals(), ['Solution'], 0).Solution()
+        solution = __import__(
+            "solutions.day_{}".format(i), globals(), locals(), ["Solution"], 0
+        ).Solution()
        solution.show_results()
    except IOError:
        pass
--- a/2017-python/solutions/init.py
+++ b/2017-python/solutions/init.py
@ -4,20 +4,22 @@ class BaseSolution:
    trim_input = True

    def parse_input(self, filename):
-        filepath = './inputs/{}'.format(filename)
-        with open(filepath, 'r') as f:
+        filepath = "./inputs/{}".format(filename)
+        with open(filepath, "r") as f:
            self.puzzle_input = f.read()
            if self.trim_input:
                self.puzzle_input = self.puzzle_input.strip()

    def show_results(self):
        self.parse_input(self.input_file)
-        print('\n\n{}\n{}\n\nPart 1: {}\nPart 2: {}'.format(
-            str(self),
-            '-' * len(str(self)),
-            self.solve(self.puzzle_input),
-            self.solve_again(self.puzzle_input),
-        ))
+        print(
+            "\n\n{}\n{}\n\nPart 1: {}\nPart 2: {}".format(
+                str(self),
+                "-" * len(str(self)),
+                self.solve(self.puzzle_input),
+                self.solve_again(self.puzzle_input),
+            )
+        )

    def solve(self, puzzle_input):
        raise NotImplemented
--- a/2017-python/solutions/day_01.py
+++ b/2017-python/solutions/day_01.py
@ -2,21 +2,24 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '01.txt'
+    input_file = "01.txt"

    def __str__(self):
-        return 'Day 1: Inverse Captcha'
+        return "Day 1: Inverse Captcha"

    def solve(self, puzzle_input, distance=1):
        pi_length = len(puzzle_input)
-        return sum(int(puzzle_input[pos]) for pos in range(pi_length) if
-                   puzzle_input[pos] == puzzle_input[(pos + distance) % pi_length])
+        return sum(
+            int(puzzle_input[pos])
+            for pos in range(pi_length)
+            if puzzle_input[pos] == puzzle_input[(pos + distance) % pi_length]
+        )

    def solve_again(self, puzzle_input):
        distance = len(puzzle_input) // 2
        return self.solve(puzzle_input, distance)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_02.py
+++ b/2017-python/solutions/day_02.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '02.txt'
+    input_file = "02.txt"

    def __str__(self):
-        return 'Day 2: Corruption Checksum'
+        return "Day 2: Corruption Checksum"

    def _get_rows(self, puzzle_input):
        return [list(map(int, rows.split())) for rows in puzzle_input.splitlines()]
@ -29,6 +29,6 @@ class Solution(BaseSolution):
        return sum(self.get_even_divisible(columns) for columns in rows)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_03.py
+++ b/2017-python/solutions/day_03.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '03.txt'
+    input_file = "03.txt"

    def __str__(self):
-        return 'Day 3: Spiral Memory'
+        return "Day 3: Spiral Memory"

    def _get_rounds(self, value):
        n = 0
@ -32,6 +32,6 @@ class Solution(BaseSolution):
        return 279138


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_04.py
+++ b/2017-python/solutions/day_04.py
@ -2,15 +2,15 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '04.txt'
+    input_file = "04.txt"

    def __str__(self):
-        return 'Day 4: High-Entropy Passphrases'
+        return "Day 4: High-Entropy Passphrases"

    def validate(self, passphrase, extended=False):
        words = passphrase.split()
        if extended:
-            words = [''.join(sorted(w)) for w in words]
+            words = ["".join(sorted(w)) for w in words]
        return sorted(list(set(words))) == sorted(words)

    def solve(self, puzzle_input):
@ -20,6 +20,6 @@ class Solution(BaseSolution):
        return sum(self.validate(p, True) for p in puzzle_input.splitlines())


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_05.py
+++ b/2017-python/solutions/day_05.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '05.txt'
+    input_file = "05.txt"

    def __str__(self):
-        return 'Day 5: A Maze of Twisty Trampolines, All Alike'
+        return "Day 5: A Maze of Twisty Trampolines, All Alike"

    def solve(self, puzzle_input, strange_jumps=False):
        pos = 0
@ -23,6 +23,6 @@ class Solution(BaseSolution):
        return self.solve(puzzle_input, True)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_06.py
+++ b/2017-python/solutions/day_06.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '06.txt'
+    input_file = "06.txt"

    def __str__(self):
-        return 'Day 6: Memory Reallocation'
+        return "Day 6: Memory Reallocation"

    def redistribute(self, banks):
        banks = list(banks)
@ -39,10 +39,10 @@ class Solution(BaseSolution):

    def solve_again(self, puzzle_input):
        seen = self._allocate(puzzle_input)
-        seen_last = ' '.join(str(n) for n in seen[-1])
+        seen_last = " ".join(str(n) for n in seen[-1])
        return len(self._allocate(seen_last)) - 1


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_07.py
+++ b/2017-python/solutions/day_07.py
@ -18,8 +18,8 @@ class Program:
            name, weight = data.split()
        except ValueError:
            name, weight, _, *disc = data.split()
-        weight = int(weight[1:len(weight) - 1])
-        disc = tuple(p.replace(',', '') for p in disc)
+        weight = int(weight[1 : len(weight) - 1])
+        disc = tuple(p.replace(",", "") for p in disc)
        return name, weight, disc

    def has_disc(self):
@ -30,29 +30,31 @@ class Program:


 class Solution(BaseSolution):
-    input_file = '07.txt'
+    input_file = "07.txt"

    def __str__(self):
-        return 'Day 7: Recursive Circus'
+        return "Day 7: Recursive Circus"

    def _get_programs(self, puzzle_input):
        return [Program(data) for data in puzzle_input.splitlines()]

    def _get_discs(self, disc, programs):
-        subdisc = [{'own_weight': p.weight, 'obj': p} for p in programs if p.name in disc]
+        subdisc = [
+            {"own_weight": p.weight, "obj": p} for p in programs if p.name in disc
+        ]
        for t in subdisc:
-            t['weight'] = t['own_weight']
-            if t['obj'].has_disc():
-                t['disc'] = self._get_discs(t['obj'].disc, programs)
-                t['weight'] += sum([st['weight'] for st in t['disc']])
-            del (t['obj'])
+            t["weight"] = t["own_weight"]
+            if t["obj"].has_disc():
+                t["disc"] = self._get_discs(t["obj"].disc, programs)
+                t["weight"] += sum([st["weight"] for st in t["disc"]])
+            del t["obj"]
        return subdisc

    def _find_unbalanced_disc(self, disc):
-        disc = sorted(disc, key=lambda t: t['weight'])
-        if not disc[0]['weight'] < disc[1]['weight']:
-            disc = sorted(disc, key=lambda t: t['weight'], reverse=True)
-        return disc[0], disc[1]['weight'] - disc[0]['weight']
+        disc = sorted(disc, key=lambda t: t["weight"])
+        if not disc[0]["weight"] < disc[1]["weight"]:
+            disc = sorted(disc, key=lambda t: t["weight"], reverse=True)
+        return disc[0], disc[1]["weight"] - disc[0]["weight"]

    def solve(self, puzzle_input):
        programs = self._get_programs(puzzle_input)
@ -67,28 +69,30 @@ class Solution(BaseSolution):
            unseen = p.unseen_discs(seen)
            if len(unseen) > 0:
                seen += unseen
-        bottom_program = list(filter(lambda p: p.name not in seen, programs_with_discs))[0]
+        bottom_program = list(
+            filter(lambda p: p.name not in seen, programs_with_discs)
+        )[0]
        return bottom_program

    def solve_again(self, puzzle_input):
        programs = self._get_programs(puzzle_input)
        bottom_program = self.solve(puzzle_input)
        disc_tree = {
-            'own_weight': bottom_program.weight,
-            'disc': self._get_discs(bottom_program.disc, programs)
+            "own_weight": bottom_program.weight,
+            "disc": self._get_discs(bottom_program.disc, programs),
        }
        diff = -1
        unbalanced = True
        while unbalanced:
-            disc, new_diff = self._find_unbalanced_disc(disc_tree['disc'])
+            disc, new_diff = self._find_unbalanced_disc(disc_tree["disc"])
            if new_diff == 0:
                unbalanced = False
            else:
                disc_tree = disc
                diff = new_diff
-        return disc_tree['own_weight'] + diff
+        return disc_tree["own_weight"] + diff


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_08.py
+++ b/2017-python/solutions/day_08.py
@ -2,22 +2,22 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '08.txt'
+    input_file = "08.txt"
    registry = {}

    def __str__(self):
-        return 'Day 8: I Heard You Like Registers'
+        return "Day 8: I Heard You Like Registers"

    def _should_modify(self, x, comp, y):
-        if comp in ('==', '!=', '>=', '<=', '>', '<'):
-            return eval('{:d} {} {:d}'.format(x, comp, y))
+        if comp in ("==", "!=", ">=", "<=", ">", "<"):
+            return eval("{:d} {} {:d}".format(x, comp, y))
        return False

    def _update_registry(self, registry, instruction):
        r, action, n, _, k, comp, v = instruction.split()
        current = registry.get(r, 0)
        if self._should_modify(registry.get(k, 0), comp, int(v)):
-            registry[r] = current + int(n) if action == 'inc' else current - int(n)
+            registry[r] = current + int(n) if action == "inc" else current - int(n)

    def solve(self, puzzle_input):
        registry = {}
@ -35,6 +35,6 @@ class Solution(BaseSolution):
        return max_value


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_09.py
+++ b/2017-python/solutions/day_09.py
@ -4,30 +4,30 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '09.txt'
+    input_file = "09.txt"

    def __str__(self):
-        return 'Day 9: Stream Processing'
+        return "Day 9: Stream Processing"

    def solve(self, puzzle_input):
        level = 0
        groups = []
-        stream = re.sub(r'!.', '', puzzle_input)
-        stream = re.sub(r'<[^>]*>', '', stream)
+        stream = re.sub(r"!.", "", puzzle_input)
+        stream = re.sub(r"<[^>]*>", "", stream)
        for c in stream:
-            if c == '{':
+            if c == "{":
                level += 1
-            if c == '}':
+            if c == "}":
                groups.append(level)
                level -= 1
        return sum(groups)

    def solve_again(self, puzzle_input):
-        stream = re.sub(r'!.', '', puzzle_input)
-        garbage = re.findall(r'<([^>]*)>', stream)
+        stream = re.sub(r"!.", "", puzzle_input)
+        garbage = re.findall(r"<([^>]*)>", stream)
        return sum([len(g) for g in garbage])


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_10.py
+++ b/2017-python/solutions/day_10.py
@ -2,14 +2,14 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '10.txt'
+    input_file = "10.txt"
    list = []
    l = 0
    skip_size = 0
    pos = 0

    def __str__(self):
-        return 'Day 10: Knot Hash'
+        return "Day 10: Knot Hash"

    def reset(self, l=256):
        self.list = list(range(l))
@ -28,7 +28,7 @@ class Solution(BaseSolution):

    def solve(self, puzzle_input, r=256):
        self.reset(r)
-        for sublist_length in map(int, puzzle_input.split(',')):
+        for sublist_length in map(int, puzzle_input.split(",")):
            self.reverse(sublist_length)
        return self.list[0] * self.list[1]

@ -38,10 +38,13 @@ class Solution(BaseSolution):
        for _ in range(64):
            for sublist_length in puzzle_input:
                self.reverse(sublist_length)
-        dense_hash = [eval('^'.join(list(map(str, self.list[seq:seq+16])))) for seq in range(0, r, 16)]
-        return ''.join(['{:x}'.format(int(i)).zfill(2) for i in dense_hash])
+        dense_hash = [
+            eval("^".join(list(map(str, self.list[seq : seq + 16]))))
+            for seq in range(0, r, 16)
+        ]
+        return "".join(["{:x}".format(int(i)).zfill(2) for i in dense_hash])


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_11.py
+++ b/2017-python/solutions/day_11.py
@ -2,20 +2,20 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '11.txt'
+    input_file = "11.txt"
    furthest_away = 0
    # https://www.redblobgames.com/grids/hexagons/#coordinates
    DIRECTIONS = {
-        'n': lambda x, y, z: (x, y + 1, z - 1),
-        'ne': lambda x, y, z: (x + 1, y, z - 1),
-        'se': lambda x, y, z: (x + 1, y - 1, z),
-        's': lambda x, y, z: (x, y - 1, z + 1),
-        'sw': lambda x, y, z: (x - 1, y, z + 1),
-        'nw': lambda x, y, z: (x - 1, y + 1, z),
+        "n": lambda x, y, z: (x, y + 1, z - 1),
+        "ne": lambda x, y, z: (x + 1, y, z - 1),
+        "se": lambda x, y, z: (x + 1, y - 1, z),
+        "s": lambda x, y, z: (x, y - 1, z + 1),
+        "sw": lambda x, y, z: (x - 1, y, z + 1),
+        "nw": lambda x, y, z: (x - 1, y + 1, z),
    }

    def __str__(self):
-        return 'Day 11: Hex Ed'
+        return "Day 11: Hex Ed"

    def _get_end(self, steps):
        x = 0
@ -28,14 +28,14 @@ class Solution(BaseSolution):
        return abs(x), abs(y), abs(z)

    def solve(self, puzzle_input):
-        x, y, z = self._get_end(puzzle_input.split(','))
+        x, y, z = self._get_end(puzzle_input.split(","))
        return max(x, y, z)

    def solve_again(self, puzzle_input):
-        _, *__ = self._get_end(puzzle_input.split(','))
+        _, *__ = self._get_end(puzzle_input.split(","))
        return self.furthest_away


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_12.py
+++ b/2017-python/solutions/day_12.py
@ -2,17 +2,17 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '12.txt'
+    input_file = "12.txt"
    seen = []

    def __str__(self):
-        return 'Day 12: Digital Plumber'
+        return "Day 12: Digital Plumber"

    def _walk(self, i, programs):
-        line = next(filter(lambda l: l.startswith('{} <->'.format(i)), programs))
+        line = next(filter(lambda l: l.startswith("{} <->".format(i)), programs))
        piped = line.split()[2:]
        self.seen.add(i)
-        for p in [int(p.replace(',', '')) for p in piped]:
+        for p in [int(p.replace(",", "")) for p in piped]:
            if p not in self.seen:
                self._walk(p, programs)

@ -34,6 +34,6 @@ class Solution(BaseSolution):
        return groups


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_13.py
+++ b/2017-python/solutions/day_13.py
@ -4,12 +4,12 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '13.txt'
+    input_file = "13.txt"
    layers = []
    scanners = []

    def __str__(self):
-        return 'Day 13: Packet Scanners'
+        return "Day 13: Packet Scanners"

    def _move_scanners(self):
        for p, l in enumerate(self.layers):
@ -22,7 +22,10 @@ class Solution(BaseSolution):
        self.scanners = [[0, 1] for l in self.layers]

    def _setup(self, puzzle_input):
-        pi = [tuple(map(int, line.strip().split(': '))) for line in puzzle_input.splitlines()]
+        pi = [
+            tuple(map(int, line.strip().split(": ")))
+            for line in puzzle_input.splitlines()
+        ]
        self.layers = [0 for _ in range(pi[-1][0] + 1)]
        self._init_scanners()
        for k, v in pi:
@ -55,13 +58,16 @@ class Solution(BaseSolution):

    def solve_again(self, puzzle_input):
        # todo: rewrite!
-        lines = [line.split(': ') for line in puzzle_input.splitlines()]
+        lines = [line.split(": ") for line in puzzle_input.splitlines()]
        heights = {int(pos): int(height) for pos, height in lines}
        wait = next(
-            wait for wait in itertools.count() if not any(self._scan(heights[pos], wait + pos) == 0 for pos in heights))
+            wait
+            for wait in itertools.count()
+            if not any(self._scan(heights[pos], wait + pos) == 0 for pos in heights)
+        )
        return wait


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_14.py
+++ b/2017-python/solutions/day_14.py
@ -3,18 +3,18 @@ from solutions.day_10 import Solution as KnotHash


 class Solution(BaseSolution):
-    input_file = '14.txt'
+    input_file = "14.txt"

    def __str__(self):
-        return 'Day 14: Disk Defragmentation'
+        return "Day 14: Disk Defragmentation"

    def _get_grid(self, pi):
-        grid = ''
+        grid = ""
        ks = KnotHash()
        for n in range(128):
-            s = '-'.join([pi, str(n)])
+            s = "-".join([pi, str(n)])
            knothash = ks.solve_again(s)
-            grid += '{:0128b}'.format(int(knothash, 16))
+            grid += "{:0128b}".format(int(knothash, 16))
        return grid

    def _find_regions(self, squares):
@ -31,10 +31,10 @@ class Solution(BaseSolution):
                get_adjacent_square(i - 128)
            if i % 128 < 127:
                get_adjacent_square(i + 1)
-            if i < 128 ** 2 - 128:
+            if i < 128**2 - 128:
                get_adjacent_square(i + 128)

-        for i in range(128 ** 2):
+        for i in range(128**2):
            if i in seen or i not in squares:
                continue
            regions += 1
@ -47,10 +47,10 @@ class Solution(BaseSolution):

    def solve_again(self, puzzle_input):
        grid = self._get_grid(puzzle_input)
-        squares = [i for i, s in enumerate(list(grid)) if s == '1']
+        squares = [i for i, s in enumerate(list(grid)) if s == "1"]
        return self._find_regions(squares)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_15.py
+++ b/2017-python/solutions/day_15.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '15.txt'
+    input_file = "15.txt"

    def __str__(self):
-        return 'Day 15: Dueling Generators'
+        return "Day 15: Dueling Generators"

    def _calc(self, x, f, m=1):
        x = (x * f) % 2147483647
@ -21,7 +21,7 @@ class Solution(BaseSolution):
        for _ in range(40 * 10**6):
            a = self._calc(a, af)
            b = self._calc(b, bf)
-            if '{:b}'.format(a)[-16:] == '{:b}'.format(b)[-16:]:
+            if "{:b}".format(a)[-16:] == "{:b}".format(b)[-16:]:
                j += 1
        return j

@ -29,14 +29,14 @@ class Solution(BaseSolution):
        af, bf = (16807, 48271)
        a, b = [int(pi.split()[-1]) for pi in puzzle_input.splitlines()]
        j = 0
-        for _ in range(5 * 10 ** 6):
+        for _ in range(5 * 10**6):
            a = self._calc(a, af, 4)
            b = self._calc(b, bf, 8)
-            if '{:b}'.format(a)[-16:] == '{:b}'.format(b)[-16:]:
+            if "{:b}".format(a)[-16:] == "{:b}".format(b)[-16:]:
                j += 1
        return j


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_16.py
+++ b/2017-python/solutions/day_16.py
@ -2,24 +2,24 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '16.txt'
+    input_file = "16.txt"

    def __str__(self):
-        return 'Day 16: Permutation Promenade'
+        return "Day 16: Permutation Promenade"

    def _move(self, programs, m, i):
        l = len(programs)
-        if m == 's':
+        if m == "s":
            r = int(i)
-            return programs[-r:] + programs[:l - r]
-        if m == 'x':
-            x, y = [int(s) for s in i.split('/')]
+            return programs[-r:] + programs[: l - r]
+        if m == "x":
+            x, y = [int(s) for s in i.split("/")]
            z = programs[x]
            programs[x] = programs[y]
            programs[y] = z
            return programs
-        if m == 'p':
-            xp, yp = i.split('/')
+        if m == "p":
+            xp, yp = i.split("/")
            x = programs.index(xp)
            y = programs.index(yp)
            z = programs[x]
@ -34,22 +34,22 @@ class Solution(BaseSolution):

    def solve(self, puzzle_input, n=16):
        programs = [chr(c) for c in range(97, 97 + n)]
-        moves = puzzle_input.split(',')
-        return ''.join(self._dance(programs, moves))
+        moves = puzzle_input.split(",")
+        return "".join(self._dance(programs, moves))

    def solve_again(self, puzzle_input, n=16):
-        moves = puzzle_input.split(',')
+        moves = puzzle_input.split(",")
        initial = [chr(c) for c in range(97, 97 + n)]
        programs = list(self.solve(puzzle_input))
        dances = 1
        while not programs == initial:
            programs = self._dance(programs, moves)
            dances += 1
-        for _ in range(10 ** 9 % dances):
+        for _ in range(10**9 % dances):
            programs = self._dance(programs, moves)
-        return ''.join(programs)
+        return "".join(programs)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_17.py
+++ b/2017-python/solutions/day_17.py
@ -2,10 +2,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '17.txt'
+    input_file = "17.txt"

    def __str__(self):
-        return 'Day 17: Spinlock'
+        return "Day 17: Spinlock"

    def solve(self, puzzle_input):
        n = int(puzzle_input)
@ -20,13 +20,13 @@ class Solution(BaseSolution):
        pos = 0
        n = int(puzzle_input)
        last_seen = 0
-        for i in range(1, 5 * 10 ** 7 + 1):
+        for i in range(1, 5 * 10**7 + 1):
            pos = (pos + n) % i + 1
            if pos == 1:
                last_seen = i
        return last_seen


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_18.py
+++ b/2017-python/solutions/day_18.py
@ -2,16 +2,16 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '18.txt'
+    input_file = "18.txt"
    sound_freq = 0
    queue = [], []
    sent = [0, 0]

    def __str__(self):
-        return 'Day 18: Duet'
+        return "Day 18: Duet"

    def _run(self, line, registry, swag_mode=True):
-        actions = 'add jgz mod mul rcv set snd'
+        actions = "add jgz mod mul rcv set snd"
        a, *kv = line.split()
        if len(kv) == 2:
            k, v = kv
@ -19,9 +19,9 @@ class Solution(BaseSolution):
            k = kv[0]
            v = None
        if a in actions:
-            if a == 'add' and k in registry:
+            if a == "add" and k in registry:
                registry[k] += registry[v] if v in registry else int(v)
-            if a == 'jgz':  # damn you, 'jgz 1 3'
+            if a == "jgz":  # damn you, 'jgz 1 3'
                try:
                    k = int(k)
                except ValueError:
@ -31,25 +31,25 @@ class Solution(BaseSolution):
                except ValueError:
                    v = registry[v] if v in registry else 1
                return v if k > 0 else 1
-            if a == 'mod' and k in registry:
+            if a == "mod" and k in registry:
                registry[k] %= registry[v] if v in registry else int(v)
-            if a == 'mul' and k in registry:
+            if a == "mul" and k in registry:
                registry[k] *= registry[v] if v in registry else int(v)
-            if a == 'set':
+            if a == "set":
                registry[k] = registry[v] if v in registry else int(v)
            if swag_mode:  # Part 1: scientific wild-ass guess
-                if a == 'rcv' and registry[k] != 0:
+                if a == "rcv" and registry[k] != 0:
                    return self.STOP_SIGNAL
-                if a == 'snd' and k in registry:
+                if a == "snd" and k in registry:
                    self.sound_freq = registry[k]
            else:  # part 2, actual instructions
-                if a == 'rcv':
-                    if len(self.queue[registry['_id']]) == 0:
+                if a == "rcv":
+                    if len(self.queue[registry["_id"]]) == 0:
                        return 0
-                    registry[k] = self.queue[registry['_id']].pop(0)
-                if a == 'snd':
-                    self.sent[registry['_id']] += 1
-                    q = (registry['_id'] + 1) % 2
+                    registry[k] = self.queue[registry["_id"]].pop(0)
+                if a == "snd":
+                    self.sent[registry["_id"]] += 1
+                    q = (registry["_id"] + 1) % 2
                    kk = registry[k] if k in registry else int(k)
                    self.queue[q].append(kk)
        return 1
@ -65,7 +65,7 @@ class Solution(BaseSolution):
        return self.sound_freq

    def solve_again(self, puzzle_input):
-        registry = {'p': 0, '_id': 0}, {'p': 1, '_id': 1}
+        registry = {"p": 0, "_id": 0}, {"p": 1, "_id": 1}
        lines = puzzle_input.splitlines()
        i = 0
        j = 0
@ -89,6 +89,6 @@ class Solution(BaseSolution):
        return self.sent[1]


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_19.py
+++ b/2017-python/solutions/day_19.py
@ -2,48 +2,48 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '19.txt'
+    input_file = "19.txt"
    trim_input = False

    def __str__(self):
-        return 'Day 19: A Series of Tubes'
+        return "Day 19: A Series of Tubes"

    def _walk_maze(self, puzzle_input):
        DIRECTIONS = {
-            'D': (1, 0),
-            'U': (-1, 0),
-            'R': (0, 1),
-            'L': (0, -1),
+            "D": (1, 0),
+            "U": (-1, 0),
+            "R": (0, 1),
+            "L": (0, -1),
        }
        maze = puzzle_input.splitlines()
-        pos = (0, list(maze[0]).index('|'))
-        d = DIRECTIONS['D']
-        paths = '-|'
+        pos = (0, list(maze[0]).index("|"))
+        d = DIRECTIONS["D"]
+        paths = "-|"
        steps = 0
-        seen = ''
+        seen = ""

        def _nc(nu):
            np = (pos[0] + nu[0], pos[1] + nu[1])
            if np[0] < len(maze) and np[1] < len(maze[np[0]]):
                return maze[np[0]][np[1]]
            else:
-                return ' '
+                return " "

        while True:
            pos = (pos[0] + d[0], pos[1] + d[1])
            c = _nc((0, 0))
            steps += 1
-            if c == '+':
+            if c == "+":
                nc = _nc(d)
-                if nc == ' ':
+                if nc == " ":
                    for v in DIRECTIONS.values():
                        if -v[0] == d[0] and -v[1] == d[1]:
                            continue
                        nc = _nc(v)
-                        if nc != ' ':
+                        if nc != " ":
                            d = v
                            break
-            elif c == ' ':
+            elif c == " ":
                break
            elif c not in paths:
                seen += c
@ -58,6 +58,6 @@ class Solution(BaseSolution):
        return steps


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_20.py
+++ b/2017-python/solutions/day_20.py
@ -6,15 +6,18 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '20.txt'
+    input_file = "20.txt"

    def __str__(self):
-        return 'Day 20: Particle Swarm'
+        return "Day 20: Particle Swarm"

    def _get_particle(self, line):
-        return [list(map(int, coordinate.split(','))) for coordinate in re.findall(r'.=<([^>]+)>', line)]
+        return [
+            list(map(int, coordinate.split(",")))
+            for coordinate in re.findall(r".=<([^>]+)>", line)
+        ]

-    def solve(self, puzzle_input, ticks=10 ** 4):
+    def solve(self, puzzle_input, ticks=10**4):
        particles = [self._get_particle(line) for line in puzzle_input.splitlines()]
        distances = [[] for _ in range(len(particles))]
        for _ in range(ticks):
@ -27,10 +30,13 @@ class Solution(BaseSolution):
                p[1] += v[1]
                p[2] += v[2]
                distances[i].append(sum(map(abs, p)))
-        d = sorted(map(lambda d: (d[0], sum(d[1]) / len(d[1])), enumerate(distances)), key=lambda x: x[1])
+        d = sorted(
+            map(lambda d: (d[0], sum(d[1]) / len(d[1])), enumerate(distances)),
+            key=lambda x: x[1],
+        )
        return d[0][0]

-    def solve_again(self, puzzle_input, ticks=10 ** 3):
+    def solve_again(self, puzzle_input, ticks=10**3):
        particles = [self._get_particle(line) for line in puzzle_input.splitlines()]
        for _ in range(ticks):
            positions = collections.defaultdict(list)
@ -42,7 +48,7 @@ class Solution(BaseSolution):
                p[0] += v[0]
                p[1] += v[1]
                p[2] += v[2]
-                k = '-'.join(map(str, p))
+                k = "-".join(map(str, p))
                positions[k].append(particle)
            for duplicates in positions.values():
                if len(duplicates) > 1:
@ -51,6 +57,6 @@ class Solution(BaseSolution):
        return len(particles)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_21.py
+++ b/2017-python/solutions/day_21.py
@ -7,9 +7,9 @@ class Rule:
    size = 0

    def __init__(self, line):
-        pattern, output = line.split(' => ')
-        self.pattern = pattern.replace('/', '')
-        self.output = output.replace('/', '')
+        pattern, output = line.split(" => ")
+        self.pattern = pattern.replace("/", "")
+        self.output = output.replace("/", "")
        self.size = int(len(self.pattern) ** 0.5)

        self.patterns = [
@ -22,13 +22,18 @@ class Rule:
        ]

    def __repr__(self):
-        return '[{}] {} -> {}'.format(self.size, self.pattern, self.output)
+        return "[{}] {} -> {}".format(self.size, self.pattern, self.output)

    def _r(self, b):
-        return ''.join(map(lambda g: ''.join(g), zip(*[b[s:s + self.size] for s in range(0, len(b), self.size)][::-1])))
+        return "".join(
+            map(
+                lambda g: "".join(g),
+                zip(*[b[s : s + self.size] for s in range(0, len(b), self.size)][::-1]),
+            )
+        )

    def _f(self, b):
-        return b[-self.size:] + b[self.size:len(b) - self.size] + b[0:self.size]
+        return b[-self.size :] + b[self.size : len(b) - self.size] + b[0 : self.size]

    def matches(self, canvas):
        return canvas in self.patterns
@ -38,13 +43,13 @@ class Rule:


 class Solution(BaseSolution):
-    input_file = '21.txt'
+    input_file = "21.txt"

    def __str__(self):
-        return 'Day 21: Fractal Art'
+        return "Day 21: Fractal Art"

    def _get_block(self, canvas, size, n=0):
-        s = ''
+        s = ""
        cl = int(len(canvas) ** 0.5)
        x = n % (cl // size)
        y = n // (cl // size)
@ -56,20 +61,22 @@ class Solution(BaseSolution):

    def _join_blocks(self, blocks):
        bl = len(blocks)
-        c = int(bl ** 0.5)
+        c = int(bl**0.5)
        rl = int(len(blocks[0]) ** 0.5)
-        canvas = ''
+        canvas = ""
        for i in range(0, bl, c):
            for j in range(rl):
-                canvas += ''.join([block[j * rl:(j + 1) * rl] for block in blocks[i:i + c]])
+                canvas += "".join(
+                    [block[j * rl : (j + 1) * rl] for block in blocks[i : i + c]]
+                )
        return canvas

    def solve(self, puzzle_input, iterations=5):
-        canvas = '.#...####'
+        canvas = ".#...####"
        rules = [Rule(l.strip()) for l in puzzle_input.splitlines()]
        for _ in range(iterations):
            size = 2 if len(canvas) % 2 == 0 else 3
-            blocks = len(canvas) // (size ** 2)
+            blocks = len(canvas) // (size**2)
            cb = []
            for b in range(blocks):
                bc = self._get_block(canvas, size, b)
@ -78,12 +85,12 @@ class Solution(BaseSolution):
                    r = rule[0]
                cb.append(r.enhance(bc))
            canvas = self._join_blocks(cb)
-        return collections.Counter(canvas)['#']
+        return collections.Counter(canvas)["#"]

    def solve_again(self, puzzle_input):
        return self.solve(puzzle_input, 18)


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/solutions/day_22.py
+++ b/2017-python/solutions/day_22.py
@ -4,10 +4,10 @@ from solutions import BaseSolution


 class Solution(BaseSolution):
-    input_file = '22.txt'
+    input_file = "22.txt"

    def __str__(self):
-        return 'Day 22: Sporifica Virus'
+        return "Day 22: Sporifica Virus"

    infected = 0

@ -50,7 +50,7 @@ class Solution(BaseSolution):
            dirs = dirs[1:] + [dirs[0]]
        elif state == "#":
            dirs = [dirs[3]] + dirs[:3]
-        elif state == 'F':
+        elif state == "F":
            dirs = dirs[2:] + dirs[:2]
        return dirs

@ -61,16 +61,16 @@ class Solution(BaseSolution):
            i, p = existing
            return amap, p[2]
        else:
-            amap.append([pos[0], pos[1], '.'])
-            return amap, '.'
+            amap.append([pos[0], pos[1], "."])
+            return amap, "."

    def _update_state(self, amap, pos):
        t = lambda x: x[1][0] == pos[0] and x[1][1] == pos[1]
        existing = next(filter(t, enumerate(amap)))
        i, p = existing
-        if p[2] == '.':
+        if p[2] == ".":
            self.infected += 1
-        amap[i][2] = '.' if p[2] == '#' else '#'
+        amap[i][2] = "." if p[2] == "#" else "#"
        return amap

    def _move(self, pos, d):
@ -80,12 +80,12 @@ class Solution(BaseSolution):
        t = lambda x: x[1][0] == pos[0] and x[1][1] == pos[1]
        existing = next(filter(t, enumerate(amap)))
        i, p = existing
-        if p[2] == '.':
-            ns = 'W'
-        elif p[2] == 'W':
+        if p[2] == ".":
+            ns = "W"
+        elif p[2] == "W":
            self.infected += 1
            ns = "#"
-        elif p[2] == '#':
+        elif p[2] == "#":
            ns = "F"
        else:
            ns = "."
@ -93,6 +93,6 @@ class Solution(BaseSolution):
        return amap


-if __name__ == '__main__':
+if __name__ == "__main__":
    solution = Solution()
    solution.show_results()
--- a/2017-python/tests/day_01_tests.py
+++ b/2017-python/tests/day_01_tests.py
@ -8,18 +8,18 @@ class Day1TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_sums_equal_pairs(self):
-        assert self.solution.solve('1122') == 3
-        assert self.solution.solve('1111') == 4
-        assert self.solution.solve('1234') == 0
-        assert self.solution.solve('91212129') == 9
+        assert self.solution.solve("1122") == 3
+        assert self.solution.solve("1111") == 4
+        assert self.solution.solve("1234") == 0
+        assert self.solution.solve("91212129") == 9

    def test_sums_equal_pairs_halvway_around(self):
-        assert self.solution.solve_again('1212') == 6
-        assert self.solution.solve_again('1221') == 0
-        assert self.solution.solve_again('123425') == 4
-        assert self.solution.solve_again('123123') == 12
-        assert self.solution.solve_again('12131415') == 4
+        assert self.solution.solve_again("1212") == 6
+        assert self.solution.solve_again("1221") == 0
+        assert self.solution.solve_again("123425") == 4
+        assert self.solution.solve_again("123123") == 12
+        assert self.solution.solve_again("12131415") == 4


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_02_tests.py
+++ b/2017-python/tests/day_02_tests.py
@ -13,19 +13,19 @@ class Day2TestCase(unittest.TestCase):
        assert self.solution.get_diff([2, 4, 6, 8]) == 6

    def test_calculates_checksum(self):
-        puzzle_input = '\n'.join(['5 1 9 5', '7 5 3', '2 4 6 8'])
+        puzzle_input = "\n".join(["5 1 9 5", "7 5 3", "2 4 6 8"])
        assert self.solution.solve(puzzle_input) == 18

    def test_calculates_row_even_divisible(self):
-        puzzle_input = '\n'.join(['5 9 2 8', '9 4 7 3', '3 8 6 5'])
+        puzzle_input = "\n".join(["5 9 2 8", "9 4 7 3", "3 8 6 5"])
        assert self.solution.get_even_divisible([5, 9, 2, 8]) == 4
        assert self.solution.get_even_divisible([9, 4, 7, 3]) == 3
        assert self.solution.get_even_divisible([3, 8, 6, 5]) == 2

    def test_calculates_row_result_sum(self):
-        puzzle_input = '\n'.join(['5 9 2 8', '9 4 7 3', '3 8 6 5'])
+        puzzle_input = "\n".join(["5 9 2 8", "9 4 7 3", "3 8 6 5"])
        assert self.solution.solve_again(puzzle_input) == 9


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_03_tests.py
+++ b/2017-python/tests/day_03_tests.py
@ -8,11 +8,11 @@ class Day3TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_shortest_manhattan_distance(self):
-        assert self.solution.solve('1') == 0
-        assert self.solution.solve('12') == 3
-        assert self.solution.solve('23') == 2
-        assert self.solution.solve('1024') == 31
+        assert self.solution.solve("1") == 0
+        assert self.solution.solve("12") == 3
+        assert self.solution.solve("23") == 2
+        assert self.solution.solve("1024") == 31


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_04_tests.py
+++ b/2017-python/tests/day_04_tests.py
@ -9,22 +9,22 @@ class Day4TestCase(unittest.TestCase):

    def test_passphrase_has_only_unique_words(self):
        passphrases = [
-            'aa bb cc dd ee',
-            'aa bb cc dd aa',
-            'aa bb cc dd aaa',
+            "aa bb cc dd ee",
+            "aa bb cc dd aa",
+            "aa bb cc dd aaa",
        ]
        assert self.solution.validate(passphrases[0]) == True
        assert self.solution.validate(passphrases[1]) == False
        assert self.solution.validate(passphrases[2]) == True
-        assert self.solution.solve('\n'.join(passphrases)) == 2
+        assert self.solution.solve("\n".join(passphrases)) == 2

    def test_passphrase_has_no_anagrams(self):
        passphrases = [
-           'abcde fghij',
-           'abcde xyz ecdab',
-           'a ab abc abd abf abj',
-           'iiii oiii ooii oooi oooo',
-           'oiii ioii iioi iiio',
+            "abcde fghij",
+            "abcde xyz ecdab",
+            "a ab abc abd abf abj",
+            "iiii oiii ooii oooi oooo",
+            "oiii ioii iioi iiio",
        ]
        assert self.solution.validate(passphrases[0], True) == True
        assert self.solution.validate(passphrases[1], True) == False
@ -33,5 +33,5 @@ class Day4TestCase(unittest.TestCase):
        assert self.solution.validate(passphrases[4], True) == False


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_05_tests.py
+++ b/2017-python/tests/day_05_tests.py
@ -8,13 +8,29 @@ class Day5TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_calculate_exit_distance(self):
-        puzzle_input = '\n'.join(['0', '3', '0', '1', '-3',])
+        puzzle_input = "\n".join(
+            [
+                "0",
+                "3",
+                "0",
+                "1",
+                "-3",
+            ]
+        )
        assert self.solution.solve(puzzle_input) == 5

    def test_calculate_stranger_exit_distance(self):
-        puzzle_input = '\n'.join(['0', '3', '0', '1', '-3',])
+        puzzle_input = "\n".join(
+            [
+                "0",
+                "3",
+                "0",
+                "1",
+                "-3",
+            ]
+        )
        assert self.solution.solve_again(puzzle_input) == 10


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_06_tests.py
+++ b/2017-python/tests/day_06_tests.py
@ -8,7 +8,7 @@ class Day6TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_count_redistribution_cycles(self):
-        puzzle_input = '0 2 7 0'
+        puzzle_input = "0 2 7 0"
        banks = list(map(int, puzzle_input.split()))
        assert self.solution.redistribute(banks) == (2, 4, 1, 2)
        assert self.solution.redistribute((2, 4, 1, 2)) == (3, 1, 2, 3)
@ -18,9 +18,9 @@ class Day6TestCase(unittest.TestCase):
        assert self.solution.solve(puzzle_input) == 5

    def test_count_redistribution_cycles_again(self):
-        puzzle_input = '0 2 7 0'
+        puzzle_input = "0 2 7 0"
        assert self.solution.solve_again(puzzle_input) == 4


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_07_tests.py
+++ b/2017-python/tests/day_07_tests.py
@ -5,7 +5,7 @@ from solutions.day_07 import Solution, Program

 class Day7TestCase(unittest.TestCase):
    def setUp(self):
-        self.puzzle_input = '''
+        self.puzzle_input = """
        pbga (66)
        xhth (57)
        ebii (61)
@ -19,24 +19,24 @@ class Day7TestCase(unittest.TestCase):
        ugml (68) -> gyxo, ebii, jptl
        gyxo (61)
        cntj (57)
-        '''.strip()
+        """.strip()
        self.solution = Solution()

    def test_find_bottom_tower(self):
-        p = Program('ugml (68) -> gyxo, ebii, jptl')
-        assert p.name == 'ugml'
+        p = Program("ugml (68) -> gyxo, ebii, jptl")
+        assert p.name == "ugml"
        assert p.weight == 68
-        assert p.disc == ('gyxo', 'ebii', 'jptl')
-        p = Program('jptl (61)')
-        assert p.name == 'jptl'
+        assert p.disc == ("gyxo", "ebii", "jptl")
+        p = Program("jptl (61)")
+        assert p.name == "jptl"
        assert p.weight == 61
        assert p.disc == ()
-        assert self.solution.solve(self.puzzle_input).name == 'tknk'
+        assert self.solution.solve(self.puzzle_input).name == "tknk"

    def test_find_weight_correction(self):
        corrected = self.solution.solve_again(self.puzzle_input)
        assert corrected == 60


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_08_tests.py
+++ b/2017-python/tests/day_08_tests.py
@ -8,23 +8,23 @@ class Day8TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_largest_registry_value(self):
-        puzzle_input = '''
+        puzzle_input = """
        b inc 5 if a > 1
        a inc 1 if b < 5
        c dec -10 if a >= 1
        c inc -20 if c == 10
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input) == 1

    def test_largest_ath_registry_value(self):
-        puzzle_input = '''
+        puzzle_input = """
        b inc 5 if a > 1
        a inc 1 if b < 5
        c dec -10 if a >= 1
        c inc -20 if c == 10
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input) == 10


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_09_tests.py
+++ b/2017-python/tests/day_09_tests.py
@ -8,24 +8,24 @@ class Day9TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_calculates_score(self):
-        assert self.solution.solve('{}') == 1
-        assert self.solution.solve('{{{}}}') == 6
-        assert self.solution.solve('{{},{}}') == 5
-        assert self.solution.solve('{{{},{},{{}}}}') == 16
-        assert self.solution.solve('{<a>,<a>,<a>,<a>}') == 1
-        assert self.solution.solve('{{<ab>},{<ab>},{<ab>},{<ab>}}') == 9
-        assert self.solution.solve('{{<!!>},{<!!>},{<!!>},{<!!>}}') == 9
-        assert self.solution.solve('{{<a!>},{<a!>},{<a!>},{<ab>}}') == 3
+        assert self.solution.solve("{}") == 1
+        assert self.solution.solve("{{{}}}") == 6
+        assert self.solution.solve("{{},{}}") == 5
+        assert self.solution.solve("{{{},{},{{}}}}") == 16
+        assert self.solution.solve("{<a>,<a>,<a>,<a>}") == 1
+        assert self.solution.solve("{{<ab>},{<ab>},{<ab>},{<ab>}}") == 9
+        assert self.solution.solve("{{<!!>},{<!!>},{<!!>},{<!!>}}") == 9
+        assert self.solution.solve("{{<a!>},{<a!>},{<a!>},{<ab>}}") == 3

    def test_count_garbage(self):
-        assert self.solution.solve_again('<>') == 0
-        assert self.solution.solve_again('<random characters>') == 17
-        assert self.solution.solve_again('<<<<>') == 3
-        assert self.solution.solve_again('<{!>}>') == 2
-        assert self.solution.solve_again('<!!>') == 0
-        assert self.solution.solve_again('<!!!>>') == 0
+        assert self.solution.solve_again("<>") == 0
+        assert self.solution.solve_again("<random characters>") == 17
+        assert self.solution.solve_again("<<<<>") == 3
+        assert self.solution.solve_again("<{!>}>") == 2
+        assert self.solution.solve_again("<!!>") == 0
+        assert self.solution.solve_again("<!!!>>") == 0
        assert self.solution.solve_again('<{o"i!a,<{i<a>') == 10


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_10_tests.py
+++ b/2017-python/tests/day_10_tests.py
@ -25,14 +25,16 @@ class Day10TestCase(unittest.TestCase):
        assert self.solution.list == [3, 4, 2, 1, 0]
        assert self.solution.skip_size == 4
        assert self.solution.pos == 4
-        assert self.solution.solve('3,4,1,5', r=5) == 12
+        assert self.solution.solve("3,4,1,5", r=5) == 12

    def test_dense_hash(self):
-        assert self.solution.solve_again('') == 'a2582a3a0e66e6e86e3812dcb672a272'
-        assert self.solution.solve_again('AoC 2017') == '33efeb34ea91902bb2f59c9920caa6cd'
-        assert self.solution.solve_again('1,2,3') == '3efbe78a8d82f29979031a4aa0b16a9d'
-        assert self.solution.solve_again('1,2,4') == '63960835bcdc130f0b66d7ff4f6a5a8e'
+        assert self.solution.solve_again("") == "a2582a3a0e66e6e86e3812dcb672a272"
+        assert (
+            self.solution.solve_again("AoC 2017") == "33efeb34ea91902bb2f59c9920caa6cd"
+        )
+        assert self.solution.solve_again("1,2,3") == "3efbe78a8d82f29979031a4aa0b16a9d"
+        assert self.solution.solve_again("1,2,4") == "63960835bcdc130f0b66d7ff4f6a5a8e"


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_11_tests.py
+++ b/2017-python/tests/day_11_tests.py
@ -8,15 +8,15 @@ class Day11TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_distance(self):
-        assert self.solution.solve('ne,ne,ne') == 3
-        assert self.solution.solve('ne,ne,sw,sw') == 0
-        assert self.solution.solve('ne,ne,s,s') == 2
-        assert self.solution.solve('se,sw,se,sw,sw') == 3
+        assert self.solution.solve("ne,ne,ne") == 3
+        assert self.solution.solve("ne,ne,sw,sw") == 0
+        assert self.solution.solve("ne,ne,s,s") == 2
+        assert self.solution.solve("se,sw,se,sw,sw") == 3

    def test_furthest_away(self):
-        assert self.solution.solve_again('ne,ne,sw,sw') == 2
-        assert self.solution.solve_again('se,sw,se,sw,sw') == 3
+        assert self.solution.solve_again("ne,ne,sw,sw") == 2
+        assert self.solution.solve_again("se,sw,se,sw,sw") == 3


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_12_tests.py
+++ b/2017-python/tests/day_12_tests.py
@ -8,7 +8,7 @@ class Day12TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_connected_to_program0(self):
-        puzzle_input = '''
+        puzzle_input = """
        0 <-> 2
        1 <-> 1
        2 <-> 0, 3, 4
@ -16,11 +16,11 @@ class Day12TestCase(unittest.TestCase):
        4 <-> 2, 3, 6
        5 <-> 6
        6 <-> 4, 5
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input) == 6

    def test_group_coun(self):
-        puzzle_input = '''
+        puzzle_input = """
        0 <-> 2
        1 <-> 1
        2 <-> 0, 3, 4
@ -28,9 +28,9 @@ class Day12TestCase(unittest.TestCase):
        4 <-> 2, 3, 6
        5 <-> 6
        6 <-> 4, 5
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input) == 2


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_13_tests.py
+++ b/2017-python/tests/day_13_tests.py
@ -8,23 +8,23 @@ class Day13TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_get_through_firewall(self):
-        puzzle_input = '''
+        puzzle_input = """
        0: 3
        1: 2
        4: 4
        6: 4
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input) == 24

    def test_wait(self):
-        puzzle_input = '''
+        puzzle_input = """
        0: 3
        1: 2
        4: 4
        6: 4
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input) == 10


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_14_tests.py
+++ b/2017-python/tests/day_14_tests.py
@ -8,11 +8,11 @@ class Day14TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_used_squares(self):
-        assert self.solution.solve('flqrgnkx') == 8108
+        assert self.solution.solve("flqrgnkx") == 8108

    def test_regions(self):
-        assert self.solution.solve_again('flqrgnkx') == 1242
+        assert self.solution.solve_again("flqrgnkx") == 1242


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_15_tests.py
+++ b/2017-python/tests/day_15_tests.py
@ -8,19 +8,19 @@ class Day15TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_40m_pairs(self):
-        puzzle_input = '''
+        puzzle_input = """
        Generator A starts with 65
        Generator B starts with 8921
-        '''.strip()
-        #assert self.solution.solve(puzzle_input) == 588
+        """.strip()
+        # assert self.solution.solve(puzzle_input) == 588

    def test_5k_pairs(self):
-        puzzle_input = '''
+        puzzle_input = """
        Generator A starts with 65
        Generator B starts with 8921
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input) == 309


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_16_tests.py
+++ b/2017-python/tests/day_16_tests.py
@ -8,9 +8,9 @@ class Day16TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_something(self):
-        puzzle_input = '''s1,x3/4,pe/b'''.strip()
-        assert self.solution.solve(puzzle_input, 5) == 'baedc'
+        puzzle_input = """s1,x3/4,pe/b""".strip()
+        assert self.solution.solve(puzzle_input, 5) == "baedc"


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_17_tests.py
+++ b/2017-python/tests/day_17_tests.py
@ -8,8 +8,8 @@ class Day17TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_something(self):
-        assert self.solution.solve('3') == 638
+        assert self.solution.solve("3") == 638


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_18_tests.py
+++ b/2017-python/tests/day_18_tests.py
@ -8,7 +8,7 @@ class Day18TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_something(self):
-        puzzle_input = '''
+        puzzle_input = """
        set a 1
        add a 2
        mul a a
@ -19,11 +19,11 @@ class Day18TestCase(unittest.TestCase):
        jgz a -1
        set a 1
        jgz a -2
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input) == 4

    def test_something_else(self):
-        puzzle_input = '''
+        puzzle_input = """
        snd 1
        snd 2
        snd p
@ -31,9 +31,9 @@ class Day18TestCase(unittest.TestCase):
        rcv b
        rcv c
        rcv d
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input) == 3


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_19_tests.py
+++ b/2017-python/tests/day_19_tests.py
@ -8,27 +8,27 @@ class Day19TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_seen(self):
-        puzzle_input = '''             |          
+        puzzle_input = """             |          
             |  +--+    
             A  |  C    
         F---|----E|--+ 
             |  |  |  D 
             +B-+  +--+ 
             
-        '''
-        assert self.solution.solve(puzzle_input) == 'ABCDEF'
+        """
+        assert self.solution.solve(puzzle_input) == "ABCDEF"

    def test_steps(self):
-        puzzle_input = '''             |          
+        puzzle_input = """             |          
             |  +--+    
             A  |  C    
         F---|----E|--+ 
             |  |  |  D 
             +B-+  +--+ 

-        '''
+        """
        assert self.solution.solve_again(puzzle_input) == 38


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_20_tests.py
+++ b/2017-python/tests/day_20_tests.py
@ -8,21 +8,21 @@ class Day20TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_shortest_distance_over_time(self):
-        puzzle_input = '''
+        puzzle_input = """
        p=< 3,0,0>, v=< 2,0,0>, a=<-1,0,0>
        p=< 4,0,0>, v=< 0,0,0>, a=<-2,0,0>
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input, 4) == 0

    def test_something(self):
-        puzzle_input = '''
+        puzzle_input = """
        p=<-6,0,0>, v=< 3,0,0>, a=< 0,0,0>
        p=<-4,0,0>, v=< 2,0,0>, a=< 0,0,0>
        p=<-2,0,0>, v=< 1,0,0>, a=< 0,0,0>
        p=< 3,0,0>, v=<-1,0,0>, a=< 0,0,0>
-        '''.strip()
+        """.strip()
        assert self.solution.solve_again(puzzle_input, 4) == 1


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_21_tests.py
+++ b/2017-python/tests/day_21_tests.py
@ -8,12 +8,12 @@ class Day21TestCase(unittest.TestCase):
        self.solution = Solution()

    def test_something(self):
-        puzzle_input = '''
+        puzzle_input = """
        ../.# => ##./#../...
        .#./..#/### => #..#/..../..../#..#
-        '''.strip()
+        """.strip()
        assert self.solution.solve(puzzle_input, 2) == 12


-if __name__ == '__main__':
+if __name__ == "__main__":
    unittest.main()
--- a/2017-python/tests/day_22_tests.py
+++ b/2017-python/tests/day_22_tests.py
@ -26,5 +26,6 @@ class Day22TestCase(unittest.TestCase):
        assert self.solution.solve_again(puzzle_input, 100) == 26
        assert self.solution.solve_again(puzzle_input, 10000000) == 2511944

-if __name__ == '__main__':
+
+if __name__ == "__main__":
    unittest.main()