From 5b754381b0d4afb176876edd64ba0eda35701c6f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Anders=20Engl=C3=B6f=20Ytterstr=C3=B6m?= <yttan@fastmail.se>
Date: Tue, 6 May 2025 20:14:58 +0200
Subject: [PATCH] Format files

---
 2017-python/aoc.py                | 36 ++++++++++++++++---------
 2017-python/solutions/__init__.py | 18 +++++++------
 2017-python/solutions/day_01.py   | 13 +++++----
 2017-python/solutions/day_02.py   |  6 ++---
 2017-python/solutions/day_03.py   |  6 ++---
 2017-python/solutions/day_04.py   |  8 +++---
 2017-python/solutions/day_05.py   |  6 ++---
 2017-python/solutions/day_06.py   |  8 +++---
 2017-python/solutions/day_07.py   | 44 +++++++++++++++++--------------
 2017-python/solutions/day_08.py   | 12 ++++-----
 2017-python/solutions/day_09.py   | 18 ++++++-------
 2017-python/solutions/day_10.py   | 15 ++++++-----
 2017-python/solutions/day_11.py   | 22 ++++++++--------
 2017-python/solutions/day_12.py   | 10 +++----
 2017-python/solutions/day_13.py   | 18 ++++++++-----
 2017-python/solutions/day_14.py   | 18 ++++++-------
 2017-python/solutions/day_15.py   | 12 ++++-----
 2017-python/solutions/day_16.py   | 28 ++++++++++----------
 2017-python/solutions/day_17.py   |  8 +++---
 2017-python/solutions/day_18.py   | 36 ++++++++++++-------------
 2017-python/solutions/day_19.py   | 32 +++++++++++-----------
 2017-python/solutions/day_20.py   | 22 ++++++++++------
 2017-python/solutions/day_21.py   | 39 ++++++++++++++++-----------
 2017-python/solutions/day_22.py   | 24 ++++++++---------
 2017-python/tests/day_01_tests.py | 20 +++++++-------
 2017-python/tests/day_02_tests.py |  8 +++---
 2017-python/tests/day_03_tests.py | 10 +++----
 2017-python/tests/day_04_tests.py | 20 +++++++-------
 2017-python/tests/day_05_tests.py | 22 +++++++++++++---
 2017-python/tests/day_06_tests.py |  6 ++---
 2017-python/tests/day_07_tests.py | 18 ++++++-------
 2017-python/tests/day_08_tests.py | 10 +++----
 2017-python/tests/day_09_tests.py | 30 ++++++++++-----------
 2017-python/tests/day_10_tests.py | 14 +++++-----
 2017-python/tests/day_11_tests.py | 14 +++++-----
 2017-python/tests/day_12_tests.py | 10 +++----
 2017-python/tests/day_13_tests.py | 10 +++----
 2017-python/tests/day_14_tests.py |  6 ++---
 2017-python/tests/day_15_tests.py | 12 ++++-----
 2017-python/tests/day_16_tests.py |  6 ++---
 2017-python/tests/day_17_tests.py |  4 +--
 2017-python/tests/day_18_tests.py | 10 +++----
 2017-python/tests/day_19_tests.py | 12 ++++-----
 2017-python/tests/day_20_tests.py | 10 +++----
 2017-python/tests/day_21_tests.py |  6 ++---
 2017-python/tests/day_22_tests.py |  3 ++-
 46 files changed, 391 insertions(+), 329 deletions(-)

