113 lines
2.6 KiB
Python
113 lines
2.6 KiB
Python
from functools import reduce
|
|
|
|
|
|
def load() -> list[tuple[list[str], ...]]:
|
|
with open('../.input/day08', 'r') as f:
|
|
return [tuple(map(str.split, line.split('|'))) for line in f.read().splitlines()]
|
|
|
|
|
|
def solve1() -> int:
|
|
return sum(
|
|
len(list(filter(lambda x: len(x) in [2, 3, 4, 7], output)))
|
|
for _, output in load()
|
|
)
|
|
|
|
|
|
A = 0b0000001
|
|
B = 0b0000010
|
|
C = 0b0000100
|
|
D = 0b0001000
|
|
E = 0b0010000
|
|
F = 0b0100000
|
|
G = 0b1000000
|
|
|
|
n_to_s = {
|
|
0: A | B | C | E | F | G,
|
|
1: C | F,
|
|
2: A | C | D | E | G,
|
|
3: A | C | D | F | G,
|
|
4: B | C | D | F,
|
|
5: A | B | D | F | G,
|
|
6: A | B | D | E | F | G,
|
|
7: A | C | F,
|
|
8: A | B | C | D | E | F | G,
|
|
9: A | B | C | D | F | G,
|
|
}
|
|
|
|
s_to_n = {
|
|
A | B | C | E | F | G: 0,
|
|
C | F: 1,
|
|
A | C | D | E | G: 2,
|
|
A | C | D | F | G: 3,
|
|
B | C | D | F: 4,
|
|
A | B | D | F | G: 5,
|
|
A | B | D | E | F | G: 6,
|
|
A | C | F: 7,
|
|
A | B | C | D | E | F | G: 8,
|
|
A | B | C | D | F | G: 9,
|
|
}
|
|
|
|
possible = {
|
|
2: n_to_s[1],
|
|
3: n_to_s[7],
|
|
4: n_to_s[4],
|
|
}
|
|
|
|
|
|
def negate(string: str):
|
|
return list(filter(lambda x: x not in string, "abcdefg"))
|
|
|
|
|
|
def check_pattern(pattern: list[str], mapping: dict[str, int]):
|
|
def check_legal(_str: str):
|
|
return reduce(lambda a, c: a | mapping[c], _str, 0) in s_to_n
|
|
return all(map(check_legal, pattern))
|
|
|
|
|
|
def find_mapping(pattern: list[str]):
|
|
domains = {
|
|
char: 0b1111111
|
|
for char in 'abcdefg'
|
|
}
|
|
|
|
# remove obvious impossible choices
|
|
for activation in pattern:
|
|
length = len(activation)
|
|
if length in possible:
|
|
for char in activation:
|
|
domains[char] &= possible[length]
|
|
for char in negate(activation):
|
|
domains[char] &= ~possible[length]
|
|
|
|
# bruteforce search
|
|
search: list[dict[str, int]] = [{}]
|
|
for char, domain in domains.items():
|
|
deeper = []
|
|
for i in range(7):
|
|
if domain & (1 << i):
|
|
for s in search:
|
|
new = s.copy()
|
|
new[char] = (1 << i)
|
|
deeper.append(new)
|
|
search = deeper
|
|
|
|
for mapping in search:
|
|
if check_pattern(pattern, mapping):
|
|
return mapping
|
|
|
|
|
|
def string_to_int(string: str, mapping: dict) -> int:
|
|
return s_to_n[reduce(lambda a, c: a | mapping[c], string, 0)]
|
|
|
|
|
|
def solve2() -> int:
|
|
return sum(
|
|
reduce(lambda a, c: a * 10 + string_to_int(c, find_mapping(pattern)), output, 0)
|
|
for pattern, output in load()
|
|
)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
print(solve1()) # 301
|
|
print(solve2()) # 908067
|