Merge pull request #27 from marcelblijleven/2021_day_12

solution: add 2021 day 12

Author: marcelblijleven

src/adventofcode/inputs/2021/day_12.txt

@@ -0,0 +1,25 @@
+vp-BY
+ui-oo
+kk-IY
+ij-vp
+oo-start
+SP-ij
+kg-uj
+ij-UH
+SP-end
+oo-IY
+SP-kk
+SP-vp
+ui-ij
+UH-ui
+ij-IY
+start-ui
+IY-ui
+uj-ui
+kk-oo
+IY-start
+end-vp
+uj-UH
+ij-kk
+UH-end
+UH-kk

src/adventofcode/year_2021/day_12_2021.py

@@ -0,0 +1,117 @@
+from collections import defaultdict
+from typing import List, Set, DefaultDict
+
+from adventofcode.util.console import console
+from adventofcode.util.exceptions import SolutionNotFoundException
+from adventofcode.util.helpers import solution_timer
+from adventofcode.util.input_helpers import get_input_for_day
+
+PathDict = DefaultDict[str, list[str]]
+
+
+def is_big_cave(cave: str) -> bool:
+    return cave.upper() == cave
+
+
+def is_small_cave(cave: str) -> bool:
+    return cave.lower() == cave
+
+
+def default_dict_factory() -> List[str]:
+    return []
+
+
+def get_paths(input_data: List[str]) -> PathDict:
+    path_dict: PathDict = defaultdict(default_dict_factory)
+
+    for line in input_data:
+        a, b = line.split('-')
+        path_dict[a].append(b)
+        path_dict[b].append(a)
+
+    return path_dict
+
+
+class CaveExplorer3000:
+    def __init__(self, paths: PathDict, limit_small_caves: bool = False) -> None:
+        self.paths = paths
+        self.limit_small_caves = limit_small_caves
+        self.path_count = 0
+
+    def traverse(self, cave: str, visited: Set[str]) -> int:
+        if cave == 'end':
+            return 1
+        elif cave == 'start' and cave in visited:
+            return 0
+
+        if cave in visited and is_small_cave(cave):
+            return 0
+
+        visited.add(cave)
+        paths = self.paths[cave]
+        return sum(self.traverse(path, visited.copy()) for path in paths)
+
+    def traverse_part_two(self, cave: str, visited: Set[str], revisit=True) -> int:
+        if cave == 'end':
+            return 1
+        elif cave == 'start' and cave in visited:
+            return 0
+
+        if cave in visited and is_small_cave(cave):
+            if not revisit:
+                return 0
+
+            revisit = False
+
+        visited.add(cave)
+        paths = self.paths[cave]
+        return sum(self.traverse_part_two(path, visited.copy(), revisit) for path in paths)
+
+    def traverse_with_print(self, cave: str, visited: Set[str], path_flow: str = '') -> int:
+        if path_flow == '':
+            path_flow = f'{cave}'
+        else:
+            path_flow += f' -> {cave}'
+
+        if cave == 'end':
+            console.print(path_flow)
+            return 1
+        elif cave == 'start' and cave in visited:
+            return 0
+
+        if cave in visited and is_small_cave(cave):
+            return 0
+
+        visited.add(cave)
+        paths = self.paths[cave]
+        return sum(self.traverse_with_print(path, visited.copy(), path_flow) for path in paths)
+
+
+@solution_timer(2021, 12, 1)
+def part_one(input_data: List[str]):
+    path_dict = get_paths(input_data)
+    cave_explorer = CaveExplorer3000(path_dict)
+    answer = cave_explorer.traverse('start', set())
+
+    if not answer:
+        raise SolutionNotFoundException(2021, 12, 1)
+
+    return answer
+
+
+@solution_timer(2021, 12, 2)
+def part_two(input_data: List[str]):
+    path_dict = get_paths(input_data)
+    cave_explorer = CaveExplorer3000(path_dict, limit_small_caves=True)
+    answer = cave_explorer.traverse_part_two('start', set())
+
+    if not answer:
+        raise SolutionNotFoundException(2021, 12, 2)
+
+    return answer
+
+
+if __name__ == '__main__':
+    data = get_input_for_day(2021, 12)
+    part_one(data)
+    part_two(data)