diff --git a/2017-python/aoc.py b/2017-python/aoc.py
index 1f5d463..b30d68d 100644
--- 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
diff --git a/2017-python/solutions/__init__.py b/2017-python/solutions/__init__.py
index 84d82b8..76e2b38 100644
--- 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
diff --git a/2017-python/solutions/day_01.py b/2017-python/solutions/day_01.py
index 9888598..764ff15 100644
--- 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()
diff --git a/2017-python/solutions/day_02.py b/2017-python/solutions/day_02.py
index 45d1d22..1a0ccc6 100644
--- 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()
diff --git a/2017-python/solutions/day_03.py b/2017-python/solutions/day_03.py
index 57e9ecd..830e236 100644
--- 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()
diff --git a/2017-python/solutions/day_04.py b/2017-python/solutions/day_04.py
index ee09497..a4f7478 100644
--- 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()
diff --git a/2017-python/solutions/day_05.py b/2017-python/solutions/day_05.py
index a5482af..ef669f6 100644
--- 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()
diff --git a/2017-python/solutions/day_06.py b/2017-python/solutions/day_06.py
index fc00398..6a14512 100644
--- 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()
diff --git a/2017-python/solutions/day_07.py b/2017-python/solutions/day_07.py
index ad9a5fe..1be6f44 100644
--- 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()
diff --git a/2017-python/solutions/day_08.py b/2017-python/solutions/day_08.py
index bcc72fc..0aaf915 100644
--- 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()
diff --git a/2017-python/solutions/day_09.py b/2017-python/solutions/day_09.py
index aa97907..e992cf6 100644
--- 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()
diff --git a/2017-python/solutions/day_10.py b/2017-python/solutions/day_10.py
index f686d1e..b9f91a3 100644
--- 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()
diff --git a/2017-python/solutions/day_11.py b/2017-python/solutions/day_11.py
index 9dc1ea8..1c3df49 100644
--- 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()
diff --git a/2017-python/solutions/day_12.py b/2017-python/solutions/day_12.py
index d60e0a2..b5cfe92 100644
--- 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()
diff --git a/2017-python/solutions/day_13.py b/2017-python/solutions/day_13.py
index 7f714e9..c9cf411 100644
--- 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()
diff --git a/2017-python/solutions/day_14.py b/2017-python/solutions/day_14.py
index ed16396..86203ee 100644
--- 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()
diff --git a/2017-python/solutions/day_15.py b/2017-python/solutions/day_15.py
index 35ba167..e2f7613 100644
--- 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()
diff --git a/2017-python/solutions/day_16.py b/2017-python/solutions/day_16.py
index f94464e..a4823b0 100644
--- 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()
diff --git a/2017-python/solutions/day_17.py b/2017-python/solutions/day_17.py
index 2849aed..92a91d8 100644
--- 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()
diff --git a/2017-python/solutions/day_18.py b/2017-python/solutions/day_18.py
index 9e586cb..40c07d7 100644
--- 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()
diff --git a/2017-python/solutions/day_19.py b/2017-python/solutions/day_19.py
index 736bff5..0b1a315 100644
--- 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()
diff --git a/2017-python/solutions/day_20.py b/2017-python/solutions/day_20.py
index 21dabd1..c0f6918 100644
--- 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()
diff --git a/2017-python/solutions/day_21.py b/2017-python/solutions/day_21.py
index e639bf5..c47eb20 100644
--- 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()
diff --git a/2017-python/solutions/day_22.py b/2017-python/solutions/day_22.py
index 6b13152..024f115 100644
--- 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()
diff --git a/2017-python/tests/day_01_tests.py b/2017-python/tests/day_01_tests.py
index c26170a..fd3f637 100644
--- 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()
diff --git a/2017-python/tests/day_02_tests.py b/2017-python/tests/day_02_tests.py
index 1245a19..db32c03 100644
--- 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()
diff --git a/2017-python/tests/day_03_tests.py b/2017-python/tests/day_03_tests.py
index 9da2ab7..27d87e0 100644
--- 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()
diff --git a/2017-python/tests/day_04_tests.py b/2017-python/tests/day_04_tests.py
index f89b07c..8560e82 100644
--- 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()
diff --git a/2017-python/tests/day_05_tests.py b/2017-python/tests/day_05_tests.py
index 5384954..487f416 100644
--- 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()
diff --git a/2017-python/tests/day_06_tests.py b/2017-python/tests/day_06_tests.py
index bb4d176..2e83af2 100644
--- 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()
diff --git a/2017-python/tests/day_07_tests.py b/2017-python/tests/day_07_tests.py
index 74ce2e3..bb43ee8 100644
--- 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()
diff --git a/2017-python/tests/day_08_tests.py b/2017-python/tests/day_08_tests.py
index 18d9c67..507326d 100644
--- 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()
diff --git a/2017-python/tests/day_09_tests.py b/2017-python/tests/day_09_tests.py
index 10d4a27..db72776 100644
--- 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()
diff --git a/2017-python/tests/day_10_tests.py b/2017-python/tests/day_10_tests.py
index 270d01b..c443a90 100644
--- 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()
diff --git a/2017-python/tests/day_11_tests.py b/2017-python/tests/day_11_tests.py
index 83f7da1..df08c50 100644
--- 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()
diff --git a/2017-python/tests/day_12_tests.py b/2017-python/tests/day_12_tests.py
index 43d34f8..dce3db2 100644
--- 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()
diff --git a/2017-python/tests/day_13_tests.py b/2017-python/tests/day_13_tests.py
index 2a0e678..3ab2637 100644
--- 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()
diff --git a/2017-python/tests/day_14_tests.py b/2017-python/tests/day_14_tests.py
index 90bc38d..55d2542 100644
--- 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()
diff --git a/2017-python/tests/day_15_tests.py b/2017-python/tests/day_15_tests.py
index d2a0dff..7961bb9 100644
--- 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()
diff --git a/2017-python/tests/day_16_tests.py b/2017-python/tests/day_16_tests.py
index 959bf53..0188248 100644
--- 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()
diff --git a/2017-python/tests/day_17_tests.py b/2017-python/tests/day_17_tests.py
index bcaf0f0..4a53a1b 100644
--- 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()
diff --git a/2017-python/tests/day_18_tests.py b/2017-python/tests/day_18_tests.py
index e561be2..22f9325 100644
--- 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()
diff --git a/2017-python/tests/day_19_tests.py b/2017-python/tests/day_19_tests.py
index 74beb0a..732840f 100644
--- 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()
diff --git a/2017-python/tests/day_20_tests.py b/2017-python/tests/day_20_tests.py
index 048892c..a5ebdd0 100644
--- 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()
diff --git a/2017-python/tests/day_21_tests.py b/2017-python/tests/day_21_tests.py
index 0520b64..d53487e 100644
--- 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()
diff --git a/2017-python/tests/day_22_tests.py b/2017-python/tests/day_22_tests.py
index 095f74b..cb0d0c0 100644
--- 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()