1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
# -*- coding: utf-8 -*-
from abc import ABC
from dataclasses import dataclass
from multiprocessing import Pool
from typing import Iterator
from aoc import BaseAssignment
@dataclass
class InnerMapping:
source: int
destination: int
length: int
def __getitem__(self, item):
if self.source <= item < self.source + self.length:
return self.destination + item - self.source
raise KeyError()
class Mapping:
def __init__(self):
self.mappings = []
def __getitem__(self, item):
for mapping in self.mappings:
try:
return mapping[item]
except KeyError:
continue
return item
def update(self, source: int, destination: int, length: int):
self.mappings.append(InnerMapping(source, destination, length))
I = tuple[list[int], list[Mapping]]
T = int
class Assignment(BaseAssignment, ABC):
@staticmethod
def map_seed_position(seed: int, mappings: list[Mapping]) -> int:
value = seed
for item in mappings:
value = item[value]
return value
def read_input(self, example=False) -> I:
seeds, *almanac = super().read_input(example)
_, seeds = seeds.split(": ")
seeds = [int(i) for i in seeds.split(" ")]
maps: list[Mapping] = []
map = None
index = 0
while True:
try:
line = almanac[index]
except IndexError:
break
if line == "":
index += 2
if map is not None:
maps.append(map)
map = None
continue
else:
index += 1
if map is None:
map = Mapping()
destination, source, length = line.split(" ")
map.update(int(source), int(destination), int(length))
return seeds, [*maps, map]
class AssignmentOne(Assignment):
example_result = 35
def run(self, input: I) -> T:
seeds, almanac = input
values = []
for seed in seeds:
values.append(self.map_seed_position(int(seed), almanac))
return min(values)
def run_per_seed_range(index: int, seeds: list[int], almanac: list[Mapping]):
seed, length = int(seeds[index]), int(seeds[index + 1])
value = None
for seed in range(seed, seed + length):
location = Assignment.map_seed_position(seed, almanac)
if value is None or value > location:
value = location
return value
class AssignmentTwo(Assignment):
example_result = 46
def run(self, input: I) -> T:
seeds, almanac = input
value = None
with Pool(processes=len(seeds) // 2) as pool:
for v in pool.imap_unordered(
lambda index: run_per_seed_range(index, seeds, almanac),
range(0, len(seeds), 2),
):
if value is None or value > v:
value = v
return value
|