tests/year_2021/test_day_12_2021.py

@@ -0,0 +1,128 @@
+import pytest
+import pytest_mock
+
+from adventofcode.year_2021.day_12_2021 import part_two, part_one, is_big_cave, is_small_cave, get_paths, \
+    CaveExplorer3000
+
+test_input = [
+    'start-A',
+    'start-b',
+    'A-c',
+    'A-b',
+    'b-d',
+    'A-end',
+    'b-end',
+]
+
+test_input_slightly_larger = [
+    'dc-end',
+    'HN-start',
+    'start-kj',
+    'dc-start',
+    'dc-HN',
+    'LN-dc',
+    'HN-end',
+    'kj-sa',
+    'kj-HN',
+    'kj-dc',
+]
+
+test_input_even_larger = [
+    'fs-end',
+    'he-DX',
+    'fs-he',
+    'start-DX',
+    'pj-DX',
+    'end-zg',
+    'zg-sl',
+    'zg-pj',
+    'pj-he',
+    'RW-he',
+    'fs-DX',
+    'pj-RW',
+    'zg-RW',
+    'start-pj',
+    'he-WI',
+    'zg-he',
+    'pj-fs',
+    'start-RW',
+]
+
+
+@pytest.mark.parametrize(['cave', 'expected'], [
+    ('A', True),
+    ('AB', True),
+    ('a', False),
+    ('ab', False),
+    ('Ab', False),
+])
+def test_is_big_cave(cave, expected):
+    assert is_big_cave(cave) == expected
+
+
+@pytest.mark.parametrize(['cave', 'expected'], [
+    ('A', False),
+    ('AB', False),
+    ('a', True),
+    ('ab', True),
+    ('Ab', False),
+])
+def test_is_small_cave(cave, expected):
+    assert is_small_cave(cave) == expected
+
+
+def test_get_paths():
+    input_data = [
+        'start-A',
+        'start-b',
+        'A-c',
+        'A-b',
+        'b-d',
+        'A-end',
+        'b-end',
+    ]
+
+    assert dict(get_paths(input_data)) == {'A': ['start', 'c', 'b', 'end'],
+                                           'b': ['start', 'A', 'd', 'end'],
+                                           'c': ['A'],
+                                           'd': ['b'],
+                                           'end': ['A', 'b'],
+                                           'start': ['A', 'b']}
+
+
+@pytest.mark.parametrize(['input_data', 'expected'], [
+    (test_input, 10),
+    (test_input_slightly_larger, 19),
+    (test_input_even_larger, 226)
+])
+def test_cave_explorer_traverse(input_data, expected):
+    paths = get_paths(input_data)
+    cave_explorer = CaveExplorer3000(paths)
+    assert cave_explorer.traverse('start', set()) == expected
+
+
+@pytest.mark.parametrize(['input_data', 'expected'], [
+    (test_input, 36),
+    (test_input_slightly_larger, 103),
+    (test_input_even_larger, 3509)
+])
+def test_cave_explorer_traverse_part_two(input_data, expected):
+    paths = get_paths(input_data)
+    cave_explorer = CaveExplorer3000(paths, limit_small_caves=True)
+    assert cave_explorer.traverse_part_two('start', set()) == expected
+
+
+def test_cave_explorer_traverse_with_print(mocker: pytest_mock.MockerFixture):
+    mock_console = mocker.patch('adventofcode.year_2021.day_12_2021.console')
+    paths = get_paths(test_input)
+    cave_explorer = CaveExplorer3000(paths)
+    assert cave_explorer.traverse_with_print('start', set()) == 10
+    mock_console.print.assert_called()
+
+
+def test_part_one():
+    assert part_one(test_input) == 10
+
+
+def test_part_two():
+    assert part_two(test_input) == 36