wathiede/aoc
1
0
Fork 0
forked from ggriffiniii/aoc
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: wathiede:41019aa10c09003d7238796dfe450ecedec57f3f
Branches Tags
wathiede:master
ggriffiniii:master
..
compare: wathiede:4cc35dc038357814b257c6bec26ded6674ecdac6
Branches Tags
wathiede:master
ggriffiniii:master

No commits in common. "41019aa10c09003d7238796dfe450ecedec57f3f" and "4cc35dc038357814b257c6bec26ded6674ecdac6" have entirely different histories.
41019aa10c ... 4cc35dc038

16 changed files with 85 additions and 3828 deletions
Show Stats Expand all files Collapse all files

2
.cargo/config.toml
View File

@ -1,2 +0,0 @@
[build]
rustflags = ["-Ctarget-cpu=native"]

162
README.md
View File

@ -1,167 +1,123 @@
```
Advent of code 2020
Day 1 - Part 1: 1016964
generator: 16.414µs,
runner: 474ns
generator: 17.37µs,
runner: 472ns
Day 1 - Part 2: 182588480
generator: 12.988µs,
runner: 302ns
generator: 10.562µs,
runner: 344ns
Day 2 - Part 1: 586
generator: 180ns,
runner: 89.876µs
generator: 197ns,
runner: 107.894µs
Day 2 - Part 2: 352
generator: 94ns,
runner: 76.325µs
generator: 115ns,
runner: 85.595µs
Day 3 - Part 1: 265
generator: 48.133µs,
runner: 54.962µs
generator: 51.702µs,
runner: 58.098µs
Day 3 - Part 2: 3154761400
generator: 35.653µs,
runner: 283.346µs
generator: 47.858µs,
runner: 304.783µs
Day 4 - Part 2: 186
generator: 109ns,
runner: 103.216µs
generator: 125ns,
runner: 150.65µs
Day 5 - Part 1: SeatId(933)
generator: 89ns,
runner: 46.149µs
generator: 110ns,
runner: 48.99µs
Day 5 - Part 2: SeatId(711)
generator: 89ns,
runner: 44.886µs
generator: 175ns,
runner: 50.545µs
Day 6 - Part 1: 6633
generator: 109ns,
runner: 121.222µs
generator: 114ns,
runner: 128.471µs
Day 6 - Part 2: 3202
generator: 136ns,
runner: 94.567µs
generator: 116ns,
runner: 118.78µs
Day 7 - Part 1: 208
generator: 185ns,
runner: 604.146µs
generator: 123ns,
runner: 628.342µs
Day 7 - Part 2: 1664
generator: 111ns,
runner: 460.961µs
generator: 146ns,
runner: 486.984µs
Day 8 - Part 1: 1723
generator: 103ns,
runner: 36.224µs
generator: 163ns,
runner: 40.378µs
Day 8 - Part 2: 846
generator: 86ns,
runner: 40.938µs
generator: 125ns,
runner: 43.695µs
Day 9 - Part 1: 36845998
generator: 96ns,
runner: 73.527µs
generator: 94ns,
runner: 76.173µs
Day 9 - Part 2: 4830226
generator: 102ns,
runner: 29.088µs
generator: 95ns,
runner: 29.611µs
Day 10 - Part 1: 1890
generator: 121ns,
runner: 7.187µs
generator: 125ns,
runner: 7.909µs
Day 10 - Part 2: 49607173328384
generator: 105ns,
runner: 6.469µs
generator: 110ns,
runner: 6.305µs
Day 11 - Part 1: 2329
generator: 170ns,
runner: 9.306401ms
generator: 100ns,
runner: 13.938125ms
Day 11 - Part 2: 2138
generator: 208ns,
runner: 22.394928ms
generator: 205ns,
runner: 28.63697ms
Day 12 - Part 1: 1177
generator: 132ns,
runner: 23.98µs
generator: 143ns,
runner: 26.923µs
Day 12 - Part 2: 46530
generator: 88ns,
runner: 22.565µs
generator: 92ns,
runner: 23.898µs
Day 13 - Part 1: 1895
generator: 90ns,
runner: 2.108µs
generator: 93ns,
runner: 2.449µs
Day 14 - Part 1: 13865835758282
generator: 104ns,
runner: 85.834µs
generator: 163ns,
runner: 83.793µs
Day 14 - Part 2: 4195339838136
generator: 94ns,
runner: 9.646046ms
generator: 161ns,
runner: 10.181244ms
Day 15 - Part 1: 273
generator: 146ns,
runner: 51.22µs
generator: 204ns,
runner: 52.207µs
Day 15 - Part 2: 47205
generator: 109ns,
runner: 2.274252927s
generator: 102ns,
runner: 2.381580988s
Day 16 - Part 1: 25984
generator: 301ns,
runner: 175.013µs
runner: 175.367µs
Day 16 - Part 2: 1265347500049
generator: 125ns,
runner: 353.876µs
Day 16 - Part 2 - avx2: 1265347500049
generator: 152ns,
runner: 145.475µs
Day 17 - Part 1: 1812
generator: 128ns,
runner: 278.162845ms
Day 18 - Part 1: 800602729153
generator: 199ns,
runner: 163.467µs
Day 18 - Part 2: 92173009047076
generator: 153ns,
runner: 180.596µs
Day 19 - Part 1: 109
generator: 112ns,
runner: 3.277745ms
Day 19 - Part 2: 150
generator: 102ns,
runner: 7.222896ms
Day 20 - Part 1: 22878471088273
generator: 121ns,
runner: 124.756µs
Day 21 - Part 1: 2262
generator: 111ns,
runner: 368.681µs
Day 21 - Part 2: cxsvdm,glf,rsbxb,xbnmzr,txdmlzd,vlblq,mtnh,mptbpz
generator: 104ns,
runner: 329.907µs
Day 22 - Part 1: 33631
generator: 105ns,
runner: 7.331µs
Day 22 - Part 2: 33469
generator: 94ns,
runner: 1.13821236s
generator: 138ns,
runner: 356.093µs
```

8
input/2020/day17.txt
View File

@ -1,8 +0,0 @@
#.#.#.##
.####..#
#####.#.
#####..#
#....###
###...##
...#.#.#
#.##..##

373
input/2020/day18.txt
View File

@ -1,373 +0,0 @@
5 + (6 + 3 + (4 + 7 * 3 + 6 + 4 + 2) * 9) * 7 + 7
5 * 8 + 3 * ((5 + 9 * 9) * (3 * 5 + 7 * 2 * 3) + 3 * 6) + 8
5 + 5 * (6 + 7) * 5 + 4 * (3 * 3 * 8 + 2)
(6 + 2 + 9 + 9) * 6 + (2 + (5 * 3 + 4 * 5 * 8 + 5) + 6 + (5 + 9 * 8 + 2 + 2))
3 + (5 * 4 * 6 + 5 * (9 + 7 * 9)) * 5 + ((2 + 8 * 2) * 6)
3 * (9 + 9) * 4
5 * 6 + ((2 + 8 * 5) + (5 * 7 + 4 * 9 + 2 + 3) + 5 * 4 * 5) * 4 * 4
8 + 5 + 5 * ((9 + 9 * 2 * 3 + 3 * 9) + (7 * 4 + 2))
((2 * 5 * 5 + 6) * 6) + 3 * 9 * (8 * 3 + 4) * 7 * (3 + 9 + 8 * (8 * 8 * 5) + 8 * 3)
9 + (6 + (4 + 2 * 3 + 4) * 7 + 6 * 7) * 8 + 6
6 * 9 * (9 * 9) + 5 + 8 + 9
3 + 4 * 5 * 7 * ((3 + 9 * 9) + 2 + (5 + 3 + 5 + 2 + 8 + 4) * 6 * 6 + (2 * 5 * 8 * 6)) * (7 + 3 * 7 * 2 * 5 + 6)
9 + 6 + 5 * 2 * (2 + 4 + 9 * 4)
(2 * 4 * (9 + 8 + 8) + 6 * 2 + 8) + 4
(5 + 4 * (9 + 2 * 2 + 6 * 9 * 5) * 5 * 7) + (6 * 8 + 7)
3 + 8 * 4 + 2 + (7 * (7 * 5)) + 2
3 + 4 * ((2 + 5 * 6) + 2 + 5 * 4 * (9 * 8 * 6 + 9) * (9 * 5 * 4 + 9 + 2)) + 6
(6 * 4 + 2) * 7 * 6 * 5 * ((4 + 5 * 8) + 6 + 7) * 7
(3 * 5 * 4 * 5 + 9) + 6 + 6 * (6 + 2 * 5 + 7 * 4)
5 * ((5 + 3 + 6 + 9 + 7) + 5) * 6 * (9 + 9 * 3 + 4 + 3) * (5 * (3 * 5 * 2))
9 * (8 * 9 * 2 + 2) * 7 * 9 * 7 + 4
3 * 2 * 8 * 9 + 6 * ((5 + 8 + 2 + 2) * 7)
7 * 7 * (5 * 8 + 9 * 2 + 8) + 3 + 2 + 5
9 * 2 + (6 + 8 + (2 + 3 + 7 + 4 + 5 * 6) + 5 + 8)
8 + (6 * 2 + 4 + 7 * 9) + 5 * ((7 * 6 * 6) * (9 + 8 * 2 * 8) + 9 + 8 * 5) * 2
(5 + 5 + 6 + 6 * (4 + 9 * 3 + 8 + 5) * 2) + (6 + 6) * (7 * 2 * 8 + 2) + 8 * 3 + 4
7 + 9 + ((9 * 5 + 6 * 6 * 6) * (6 + 7 + 8 * 7 * 4 + 6) + 8 + 4 + 9) + (9 + 3 * 4)
5 + (9 + 4 * (7 + 4 * 5 + 5) + (6 + 8 * 7) + (8 + 2)) + 3 + 8 + (7 * 7 + 6 * 9 + 5)
(3 * 5 * 8 * 9) + 9 * 3 * (5 + (4 * 7 * 7 + 5 * 7) * 8 * 5 + 4 + (3 * 5 + 4)) + 2 * 6
((6 * 7 + 6) + 5 * 8 * (9 * 2 * 4)) * (4 + 6 + 3 * 9 + 7)
3 + 5 * 5 + 8 + 9
5 + (7 * (2 * 4 + 5 * 2 + 7 + 6) + 2 * 7) + 3 + 9 + (2 * 4 * 4)
(5 + 6 * (6 + 9 * 2)) * 4 + 3 + 7 * 3
9 * 5 * ((5 * 9 + 5 * 4) * 3 + 5 + 4 + 2) * 3 + 9
7 + 7 * 9 * (7 * 3) * 5 * 8
4 + (5 * 2 + 9 + 6) * 2 * 3 * 3
9 * 9 * 5 * ((9 * 5 * 9 + 3 * 7 + 4) * 9 * 5) + 5 + 3
(7 + 8 + (2 + 9 + 6 * 6 + 9 + 6)) + 6 * 7 + 9 + 9
8 * (3 * 8 + 5 * 4 + 5 + (5 + 5 + 9)) + 9 * 5 * 4
(6 + 5) + 9 * 2 * 8
(8 * 5) + 6 * 6 * 6 * ((3 + 7 + 3) * 9)
4 * (3 * 2 * 5 + (6 * 2) * (8 * 8 * 4 * 8 + 3 + 3) * 6) + 2 + 3 + 9 * 8
((8 * 6 + 4 + 5 + 6 * 3) + (8 * 8 * 7) * 2 * 6 * 3 * 7) * (4 + 7 * 4) + 4 + 2 + 3 * 9
7 * 4 + 5 + 3 + (4 * 3 + (6 * 8 * 5 * 5 + 4) + 9 * 3 * 8) * 9
2 + (3 + 3 + 6 + 2) * 5
9 + 8 + 9 + 4 * ((2 * 2 * 4 * 9 * 4) * (3 + 5 * 7 + 9) + (7 + 9 * 2 * 7 * 3) + 7)
8 + 3 + 2 * (2 * (7 * 5))
(8 + 5 * 8) * 8 + 4 * (3 * (5 * 3)) * 7
(3 * 9) * 8 + (3 * (9 + 3 * 2 * 7 * 9) + 8 * 9) * 4 * 7
8 * 7 * (3 + 4 + (5 + 7 * 4 + 2 + 7) * 7 + 8 + 9) + ((8 + 3) + 3) * (9 * 2 + (7 * 6 + 3 + 3 * 2) + (8 * 6 + 8 * 8 * 4 * 9)) * 4
5 * (3 + 5) + 5 * 7 * 4
(5 * 5) * (5 * 4 + 8 + 6 + (2 + 6 + 2 + 6 * 4 * 8) * 6) * 7 + 3
(6 * 9 + 8 + (9 + 8 + 2 * 4 * 2 + 3) * (8 + 6 * 9 + 9)) + 9 * 5
(3 + (2 + 6 * 5 + 9 * 4) * (2 * 4) + 2 * 3) + 4 + 6 + (7 + 2) * 6 + 4
5 + (4 * 2 + 7 * 6 + 6 + 3) + (7 + 7 * (8 * 3 + 8 * 4 + 4 * 2) + 7 * (8 + 2 + 9 * 6 + 4))
(7 * 4 + 7) + ((6 + 7 * 3 + 7) * 9 + (9 + 6 + 3) * 9 + 9) * 2
8 + (5 * (3 * 2 + 7 + 2) + (7 + 6)) * 9
8 * (6 + 5 + 8 * 3 * 8 * 6) * 8 * 9 * ((4 * 5) * 2 * (2 * 3 * 8)) + 5
5 + 5 + 5 * 2 * 2 + 4
(3 + 3 * 5 * 3 * (2 + 9 * 4 + 2 + 2 * 6)) + 4 + (8 * 9 + (9 * 8) + 9 + 7)
(9 * (3 + 2) * (8 * 8 * 5 * 4) * (9 * 4 + 8)) + 8 + 6 + 3 * 8
(2 * 2 + 9) + 5 * 8 * (3 * 4)
6 * 9 + 3 * (9 + 8 + 7 * (6 * 9 * 4 * 2)) + 4
((6 + 9 + 9 + 6) * 2 * 8) * 3
4 * (4 * (8 + 5 * 2 * 2 + 3 + 4) * (8 + 3 * 5 * 5)) * 9 + 3 * (6 + (9 + 2) + 8 + (2 + 3) + 7 * 6) + (4 * 4)
(8 * 8 * 5 + 2) * 9 * 8 + 8 * 4 * 2
4 * 9 + 8 + 4 * 6
4 * ((6 + 2 * 8) * 9 * 9) + 7 + 5 + 9 + 8
(4 * 6 * 2 + 9 + 6 + 6) + (4 + 2) + 6 + 3 + (6 + (5 + 7 + 8 + 3) * 7 + (4 * 5 + 6 + 9 * 7 * 4))
9 * 7 + ((2 * 7 + 3 * 9 + 3 + 9) + (6 * 8))
(7 + 6) + 9 * 8 * 9 + 6
3 * 3 * 4 + (2 * 9 * (6 + 2 * 4 + 9 * 8) + (7 * 9 + 4 + 4 * 4 * 6) * 8 + 8) + 5 + ((7 + 7 * 9 * 8) * 4 + 4 + (5 + 5 + 6 + 6) + 4 + 8)
(4 * 9 + 8 + (4 * 2 + 5 * 3 * 7 * 2) * 5 * 2) * (4 + (8 + 5) + 9 + 3 * (9 * 4 * 5 + 4 + 2)) * 3 * 3 * 9
(5 * (7 * 2 + 9 * 2) * 6) + 9
((3 * 2 * 6 + 3 * 7) * 6 * (9 + 6 * 7 + 4 * 5) + 6 * 9 * 3) + ((6 + 3) * 3 + (5 * 5 + 7 + 5 + 4) + 2 + (9 + 2 + 9 * 2) + 2) + 6 + (6 * 7 + (7 * 3 * 5) * 2 + 3 * 7) * (6 + (8 * 6 + 4 + 6 + 2 * 8))
8 * 3 + 2 * (6 + (2 + 9 * 8) * 2 * 9)
(9 * (7 + 3 * 8 * 5) + 7 + 3 + (4 * 2 * 3) + (7 + 2 + 2 + 3 * 7)) + 5 * ((6 * 5) * (9 * 4 * 8 * 2 * 2 * 5) * 9 * 2)
5 + ((2 * 4 * 9) * 6) + (9 + 7 + 2 * (2 + 5 + 6 + 2)) * 9
9 * 6 * (9 + 5) * 2
9 * 2 * 2 + 6 + (8 + (5 * 5 * 6 * 6 + 4 + 7) + 6) + ((3 * 7) * 4 * (2 * 6 + 9 + 2))
(2 + 4) * 5 + 5
(7 + 8 * 2 + 5 + 3 + (3 + 4 * 9 * 9 + 4)) + 2 * 8 + 3
3 + 9 + 5 + (8 + 3 + (9 + 8 * 6)) * 8
8 * (6 * (2 * 3 + 5 + 9 * 7 * 8) * 2 * 5 + 5) + 7 * 2
3 * (3 + 3 + 2) * 6 * (8 * 6 + 5)
6 + (8 + 2 + 5) + (5 + 4 * (3 + 3) + 3) + 4 + 9
(5 * 5 * 3) + ((4 * 4 * 9 + 8) + 9) * 2
2 * (4 * 3) * 2 + 3
7 * 2 * 5 + 4 + 5 + (8 * 7)
3 + (4 * 6 + 4 * 8 * (6 + 7 * 7 * 7 + 5))
3 * (8 + 5 + (6 + 6 * 8 * 7 + 6 * 8) + 3 + 2 * 5) + 3 + 9 + 6 + 5
6 + (2 * 6 * 4 * 9 + 4) * (9 * (7 * 4 + 4 * 5 + 2))
(7 * 3) * (5 * 6 + 9 * 6) * 2 * (9 * 7 + 7 + (2 * 4 * 6 + 9) + 9 + 9) * 4 * 4
(4 * (8 * 3 + 3 * 2) * 7) * 2 * 3 * 9 * 5 * (3 + (2 + 9) * 5 + 7 * (6 + 9 * 2 * 2 + 9) * 9)
3 + 9 * 7 + ((3 + 4) + (4 * 3 * 4 * 2 + 2) + 9 * 4)
3 + 6 + 2 + ((2 * 9 * 4) + 5 + 5 * 5 + 8 + 4) * (7 * (9 + 5 + 7 + 5 * 2 + 7)) * 3
5 * ((2 * 9 + 8) + 4 * 7 * 5) * (5 + 5 + (9 + 8 + 7 + 5 + 5) + 2 + 8) + 7 * 6
9 + ((7 * 3 + 4 + 3 * 3 + 7) * 5) + (8 + 2 * 6 * (8 * 9) * 4 * 7)
4 + 3 + 6 + 3 * 5 + (8 * 4 * 2)
(9 + (2 * 4 + 6 * 3) + 7 * (4 + 6) + 3 + (6 + 2 + 8 + 9 + 5 * 7)) + (9 + 3 + 4) * 3 + (8 * 4) + 9
8 + 8 * (6 + 9 + 2) * 6
4 + 7 + (3 + 4 + 5 + 7) + (5 + (9 + 6 + 8 + 7 * 3) * 3 * 7 * (2 * 4 + 3 + 6) + (8 * 9 * 2 + 6 * 6 * 5))
(2 * 7 + 4 + 8 * 8) + 3 + 7
(4 * 3 * 4 + 3 + 8 + 5) + (8 * 6 * 5) * 9 * 7 * 7 * ((7 * 5 + 8 * 4 + 2) * 8)
4 + ((9 * 9) + (6 + 2)) + 9
((8 * 3 + 3 * 6 + 5) * 5) * 6 * 8 + 5 * (3 + 9 + 5)
8 * ((9 + 6 + 3 * 2 + 4) * 9 * 3 * (6 + 7 * 6 * 2)) + (3 * 4 * (3 * 9) + (9 + 9)) + 2
8 * (6 + (6 * 6 + 5 * 4 * 2) + 7 + 5 * 5 + (8 + 9)) + 3 * (4 * (9 + 4 * 9) * (2 * 6 * 4 + 3 + 2) + (7 + 3 + 5 + 6)) * 5 + (3 + 9 * 6 + (3 * 4 * 8 + 7 * 7))
5 + 8 * 3 * 8 + 9
3 + (4 * 8 + (5 + 5 + 3 + 9 + 2 + 6)) + ((4 + 9) + (8 * 7 + 3 + 6 * 6) + 7)
(2 * 2 + 7 + 2 * (9 * 2)) * 3
7 * 3 + 2 + 9 * ((2 + 2 + 3 * 4 + 2) + (4 * 9 * 5 + 9 + 8) * 3)
(8 * 6 + 4) + (7 + 8 + 3) + 4 + 9
(4 * 6 * 5 * 6) + (2 * 4 * (5 * 9 * 8 + 7) * 2 * 3 + 6)
(6 * 5) * (3 + 2 * 3 * 9 * 4)
9 + 4 + (3 + 3 * (7 + 2) * 5) * (5 + 8 + 5 * 8 * 2)
(3 * 4) + ((3 + 4 * 9 * 7 * 5) * 6 * 8 + 6) * 5
3 + (8 * (8 * 7 * 2) * 8 * 3 + (9 + 9 + 5) * (3 * 4 + 3)) + 5 * 7
6 * 3 + 8 + (7 * (5 + 8 + 9 + 5 * 6 * 3) * 3 * 8 * 6 + 5) + 6
7 * 8
3 + 7 * (7 + 9 * 4 * 2 + 9 * 7)
(4 * 7 * 4) * (3 + 5 * 6 * 6 * 2 + 6) * 8
8 * 5
(7 * 8 + 4 + 8 * (4 + 7 * 5 + 7 * 5)) * 3 + 3 * 8 + 9 + 6
8 * (8 + (5 * 5 * 5 + 9) * (8 + 6)) * (6 + 2 * 9) * 2 * 3 + 6
(6 * 8 * (5 + 2)) + (3 + 6 + (9 + 9 * 2) * 3) * 8 * 4 * 7 + 8
(3 * 9 * 2 + (8 + 8) + 9) + 2
(8 * 2) * (8 * 6 * 4 + 6 + 3 + 3)
7 + 5 + (3 + 2 * 2) + 5 + (6 * 8) * (7 + 6 + 6 * 9)
(3 * (2 + 9 * 5 * 8 * 7) + 9 + 4) + 9 * 5
5 + 3 + (5 + 8 + 4 * 5 + 8 + (5 * 3 + 7 * 6 + 3 * 8)) * 2 + 7 + 3
(5 + 6 + 7 * (9 * 7 * 2 + 3 + 8) * 8) * 4 + 2
6 + (2 + 5 + 2 * 7 * 7 + 6) * 8
8 * 8 + (7 * 4 + 2 * (6 + 5 + 2) + (3 * 2 + 8 + 9 * 7)) * (3 * (2 + 9 + 9 * 4 + 2 * 9) * 4)
(5 + 8 + 8 * 8 * 9 * 6) * 3 + 5 + 7
8 + 5 + 6 * ((6 + 7) * 5 * 2 * 9 * 3 + 2) + 2 * 4
(8 * 4 + 5 * 7 * (7 + 7 + 3 + 7 + 9) + 9) + (3 * 2 + (7 * 7)) * 2 * 6 * 2
4 * 6
(9 + 8 + 2 * (9 + 7)) * 4 + 2 + ((6 + 9 * 3) + 5 + 5 + 4 + 2 + 8) * 2 * 6
(8 + (4 + 9 + 9) * (7 + 6 * 4 * 5 + 7) + 3 * 2 * 5) * (9 * 5 * (2 * 7 + 2 * 6)) + 3 + 8 + 3
3 + (7 * (4 * 2) + 7 * 5 + 8 + 6) * 4
8 * 7 * 5 * 4 + (2 * 7 * 6)
8 * 9 * 5 * ((6 * 4 * 5) + 4 + 2 * 5 * (4 * 4 * 7 + 4 * 6 * 6))
8 + 8
4 * 3 * 7 + 8 + (8 * 7 + 5 + 7 * 3)
(9 + 4 * (6 * 2 + 5 * 6)) + 7 + 7 * 6
3 * (8 * 6 + 3) + 2
9 + ((7 * 8) + 6 + 5 + (4 * 4 * 9 * 5) * 8)
7 * (9 + 8 * 3 * 3)
2 + ((6 + 7 + 8) * 4 * 4 * 3) + 6 + (7 * 2 * 4 + 4 * 6)
2 + 2 + 6 + 9 * (8 * 2 + 2 + (7 * 8 * 5 + 5) * 7 * 3) + 8
(5 + 6 + (9 * 8 + 7 + 2 * 3 * 2) + (9 + 9) * (3 * 3 * 6 * 2 * 3 + 6)) + ((9 + 3) + 2 * 4) * 7 + 2 + 2
(4 * (6 * 8 * 5) + (9 + 2)) * (2 + 8 + (2 + 9 * 7 * 5 * 2) + 6 + 8) + 8 + 2 * 4
9 + 3 * 7 * 8
(6 + 4 + 7 * 6 + 9) + 4 * 4 + 9 * 9
(8 + 9 + 9) * (5 * 6)
7 + (9 + 4 * 2) * 6 + (9 * (4 + 2)) * 7 * (2 * 7 + 5 + 2 * 6 + 2)
4 + 5 * 4 + 5 * 7 * (8 * 5 + 5 + (4 * 8 * 7 + 8) * 3)
8 + 5 * (8 * 3 * 5) * 9 * (4 + 6 + 6 * (5 * 9 * 9 + 5 * 7 + 2)) * 8
(7 * (6 * 9 * 8) + (8 + 4 * 7 * 2 + 4) + 8 * 3 + (6 + 6 * 3)) * (4 + 4 * 8) * 8 * 7 * 2 * 4
(9 + 5 * 5 + 6 + 3) * 9
8 * (7 + 6 * 9 + 4 + 9) * 2
((9 + 6 * 4 + 7 + 3 + 7) + 5 * 9 + (3 * 9)) + 3 + 7 * (7 + (4 + 5 + 3 * 5)) * 9
2 * 6 + 4
(6 + 6 + 5) * (5 * 8 + 6 * 5) + (9 * (7 * 6 + 3 * 3 * 4 + 7) + 7) * 4 * 4
8 + 6 * 4
(3 + 3 + (4 * 6 + 5 + 9 + 7) + (8 + 6) + 8 + 2) * 5 * 6 + 7 * 7 * (9 * 5 * 8 * 7 * 3)
((2 + 6 * 8) * 2) + 7
6 * 2 * 3 + (4 * 5 * 4 + 2)
6 + 4 * (4 + 3 + 2 + 8) * 5 * 4 * 5
2 * 4 * 2 + 7 * 4 + (5 + 7 + 3 + (7 * 6 + 8 * 8 + 7) + 4 + 3)
8 + 8 * 7 * (4 * 9 + (9 + 4 * 7 * 6)) * 7 + (4 + 4 * (3 * 2))
9 + 6 + (8 * (2 + 8) + (3 + 2 + 2 * 4))
(4 + 4) + 3 * (9 * (6 * 6 * 4 * 8) + (3 * 8 * 5 + 2 * 2 + 3) * 9 + (8 * 5 + 4 + 8 + 2 + 9)) * 4
(3 + 8 * (2 + 2) + (9 + 6 * 3 + 3 * 7 + 5) + 7 + 2) + 8 * 6 + 7
7 * 9 + (7 * 3 + (9 * 4)) + 5
((9 + 7 + 3 * 6 + 9 + 3) + 9 + (4 * 8)) + 9 + (3 + 8 + (7 * 4) + 3 + 9 * 4) * 9
(4 * 8 * 5 * (5 * 5 + 7 * 6 + 2 * 7) * (9 * 6 + 4 * 2 * 2 + 8) + 7) + (4 + 6 + 9 * 8 + 2) + 9
8 * (9 + 9 * 6 + 2 * 5 + 2) + 7 + (9 * 8 * 9 * (6 + 5 * 6)) * ((6 * 9 + 2 * 8) * 6 + 5 + 6) + 2
(9 + (2 + 2 * 4 * 6) * (6 * 4 * 4 * 7) + (6 * 7 + 9 * 9 * 6 * 8) + 4) * (5 + 5) + 5 + 5 + ((6 + 8 * 2) + 8) + 6
8 + (6 + (3 * 7 * 3 + 5 + 4 + 5) * (4 * 7 + 5 + 5 * 4) * 4) * 8 * 7 + 5
6 * 2 * 7 * 4 * (3 * 9 * 7 * 2 + 7) + 5
9 * ((6 * 2 * 4 + 3 + 8) * 8) * 2 + 7
(7 + (7 * 6 * 3 * 6 * 6 * 7) + 8 + 9 * 7 + 6) + 5 * 5 + (3 * (5 * 3 * 5 + 6 * 2 * 6) + (2 + 9)) * 3
((6 * 7) * 6) + 4
6 + 6 + 9 + 7 * (8 * 2 * (7 * 7 + 9) + 2 * 4) + 6
2 + 4 * (2 * 8 + 2) + 3 + (3 * 9 * 2 + 5 + 5 * (3 * 3))
6 + 8 + (6 + 6) * 3 + ((6 + 7 + 4 * 5) * (9 + 3 + 3)) + (3 * (3 * 8 * 4 * 7) * 6 * 2 * 4 + 6)
3 * 9 + (3 * 6 + (2 * 9 * 7 * 5 * 8) * (6 * 9 * 7 * 7 * 3) + 6)
7 + (8 + (3 + 3 + 2 + 4) + (8 * 7 + 8) + 9)
4 * ((7 * 4 + 3) + 9 * 4 * (3 + 5 * 6) + 8 + 6) * 8 * 8
9 + 9 * 2 + 2 * 6
(5 + (9 + 4 * 5) * 9) * 7 + 8 * 7 + 5 * 8
(3 * (6 + 8 * 7 * 8 + 3) + 9 * 7 + 6) + 9 + 3 * 3 * ((3 + 5 + 3 + 4 + 8) + 2 * 4)
((4 + 4 + 4 + 9 * 7) * 7 + 9 + 2 * 7 + 9) * 5 * 5 * 8 * (4 * 8 * 4 + 8)
(5 + 5) + 3
4 * ((5 * 8 + 9) + 8 * 9 * (2 + 4 * 9 + 5 + 8 * 2) * 2 + 6) * 5 * 8
5 * (7 + 7 + 7 * (6 + 5 * 5 + 2)) + 3 + 3 * 3
4 * (9 * (3 + 3 * 9 * 2) * (8 * 3 + 6 + 3 + 3) * 5 + 5 * 8) + (3 * 4 + 8 + 2) + 8
(4 * 8) + 9 * (6 + 2) * 3
9 * 7 + (2 + 3 + 4 + (2 * 2) * (5 * 4 * 5 * 3))
5 + ((4 + 8) * 9) * 9 * 5
9 + (5 + 8 + 9) + 5 + 4
(6 + 6 + (6 + 4 + 7 * 7) + 9) + 9 + (5 * 6 + 9 + 4 + (4 + 2 + 5 + 2) + 7) * 4 + 6
(4 * (6 + 5 * 6 * 5) * 5 * 3) + 5 * 6 * 9 + 4 * 8
(8 + 2 * 2 + 8) + 2 + ((2 + 9 + 3 + 7) + 8) * (3 * 9 + 3 + 8) + 2
2 * 2 * 4 * 5 * 6 * 8
2 + 8 * 7 + 3 * (5 * 8 + 6 + 3 + 4 + 7) * 5
3 * (4 * 3 + 5 + 8 + 8) + 2 * 9 * 9 * 4
((7 * 4 + 5 + 8 * 5) * (2 * 8 + 3 + 5) + (7 * 2 + 9) + 9) * 3 + 9 + 9 * 9
4 + 9 + (7 * 7) + 5 + (8 + 2)
((8 + 2 * 3 * 2 * 4) + 8 * 8) + 2 + 3 * ((7 * 6 + 6 * 4) + 9 + 9 * 8) * 5
(5 * 7 * 7) + 5 + (4 + 7 + 5 + (4 + 7 * 9) + 9 * 9) * 2
5 * 9 * (8 + 6 * (5 + 5 + 6 * 8) + 8 * 4) + (7 * 8) * 8
4 * (2 * (7 + 7 * 7 + 8 * 9 * 2) + 8 * 2 + 6)
((5 + 2 * 3 * 4) + (2 + 5 + 3 + 3) * (2 * 5 + 8) * 8) + 4 + 8 + 7 * 9
(9 + 7) + 8 * 9 * (9 + 2 * 6 + 8) + 4
(9 + 7) * 5 * 7 * (4 + 6 * 4 * (6 * 7 + 5 * 3)) * 8 + 3
7 * (3 + 2) * 2 + 9 * (8 + 9 + (8 + 9 + 6)) * 8
(5 * 8 * 9 * 9) + 4
7 * 5 + ((3 * 2 + 4) * 5 + 7) + ((7 * 3 * 8) * 4 * 7)
(9 + 9) + (6 * 6 * 7) + 6 * 3
3 + 9 + 9 * 5 * (7 + 3 * (4 * 5 + 9) * 5)
3 * 8 + 9 * (2 + (2 * 3 * 7 + 8 * 4) + 9 * 8 + 7) * 7 * 4
4 + 9 * (7 * 9 + (5 * 9 + 8))
(2 * (7 * 5 + 6 * 6 + 5 * 2) * 5) * 5
((8 + 2 + 6) * (5 * 3) + 8) + 7 + 7 + 7 * 9
(3 * 3 * 8 + 9 + 3 * 3) + 4
7 * 8 * 6 + 3 * 2 + 3
7 * 3 + (2 * 3) * 5 + 6
9 * (6 * (4 + 2 * 8 + 6) + 5 * 2 * 2)
(4 * (4 * 6 + 9) * (4 * 2 * 4) + 3 + 3) + ((4 + 8) * 2 + 6 * 9) * 6 + 9
5 + (4 * (5 + 7 + 5 + 7) * (9 * 3 * 9 * 7))
6 * (5 + 9 * 8 + 5 + 8) * (8 + 2)
(8 + 3) * 6 + (8 + 2 * 5 * 2)
(6 + 6 * (8 * 6)) + ((2 * 5 + 3 + 5 + 5 + 8) * 8 * 4 * (6 * 8 + 7 * 9 + 5) * 8)
5 * 4 * 5 * 9 + 2 * 4
8 * 7 * (5 * (6 + 7 + 9 + 3 + 9 + 5) + (6 * 3 * 3) * 4 * 6)
2 + (8 * 6 + 9 * (7 * 8 + 6 * 3 * 6 + 5) + 6 + (7 * 4 + 4 * 7)) + 9 + 5
7 + 9 * 6 + (5 + 8 * 6 + 9) + 6
(2 + 4 * (5 * 9) + 5) * 8 * 4 * 5 * 8
8 + 7 + 5 + 9 * 7
3 * 4 * 5 * 8 * (4 * 3)
(4 + 8 + 4 * 5 * (2 + 5 + 9 * 7 * 2 + 7)) * 3 * 5 * 2 + 5
7 + (4 * 8 + 9 * 3) + 6 * 3 * (6 + 5 + 7 * 3) * 5
((9 * 6) + 8 * 6) + (9 + 9 * 6 + 9) + (8 * 6 + 5 * 4 + 3) + 5 * 4 * (6 + 5 * 3 * 9 + 6 + (5 + 8 * 2 + 7))
(7 + (5 + 8 * 2) + (4 + 8 * 7 + 9 * 5) * 9 * 5 * (2 + 8 * 9 + 3 * 2 + 5)) * 9 + 5
(7 + 8 * 7 + 7 * 8 * 9) + 7 + 6 * 5 * (5 * 4 + 5)
4 * (2 + 4 + 4)
(3 * (9 * 8 + 6 * 4 + 6)) + 5 * 3 + 2 + (4 + 5 + 8)
6 + 6 * 6 + ((7 * 4 + 7) * 6 + 9)
6 + 6 + (2 + 4 + 5 + 5 * 9) * 2 * 4 + (3 * 8 * 6 + 9)
(2 + 7 + (5 * 5 * 7 + 8) * 5) + 4 + 3
(7 * 7 + 8 + 9) * 2 + 5
5 * (5 * 2 + 2 * 9 * 5) + (2 + 8 * 3 * 4 + 2 * 8) * 8
2 * 6 * 4 + (8 * 9 * 8 * 4 * 3) + 7 + 3
(9 * 4 * 8) * 5 * (5 * 7 * (3 + 3 * 6 * 2) * 5 + 7 * 2) + (2 + 8 * 2) * 2 + 5
5 * (7 * 2 + 6 * 9 * 3 + (3 + 2 + 6 + 7))
(2 * (4 * 2) * 7) + 3
5 * (3 + 2 * 5) * 5 + 8 + 3
(5 + 6 + 6 * 2) * 5 * (5 + 8 + (9 * 8 * 4) + 9) + 9 * 7 * (3 * 8 * 8 * 3 * 8)
((7 * 9 + 8) + 6) * ((9 + 7 * 8 + 6) * (4 * 4 * 4 * 8 + 5 + 6) * 8 * 7 + 4 * (2 * 2 + 3))
(5 + (4 + 7 + 8 + 6 * 8 + 5)) + (8 * (7 + 4 * 7) * (8 + 8 * 5 * 6 * 4) + 9 + (3 + 4 * 6)) + 3 + 2 + 3
8 + (8 * 7 + 5 + 3) + 7 + (8 + (5 * 5)) * 6
2 + 4 + 4 * 9
7 * 4 * 2 + 4 + 3 + (8 * 6 * 6 + (5 * 2 * 6 * 9 * 7) + 7)
8 * (5 * 3 + 2 * 6 + (6 * 5 * 4)) * 8 + (4 * (2 + 7 * 3 + 9) + (2 * 3)) + (4 * 3 + 6 * 3 * 7 * 3)
9 + 6 * (3 * 9 + 2 + 3 + 6) + 5
(9 * 6 + 8 + 8) + 8 + 6 * 9
((6 * 9 + 2 + 8 + 4) + 6 * 7 + 8 + (2 + 5 + 7 + 5 + 3 * 8) * 5) * 6 + (2 + 4) * 7 + (3 + 2 * (4 * 8 * 5) * 2 + 7 * 9)
(2 + (5 + 9 * 7 + 6) * 2 + 7 * (4 * 6)) * 9 * (7 + (8 + 5 * 3) + 3) * 5 * 3 * 5
(7 + (8 + 5 * 7 * 2)) + 2 * 7 + (2 * 5 + 7) * 8
4 + 8 + (2 + 9 + 4)
((3 + 7) + 7 + 5) + 2
6 + 8 + 9 * 2 + 9 + (6 + 4 + 3 * 4)
(9 + 2) * 7 + 7 + (3 + 4) + (8 + 3 + 3 + 5) + (2 * 7 + 5 + 4 + 3 + 8)
3 * ((7 + 9) + 5 + 9 * (9 + 6) * 3 * (9 + 2))
(7 * 3 * (5 + 2 + 5 + 8 * 3 + 7) * 3 * 3 * 6) * 4 + 8 + 3 * 5
4 * (5 + 7 * 6 * 5 * 2) + 6 + 3
7 * 6
9 + (2 * 7 * (8 + 2 + 5) * 8) + (7 * 8 + 9 * 7)
(4 + (8 * 5 * 9) * 2 + 8 * 4 + 4) + ((3 * 9) + 6 * 3 * (3 + 9 + 6 * 2 + 5) * 7) * (2 * (5 * 5 * 2 * 6 * 9)) * 6 * 9
(7 + (4 + 9 * 2 + 8)) * 6 * 8 + 7
8 + (8 + 5) * (3 + 3)
5 + 3 * 9 + 2 * (3 + 7 * (6 + 2 * 4 + 3 + 3) * 5)
5 * 9 * (3 + 9 * (4 * 6 + 2 + 3 + 3) * 4 + 8 * 4) * 8
3 * (9 * 8 + 4 + 5) + ((2 * 6) * 2 * (3 + 6 + 6) + 3) * 7
8 * (6 + 4 * 8 * 8 * 4)
(6 + 8 * 8 * 2 * (2 * 9 * 3 + 3) + 7) * 5
4 * 5 * (3 + (9 + 3 * 6 + 9 + 7) * 5 * (2 * 4 * 8 * 2) + 6 + 2) + 5
2 * 5 * (8 * 5 * 4) + (7 * 2) * (7 + 5 + 6 * 6)
5 + 3 * 3 * 7
9 * (3 + 7 * 3 + 7) * 2 * (6 * 7 + 3) + 4 + 5
4 + 6 + 7
9 + 2 * (6 + 5 * 5 + 4) * 6
5 * 7 * (5 * 9 + 4 * 3 * (7 * 6 + 3 + 3 * 6 * 9))
9 + ((3 * 7 * 9 * 6 * 5) * 6 + 9 * 4 * 8 + (6 * 5 + 7 + 9 * 3)) + 3 * (9 + 2) + 3
7 + 3 + 6 * 6 * (7 * 4 + 9 + 7) + 4
6 + 8 * (7 + 2 + 2 * 7 + (8 * 9 * 2 * 7)) * 2 * 9 + 7
(9 * 6 + 7 + 2) + 3 * (4 * 2 * (3 * 6 + 5 + 3 * 8 + 6) * (3 + 4 + 9 * 7 * 2) * 7 * 9) + (6 * 6 + 4) + 5
8 * (3 * 9) * 6 + (5 * 2 + 9 * 3) * 4 + (5 * 7)
7 + 4 + (7 + 6 * 7 * 8) * (8 * 3 + (4 + 5 + 3 * 9 + 6 + 5) + 8 * 5 + 5) * 3
4 * (4 + 9) + (7 + 5) + 3 + 7 + 9
3 + (8 * 9 * 3) * 9 + 2 * (7 * 4 * 3)
6 * 2 + ((2 + 4 + 5 + 8 + 2 + 6) + 8 * 9) * 9 * 5 + 7
6 + ((3 + 2 + 9 + 9) + 8 * 2 * 6 + 4) + 3 * 6 + 4 * 9
(3 * 5 + 7) + ((7 * 7 + 5 + 8 * 3 * 2) + 9 * (9 + 4 * 3 + 7) + 6) + 7 + 3
(4 * (3 * 7 + 9 * 2 + 6)) * 5 + 9 + 7 + 4 + 7
8 * 5 * 4 + 7 * (4 + 7 * (9 + 6 + 2 + 9)) + 9
8 + 4 * 3
7 + 2 + (4 * 3 * 9 + 9 * 7 * 9) * 7
3 * 6 * 9 + (4 + 9 * 4 + 3) * 3 + 6
3 * (3 + 7 * 6 + 4 * 4) * (9 + 5 * 5 + 6 + 7 * 5) * (3 + 7) + 4
9 + 6 * ((3 + 7 * 6 + 9 * 4 * 4) + 5 + 5 * 3 + (4 * 6 + 3 * 5)) * 8
9 + (5 * 9 + 2 * 4) + ((9 * 8 * 5 * 5 + 8) + 5 * 6 * 6)
(4 * (8 + 5 * 4) * 9 * 9 + 5 + 5) + 4 * 7 * 8
3 * 5 + (5 * 4 + 9 * 8 * (6 + 4 * 9 + 4 * 7) * 9)
((4 + 4) + (6 * 2 + 9 + 3 + 5 + 7)) * 3
6 * (9 + 8)
6 + 8 + 5 * 7 + (2 * 6 * (6 * 5 * 4 * 6 + 8 * 9) * (9 + 6 * 5 * 9 + 7 * 8) * 8)
((9 * 3 + 8 * 4) * 2 * 9 + 7) + 3 + 7 + 6 * 3 * 7
(2 + 8 + 7 + 5 + 6 * (8 * 4 + 2)) + 8 + 4 * 4 * (3 + (2 * 6 + 6 * 9 * 8) * 9 + 9 * 5 * (4 + 6 + 3 + 5 * 9)) * 4
9 + 4 * (5 + 4 + 7 * (8 + 8 * 2 * 8 * 2 + 3)) + 6 * 3 * (6 * 7)
(7 + 9 * 6 * (9 + 7 + 6 + 4 + 4 + 5)) * 4 + 5
8 + (8 + 2 * (4 + 5 + 5 + 5 * 3 * 8) + (5 * 6) + 3 + 2) * (7 * (4 * 5) + 3 * 5 * 4)
3 * ((4 * 9) + 3 + 8 * 7 * 4) * 4
5 * 9 + 8 * 4 + 2 * 3
2 * 9 * 4 + 2 * ((3 + 8 + 7 * 9) + 7)
(7 * 3 * (8 + 3 + 2 * 5 * 9) * 9 + (7 + 2 * 9 + 5 + 2) * 6) * (9 + 6 + 4 * 9 * 6 + 6)
7 * 5 * 5
(4 * 7 * 6 * 5) * ((7 + 5 * 3 + 4 * 2) * 5 * 9 + 5 * 6) + 3 * 8 * 5 + 9
6 * 6 * (4 + 5 + 6 + 9 + 6 * 3) + 4 + ((7 + 5 + 6 * 7) * 9) * 5
3 + 6 * 9 * 5 + 3 * ((9 * 7) * (6 + 8 + 5 + 7 * 8 * 7) + 4 + 4 + 4 + (6 * 7 + 4 + 2 + 5 + 9))
9 * ((4 * 2 * 6) * 7 + 4 + 6) + 4 * 4
6 + 8 + 5 * 4 * ((2 + 2) * 6 * 9) + 4
(8 * 4 + 8) + 3 * 4 + 7 * 9 + (5 * (8 * 7 + 2 + 3 * 4) + 2 + 3 * 8 * 8)
7 * 9 + ((2 * 9 * 6 * 6) + (6 * 2) * 7 + (8 + 3 * 6 + 4 * 5)) + 8 * 9
8 + ((3 + 3) + 7) * (4 + 3 * 3 * 7 * 7 + 9)
(9 + (4 + 6 + 7) + (4 + 4 * 4) + 6 + 4) * 3
4 * 6 * ((8 + 3 * 3) + 7 * (5 * 7 * 3) * 3 * 8) * 5 + 2 * 3
((6 * 5) + (7 + 6 + 7)) + 2 * 3 * 2
5 + 3 * 8 + 4 * (9 + (2 + 7 + 7 * 3 + 8 * 2) + 2 + (3 + 6 * 7 + 5))
2 + 7 * 4 * 7 * (7 + 3 + 9 * 5 * (5 + 6 * 6)) + 3
((2 * 2 + 7 + 2 + 4) * 7) + 2
6 + 4 + 3 + ((9 + 5 + 2) * 4) + 9
8 + ((3 * 8 * 7 + 6) * 3 + 6 * 2) * (4 + (2 * 8 * 2 + 9) * (7 + 4 + 7 * 5 + 7) + 3) * 4 * 5
4 * (8 * 2 + 8) + ((5 + 5 + 3) * 6 + 5) * (7 * 9 + 7) * (9 * 5)
2 + (9 * 4) + ((7 * 3) + 8) + 7
4 + 6 * (9 * 2)
(8 + 6 + (7 * 2) * 3 + (9 * 2)) + 5 + 8 * 3
7 + (4 + 5 * 2 + 8 * 7 + 5) * 4 * 4
4 * 4 * 6 + (7 * 3)
(9 * 6 + 4 * 6 + (3 * 5 * 2 + 5) * 9) * 2 * (8 * (4 + 9 * 7 + 8 * 2 + 2)) + 5
8 + 2 * 7 + 5 * (4 + (8 * 9 + 5 * 5 + 6) + 4 + 3)
5 * (3 + (8 + 5 * 2) + 2 + 6 + 7) + (7 * (9 + 4) + 8 + (8 + 9) + 6) + (7 * 6 * 5 + 6 * (9 * 3 * 9 + 4) * 8) * 4 * 4
2 + 7 * 8 + ((5 * 3 + 6 + 5 + 4 + 4) + 2 + 9 + 4) * (8 * 2) + 8
8 * 9 * 2 + 4 * (7 * 5 + 8 * 5 * 4 + 5)
(3 + 9) + ((3 * 2) + 5 + 4 * 8) + 3 * 9 + (3 + 7 + 7 + (5 * 7 * 7 * 9) + 5 * 8) * 5
3 * 6 + 3 + 7 + (8 + 7) + 7
6 + (7 + 5 + (2 + 8 + 3 * 4 * 3) + (9 + 6 + 4 * 2)) * 4 + (9 + 9 + 3 + 7 + 4 * 4) + 6 * (9 + (7 * 8 * 2))
8 + (7 * 6 * 5) + (4 + 3 + 2 + 9) * 6
6 + 7 * (7 + 3 + 3 + 9 * 2)
(8 * (4 + 3 + 5 + 9 + 3) * 3 + 3 + (9 * 7 + 9 + 9 + 4 + 7)) * (3 * 3 * 3 + 6 * 9) + 2
(2 + (4 + 8 + 6 + 9 * 3)) + 2 * 2 * 7
4 + 5 + ((5 * 7) * 6 + 9 * 4 * 5 * 6) + 6 + 3 * 8
8 * 7 + 5 + 5
(3 + (7 * 4 + 3) * 9 + 4 + 7 * 5) + (6 + (3 + 3 * 5) + (6 * 6 * 7))
4 * 8 * (7 * 7 * 6) + 6 * (2 * 5 + (6 * 4 * 9 + 2 + 5 * 5) * 7 * 5) * (6 * 6 * 7 * 6)
(4 * 4 + 5 + 9 * 9) + 2 + 2 + 9 * 3 * 5
((9 + 7 + 6 + 8 + 8) + 4 + 4 * (2 * 5 * 8)) * 4 + 7 * 7 + 4 * (6 + 2 + 7 + 5 * 6)
9 + 5 + 9 + 3
4 * 6 * 5 + 3 + (7 * (2 + 5 + 2 * 5 + 9) + (2 + 9 + 8 * 9 + 3 * 3)) * 5
(3 * 5 * (4 + 2 + 8 + 4 + 7) + 7 * 7) * (6 * 7 + 9 * 7 + 7 + 9)

562
input/2020/day19.txt
View File

@ -1,562 +0,0 @@
72: "b"
45: 46 52 | 9 72
85: 9 52 | 9 72
82: 52 87 | 72 77
133: 52 30 | 72 56
118: 7 52 | 70 72
18: 52 113 | 72 52
119: 72 46 | 52 18
25: 19 72 | 103 52
32: 90 52 | 78 72
50: 113 113
71: 72 106 | 52 128
3: 103 72 | 18 52
41: 86 72 | 19 52
96: 86 72 | 108 52
33: 44 52 | 104 72
127: 52 36 | 72 50
51: 72 79 | 52 38
43: 72 50 | 52 106
14: 32 72 | 129 52
6: 2 72 | 33 52
108: 52 72 | 72 52
129: 6 52 | 82 72
34: 127 72 | 3 52
74: 128 52 | 9 72
80: 52 103 | 72 19
2: 134 72 | 13 52
54: 128 72 | 114 52
19: 72 72 | 113 52
0: 8 11
30: 132 72 | 39 52
60: 72 64 | 52 5
4: 18 52 | 114 72
57: 72 71 | 52 54
111: 52 27 | 72 102
76: 122 52 | 75 72
134: 86 52 | 9 72
49: 17 52 | 81 72
124: 103 72 | 86 52
123: 72 28 | 52 121
117: 18 52 | 86 72
26: 51 72 | 58 52
62: 85 52 | 44 72
55: 126 52 | 92 72
115: 72 13 | 52 67
109: 128 72 | 106 52
52: "a"
93: 60 52 | 133 72
64: 67 72 | 84 52
102: 52 128 | 72 48
84: 86 52 | 46 72
77: 41 72 | 21 52
27: 52 9 | 72 108
95: 89 72 | 105 52
36: 52 72
110: 72 50 | 52 9
9: 72 72
120: 72 19 | 52 18
67: 52 48
112: 65 72 | 119 52
75: 62 52 | 123 72
23: 15 72 | 119 52
42: 131 52 | 61 72
94: 52 91 | 72 18
66: 52 128 | 72 103
10: 113 108
37: 52 18 | 72 50
98: 72 69 | 52 94
126: 115 52 | 29 72
79: 59 52 | 94 72
104: 19 72 | 36 52
125: 96 72 | 4 52
122: 52 73 | 72 112
130: 52 20 | 72 45
90: 72 40 | 52 88
132: 103 52
121: 91 52 | 46 72
7: 52 114 | 72 128
5: 52 66 | 72 41
97: 52 18 | 72 91
89: 72 109 | 52 116
53: 52 108 | 72 128
114: 52 113 | 72 72
16: 1 52 | 110 72
113: 72 | 52
31: 52 14 | 72 12
69: 52 103 | 72 48
128: 72 52
40: 72 3 | 52 83
101: 63 52 | 127 72
1: 72 91 | 52 114
58: 52 111 | 72 99
13: 19 72 | 9 52
35: 22 72 | 125 52
65: 72 114 | 52 91
12: 52 24 | 72 93
46: 72 72 | 52 52
20: 9 72
73: 72 37 | 52 43
15: 52 50 | 72 108
103: 52 52
106: 72 52 | 72 72
21: 36 72
28: 72 50 | 52 46
78: 72 16 | 52 23
70: 36 72 | 19 52
87: 72 107 | 52 47
116: 19 52 | 106 72
29: 72 68 | 52 65
8: 42
68: 9 52 | 128 72
99: 110 72 | 25 52
17: 52 118 | 72 130
11: 42 31
48: 52 52 | 72 52
83: 48 113
105: 52 100 | 72 80
61: 55 52 | 26 72
100: 48 52 | 108 72
56: 52 53 | 72 74
63: 52 106 | 72 9
44: 72 114 | 52 128
47: 52 50 | 72 36
107: 52 36 | 72 91
39: 114 72 | 86 52
86: 52 72 | 52 52
24: 52 95 | 72 35
81: 98 72 | 34 52
131: 49 52 | 76 72
92: 52 101 | 72 57
59: 52 114 | 72 50
38: 52 74 | 72 124
88: 97 72 | 10 52
22: 117 72 | 120 52
91: 72 72 | 52 72
bbabbaabaabaaaababbbbabaabbaabab
baaabaaabaaababbabababaabababaaa
aaabbbabaabbbbbbbbabaaba
aaababbbaaabaabbabbbbabbaaaabbbb
ababaabbaabbbaabbbabbababbabbbbbbaaabbbbaaaabbbabbbaaabbaaaabbaa
bbbbaabaababaaabbbaaaaabbbbabbabaaabaabaabbaaaba
bbaababbbbbbaabbbbbaaaabbbbbabaaaabbbabaabbbaaaa
aaaaaaaaaababaaaabaaababaabbbbaababaaaaaaaaabaaabbaabbbaaabaabababbbbaaabbbbbabb
bbbbabbbbbbbbbbababbabbabbbabbbaaabbbbbaabbbbbaa
bbabaaababbbaabababbabbbabaabbbbbaaabbaaaaabbbaaaaabaabbaabbabba
babbbabaaabbaaaabaaaaabbbabaaaaa
ababaabbaaabbabbbbbbbaaaaabaabaabaaaababbaaaaaaa
baaaababaaaaaaababaaabba
bbaabbbaaabababbbaaaaabbbbbbbaaaaabbaabaabaaabaabbbaabaaaaaababbababbbbb
bbababbbaaabbabababbbabaaabbaababbbaaabaaabbbabbabababab
babbabbabbbaabbbbaabaaabbabababbbbbbbbaa
abbaaaaaabbabbaabbabbabababbaabaabbbaaaa
ababaabbabbbbbabbabbbaaaabbbaabbabbbbabb
aaabbbbaabbbababaabaaaaa
babbbaaaabaaabaaabbabbabbabaabab
aaabbaabaabbabaaaaaaaabb
ababbbabaabbaabbabaababababbbbaa
babbabaaabbbababbbababaaaaaabbaaababaaab
bbaababbbabaaababbaaabab
aabababbbbaabbbbabaabaababababaaabababab
baaaaabbbbbaabbbbbababbbbbbabbab
baaaabaaabaabaaabbabaaaababaaaab
aabbbabababaaabababbaaaa
ababbbaaabababbaaabaaababbaaaabaabbbbbab
ababbbaaaabaaaababababba
aaabbbabaabbaababbbbabbbbbabbabaababbabb
aabbabaaaabbaababbabbabbaaabaabababaaabaaaaaabab
abaaabbbabbaaababaaababa
bbaaabbbbababbababaababb
aaabbabababaaabaabbabaab
bbabbaaaabbbaabbaaabbbbbbbbabaabbbbbabbbbabbaabaabbaababaaabaabb
babbabbabbbbababaaaaabaababbbabbaabaabbbabaaaabb
bbabbaababababbabaaababb
babaaabaaabababbaabababbabbababaabbaaabbbababaaaababbbbbaaaabbbbabbbbaaa
aaabaabaaabbbaabbbabbbbbbbababba
aabaababbbaaaababbabaaaa
aaaabaaabbabababbabbbaab
baaabaabbaaaababbbaabaaaaabbabaaabaaabaabbbbbabbbabaabababaabbaaabbaaababbabbbbb
aabaabbbababbbababaababaabbbaaaa
aabaabbaaaabaabaabaaaaaabababbaababaaabbabbbbabbbaaaaaaabababbabbbbbabaa
baaabbbaaaaaabbbbbaaaaabbabbaabaaaaabbba
baaabaaaabbbbaaaaabbaababbabbababaaaabbbbabbaaabaabbbaabbaaaabbb
baaabbbabaabbabaabbabaaabaaabbbaabbaaabbabaaabab
abbaaabbaaabbabbabaaabba
aaaaaaabbabbbabababbbaaaababaabbabbaaabaabbaabab
aabababaaabbaabbbbaabbbababbaaaa
aabbbabaaabaabbbbbbabaabababbbbb
bbbababbbabbbbbbbabaaabaaaabbabaaabbbbabbabababaaabaaaaa
abaabbaabbbabaabbabaaabbaaabbaaaaabbaaabbaaabbbbbabbaabb
abbbbbabaabaabababababbaaabababbaabbbababbaabaaa
aaabbaabaabaaaabbbbabbbbbabaababaaaaabab
aabbbaabbbbbababaabbbbbbaababbbb
bbababbbaabaaaabbaaaaabbbaababaabbaabaab
aabaababaabbbbbbbabbbbab
aaaaabaababbbabbabbbaabbbbabbaaa
baaaabababbbabbbbaaababbbbbababaaaaaaabb
baaaabaabaaabbaaabbbbbbaabaabbaabbbbbbabbbbbbbbbbabaabababbbbabbaababbbb
bababbabaaabaaaaaaababbbbbabbbaabaaabbbb
bbbbbbbabbabaaabaaaaaaabaabaaabaaaaaaaaababbaaabbaabbaaababaaabbabaaaaaa
abbaaababbbabaabbaaabbab
aabaabbbabaaaababaaabbbabaaaabbbbabbbababbbbabaaaaaababbaaabaabbbbbaabababbaabbb
abaaabaabbabaabbaabbaabaababaaaa
babbabaabaaaaababaaaabba
bbabbbbaaabbbabaaaaabbbb
abbabababbabbbbbaaabaaabaaaaabbaabbabbababbaabbaaabbbabbabbaabbbaabbabaaabaabbab
baabaaabbbbbaabbbaaababa
bbaaabbabbbbabbabbaabbaabaaaaabbabaabbba
babbbabaaabbbaaababababb
abaabbbbbbbbbababaaabbbabbababaaabaaaabababaaaab
bbbbbabbbabbbbbababbabaaabbbaabbbbabbbbbabbabababababaabaaabaaabbaaabaaaaaabbaaa
bababababbbbbbaaaabbbbaabbaaabaababbbbaaabbabbab
ababbaabababaababbbbbabbbbabbababaaabbbabaaaabbbaaaaaaba
abaabababbbbabbbbabbaaab
bbaaaaaaabbababaabbbababbabbbabbbaabaaaabbabbaba
abbbaabbabbabaabbbbbbbaabaaaaabbbbaaaabbbbbbabba
aabbbbbbaaabbaabaababbbababbabaaaaabbaaa
abaabbaaaabababbabbabbabbbaaaaab
babbbababbbbbbbababaaaaa
baabbbbbaabbbaabbabbababbbbbbbbb
bbaaabbbbbbabaabaaaaabaa
bbababaaabbabbabbabbbaaabbabbbab
bbbbabbababbababaababbaa
bbababaabbabaabaabbaabab
aabbbaabbbbaababbabababa
ababaaababbbbaaaabbbbaaaaaababbb
baaaababbbaabaaabbabbbabaababbabbaaaaaaabbaaaaaa
abbbababbaababbbbbaabbbbababbbaabaaababaabaababbbabbbbab
bbabaaabbaabbaaabbbaaabaaaaabbabbaaaabaaabbbbabbbaabbbbbabbabaababaaaaab
bbbbabbabbbbbbaaaaaabbbbabaabababbabbbbbbabaabbaaabbbbbbbbbbaaaa
baababaaaaabbbaaabaabbba
bbbbababbbabbaabbbabaaababbaaaababababaa
aaaaaaaaaaaaaababaaababbabbbabaa
aaabbabababbbaaabaabbbbbababbbbaaabbbabb
aabaaaabbbbbaaaaababbaabaaabbbbabbaaaaaabbababbbaababaaabaabbaabbabaaaaa
aaaabaaabbaabbaaaabbabba
bbbbaaabbaababaaababbabb
abbbbababbbbabbbbbbbababbaabbbbbaaabaabaabababbabaaabaaa
baabbabaabbbaababbabbaba
bbbbaabbbabbabaaaabaaaaababbaababaaabaabbbaaabaaaaababab
abbbbbbababbabbbbaababababbabbabababbbbb
aaabbbabbbbaaaaaabbbabaababababb
aabbaaabaaabaaabbbaaabaaaabbaaaaaaabababbbaabaab
babaababbaabaaaababaaaaa
aaabbbaaaabaabbbaaabbbbb
abaabaabbaabbabaaaabbbbaaabbbbabaabbbabb
baaababbabaaababaaababbababbbbba
aabbaaaabbabaabbbabaaabaaaaaaaabbbbaaaaa
bbbabbbbaabbbbaabbbaaaabbbbaaabb
abaaabababbabababbaabbbabaaabaaaaaaaaaabaabbbaaaaabbbbbbabbabbaaabaaaaaa
bbbbbbbabbabbaabbabbbaaabaabbaaa
bababbabbaabaabbaaabbbbabaabbbbaaabaaabb
bbbbbababaaaaabbabbbbbbabaaaabab
babbabaabbbbaaabaaabbbbaababaabbaabbaabb
ababaabbbbbaaababaabbaaaabbabbbbaaabbaaa
ababbaabbbbbbaaaaaabbbbb
babbabaababbabbabaabbbab
bbaabbaabbbbaabbabbbbbbaabbbaabaaaababbbbaaabbbbbaabbaaa
aabaabbbbabbbbbbabbabbaaabaabababbbbbabbbbaabaaa
abbbbbbaaabbbbaaabbabbbb
aaaaaaaaababbbabaaabbaabababbbba
baaabbaabaaaabaaabaabaaabbaabbbbaaaaaaababaababb
ababbbaababbbbabbabaaaaabababbba
aaaaabaaaaabbbababaaabbbabbbabba
bbbabbbaaaaaaaaaaaabbbbb
abbbbbbabbabbabbabababaa
baaaaabaaaaabaaabbaabbba
baaaabbbaababbbaaaaaaabb
bbbabaabbabbabbbabaabbbbaabbaababaaabaaababaabbb
bbbabbaabbbaabbbbbbabbbabbababababbabbbb
baabaabbbbbaabbaaaababab
bbabbaabbababbabbbabaabbbabbbbbaaaabbabaabbbbbbbababbaba
babbabbaabbaaabbbbabbbbabaaaaaaabbbaaaaa
abaabbaabbbabbbaabbabaaaaababaaaaaaaabbb
aababbabbbabbaabbabaaabbabbabaabbbbaaababbabbaaabbaaaababbbaaabbbaabaabaabababaa
abbabababbaaabbbbaababbaabaabbbbbbbbbbaa
bbbabbbabbabbbbabaaabaaababaaababbbaababbbbabababbabbbabaaabaaaaaabaabbb
baaaaaababbabaabbbabaabaabbbbbabaaababab
baabaabababbbbbabbbbaabaaaaabbbb
baabbabaababbbabbabbbbab
bbbbaabbbbbaaaabbbbbaaaa
bbbbaababaabaaababbbbbaa
bbbbbabbaaabaababbbaaaababaaabba
ababbbabbbbaaaababaaaabbbbaabbbaaaaaababababbbbababbbbbaababbbabaaaaaaababaabbababbbaaaa
aabaababbbbbababbaabbbab
baaaaababbbababbababaaab
baabaabbaaabbaaaabaabbbabbabbbbababbbbab
abbbbbbababbbabaaabababbbbaabbbabbbbababaabaaabb
bbabbabbabbabababaaaabba
abbabbbabbbbbababaaabaaa
bbbbbaabbabbbbaaabaaaaaabbbabbabaabbbabbabbabaaaabaababbbbbaaabb
baaabbbaaabaabaababaabab
baabaababaaaaabaabaabbaababbbbbabaaabbababbaabab
bbabbbbabaaaabaaaabababbabbabaab
babbaababaaaaaabbbaabaab
abaabbabaaabbbabaaaaabbbbbabababbbbaabbabbbabbbbabaaaaab
ababbbabaababababaabaaaa
abaaabaaababbbabbaababaabaabbaab
aaabbbbabbbaabbabbabaabbbaabbbaa
aaabbbaaaabaabaaabbbbbbb
abbbbabbababaabbbbaababbaabaabbbabbbbabbababbbab
baabaabbbbaaaababbabaabbbbabbaaaabbbaaaaaaababaaaabaabbbbbaaaaabbbbaaaaaaaaabbababbabbba
abbaababbbaaaaabbaabbaaa
babbbbabbbaababaaaaaaaaaabbbbaabbbababbbabbaaaaabababbaabaabbaaaaabaabbbaaaaaaaaababbbbbabbaabaa
abbbabababbabaaaababaaaaababbbbaabaabbbababbaabb
abbaaabaaabbabaaababbaab
bbaabbbabaabbbbbabbabbbaaabbaaaabbaaabbbabbaabbababbbbababbaabab
abaaabbbbbabaababbabaaaa
bbababbbbbbababbaaaaaaabbabaaabb
bbbaabbbaabbbbaaabbabbaabaabaabbbababaaa
babbbaaaaabaabbbabbbbbaa
abaabbaabaabbbbbabbbaabbaaabbaaa
abbbaabaababbbabaaaaaaaabbbabbbabbbaabab
aaaabbaabbabbaabbbaababaabbabbbbabaaabbaabbbbbbbaababbbbbbaabbabaabbbaaabbaabbba
abababbabbabbabbbbabbbab
bbbababbaaaabaaabaabbbba
bbbbaababbbbbbabbbbbabbaababaabaaababaab
bbaaaaaaaabbbaaabaaabaab
babbbbbbbbbbbaaabbaaabbaaabbabbaaaabbaaa
abaabbabaaabaababbbaaabb
abaababaaaaaaabbbababaabaaaababaabbabaabababbbba
aaabbabaabaababaababbbba
bbaaaaaababaaababababaaa
abbabaaabaabaaabbabbaaba
abbabababbabaabbabbabababbbaaaaa
aabaaabaababbbaaababaaab
bbabbbbaabaaabbbabbaaaab
bbbbababbbbaaababbbaaaba
bbbbbbababbbbbbaaaaaabab
bbababbbabaaabaabaabbaaaabbbabbabbbbbbaaabbabbbb
baababbbaaabbbaaaabaabbbaabaaabb
abaabbabbaaaabababbaabbb
bbbabaababbbbbbabaabaaabbabbbbbbbbbaabaabbabbbaaabbababb
babbabbbbbbbbabbbaaaababbbbbbbbababababa
baabababaabbaabbaabbabba
baabaababaaaaabbbabaabbbababbbaaabbaaaba
bbbbabbbbaabbbababbbaabaabaabaaaaaaaabaaabbaaaaa
bbabababbaabbabaabbabbaabaababaabaaaabba
abbbbbbaaaaabbaabbbbbaabaabbabbbaabababaaaababbbbabbbbbabaaabbab
bbbbaaabaaaabaaaaabbbaab
aabbaabbaaaaaaaaabbbbababaabababbabbabbbbbbbababaaabaabb
bbabababbabbabbbbaaaabaaaabbaababbbaaaaaabbbaaaa
bbabbabbaaabababbabbbbababaabbabbbbabbbababbaaab
abaaaaaabbbaabaaaabbbbabbababaab
aabababbbabbabbabbaabaaa
ababbbaaaaabbabaaaabbabbaaaaaabb
baaaababbbaaaababbbbbabbbbbaaabaabbabaaabbbbbabaaaaaaaababbbababaabbbbbbaabbbbaa
baabbbbbbbbbaabaabbababb
bababbababaabbbbababaaab
baababbbbabbaabbabbabbaabababbabaaaabbbaabaabaaa
aabaabababaaaabaabababbbbaaabaaaabaaabab
abbaaaaababbabbabaaaabbbbaaaabba
babbbaaabaaaaabbbabbbbab
ababbbabbaabbabaabbbabba
abaabbabaaaabaabbaaabbbbbbbabbaaaaabaabb
bbbaabbaaabbbaabbaabaabaababbaab
ababbbaabbbbbbbabaababaaabbabbabaababaaabbbaaababaabbaab
bbbbbbbabbaaaaaaaaabbbababbbbbbb
aabaaababbabbabaaaaabaaabbabbaabaabbbbbbababaaaa
baabaaabaaabbbabbababbabababbaba
abbbabbbababbabbbbbbaaaababbabbbaaaaaaaaabbaabbabbaaaaabbbabaaaabababbbaaabbabbb
baabaaabbabbababbbbaabbaaaabbaabbbbbabbbabbbaaabbbbabaaa
abaaabbbabaabaaaabbbbbabaaabbbbabababbbbbabbbbabaabaaaaa
aaaaaaaaabaaaababbbaaabababababa
bbbbaabbbababaaaaaaaaaab
aaabaaaabaaaababbabbbbbbaaaabbababbbabaa
babaaababbbbbbbaabbbbabb
baaabbaaaabbbbaabbbababa
baababbbaababbbabbbaabbbbbbbabaaaabbaaab
baaaabaabaabaabbbababbababbbaabbaaabbaabbaaaabba
baabaababbbaabbbabbabababaaaaaaa
bbbababbaabbababaaaaabbb
bbbabaaaaaaaaaaabbbaabbbbabaabbaabaaabbbabbaabbbbabbbbab
aaaaaaabbaababaaaaabaaaababbbaab
abababbaababbbabaabbbbaaaaaabaaaabbaaaba
baababbaaabaabbbbbbaabbabbbbaabbaabbabaabbabbbabaabbabba
abaaabbbbabbbaaabbbbaabaabaabababbaaabbbaabbbbabbababbbabaabbaaabaaabaaa
aabaaabaababbaabbbbbbbabbaaaaabbaaaabbba
aabbabaaabbbbabababbbbbbbaaabbbabaabbaaababbbbabbbbabaaa
abaabbbbbbbbabbbabbaaaaabbaaaaaaabbabbbbabababaa
ababaabbbbbbabaaabbaabba
bbbbababaababaaaaaaabbaabaabaaaa
abbbababbbbbaaababaaaabb
aabbbbbbaababbbaababbbabbaabbabaabaababaaaabaaab
aabaababaaabbbaabbaababababbbaaaabababaa
abaabaabbabbbababbaaaabaabaaabaabaabaabbabbababbaaabaaababaaabba
baaaaabbbbbaaaabbbbbbabb
abbbababbbbbbbbaabbaaaaababbbabbabababbaabaababb
aabbaababbabbaabbbbbaabaaaabbabbababbaba
ababbbaababbbbbabbbabaaa
abaaabbbabababbaabaaabbb
abababbabbabbababbbaabbaababbbaaaabbaaab
abbbbabbbaabaabbbaaaabbbbaaabbbbbbbabbbaababbababbbabbab
bbbbbaabbbaababbabbbaaaababbbabaaaababaaabaabbaa
ababbbaababababaaabaabbbabaaabbbbaabababbabbbbbaababbaaa
baababaabbbabbbbaaabaabb
babaabbbbbaabbbbbbabbabaabbbaaaaabbaabbabbbbaabaabbabbbbbbabbbaa
baabbabaaabbbababbaaaaba
abbbbbabbaaabbbabbaabbaaaabbbbaaaabbabbabaabbbba
aaaaaaabbaaabbbaaaaabbab
baabbbbbbaaabbbbaabbabaaaababbabbbaababaaabbbbbaabaaaaaabaabaabababbbaaa
aabbaaaaabbabaaaabbbbbaa
bbbabaabbbaaaaaaaabbbabaababaaab
babbabaaaaabbbababaaaaaa
baabbabaabaaabbbaabaaaaa
aabbaababbababbbbababaabaabbbbba
abbbbabaaabaaababbbbbaaaaaabaaab
bbbabaabbbbbabbaaababaaa
bbbbbabaabbaaabaaaabbbaaabbbbbbabaabbbaaabbbbbbbbaabbaaa
bbbbaaaabaabaabbbbabbabbbbbbbabaaaaabaaabbabbbbbbaabbbabaaabaabb
bbbbbaaabbbbabaabbabbbbbbaabaaabbabbbbbaabbbabbaabbbbbaa
aaabbbabbabbabbbbabaaaaaabbbbbaaaaababaaaaaaabbaabbabababababaaabbbababaabbaaaabbaaabaaababbaabb
abbaaaaaabbababaaababababaaaaabbaaabbaaa
aaaabaaaaabbabaaaaaabbaa
bbbbbbbabaababbbbbbbaaaabbbbbaab
ababaaaababbabbabbbababaabbaaabbabbbbbbbaabbababbbabbaba
bbbbbbbaaaaaababbaabbaaaaaababbbabaaabab
baabbbaaaaabbbbabbababbaaaaababaabbababaaaabbbbbbbbaaaababbbbbaababaaabb
bbbabbbaaabbbaabaaababbaaaabbaaa
baabaababbbbbaaabbbbabaaaabbabbaaaabaabb
abbbaabbabbabbabbbbaabbbbbabbbab
babbabaaabbabbbabaababaabbabaaba
baababbbbaaaabaaabbbaabbbbbaaaaa
bbaababbaaabbbbabbbabaaa
babababaaabbababbbbbabbbbbbababbabbbabbaaabbabbbabbaaaabbabbbabbaabbaaba
bbbbaaaabaaaaaaabbaaabaabaaaababaabaababbbbabababbabbbbaabbaaaabbbbaaababbbabbababaababb
babaaabbaabaaabbbabbbaabaaaabbbaaaaaabababababbabbababba
aaaabaaabbabaaabaabbbaaabbbbabaa
abbababaabaabbaabbbababbbbabbbbbaabbaaaaaaaabbabaaababbbbbabbbaa
aababbbababbabaabbbbabbaaabaaababbbbabababaaabaaaababaaaaabbaaab
ababbbaaaababbbaabbbbabaabaaabaabbbaabbaabbbbbaabbbaaaaabaabbabb
bbbabbaabaabababaabbababaababaaa
aaaaaaabbbbbbbabbabaabaa
abaabaaaaabbaaaabbbbaabaaabaabaabbbaabaa
aabbabaabaaabbaaaaaabbbb
abbabbaabaabababaabbbaabbbbbaababbbbabbbabbbaaab
abbaaabbabaaaabaaaaaabaaaababbbbbaabaaabaaabaabbbbabbabbbbbaaabababbabbabbbbbaaa
abaaabbbbabaaaaaabbaaababaaaaabaababbaababaabaaaabaaaaabbbaaaaab
aababababbbbbbbaabaabbabbbbbbaaaabbbaaaa
aabbaabaaabbaaaaaabaababaabbbbab
aabaaababbaaaaaabbababababaaaaabbababaab
baababaababbabbbabbaabaababbaabbaabaabbabbbbbaab
abaaabaaaaabbbaaabbababababbbabaaababaaa
aabaaababbbbbabbbaabbabb
aaabbabbaaabbbaabbbbbbababbababb
aabaaaabaabbbbaaaaaabaaabbaabbbaabbbbbbb
bbbbabaaaabbababbbabaaabbabaabba
baabaabaaabababababbabbbbbababaaaaababab
aabbbaaaaabbbbaaababbaaaababbbbaababaaaabbbabaab
abbaaabbbaabbbbabababbbabaabbbbaaabbabaabbaaaaba
aaaaaaabbbabaabbaabbbabaabbababaabbbbbbaabbbbaaaabababaaaaaabbbbaabbabba
abbbbabaabaabaabbbabbbbaabbbbabaabababbbbbaabbabbaabaaaa
abaabababbbbbabbbabaaaab
bababbabbbbabaaabbaaaabb
abbabaaabbbababbbbbaabbaaabbbbaababbaaba
bbbbaabaaabbbbbbabaabaaaaabaababbabbabbbabaaabab
babbabbbbbbabbaabbbabaabbbbbbbbb
babaabaaababbbbaabaabbbaababaaabbbabbbaaaaaaaaaabaababbbbaabbaaa
bbbbaabaabbabbaaabaabaaababababa
abbaababbbbabbabaabbbbbaababaaabaaabbbaaabaababbbbbaabaa
aabbaaaabbbbababaaaabbab
aabaababbabbbabaaabababaabaaabbaabaaaabb
bbabbabbbbaabbbbabaabaaaaaaaaaababaaabba
aaababbaabababaabababaaababaabaaabaaaabb
baaabbbabbaaaaabbaabbbab
bababaabbabbbababaaaababbabbaabbbbbaababbabbabbb
bbababaaabbbaabbaaabbbabaaabbbaabbbaaaaa
aabbbbaaabbbbbabaabaaababbaabbaaaabbbbbaabaaababbbbaabab
aaaaaaabaaaababbabababbaaababaabaabaaaaaabbaaaaaabaabbbaaaaabaaa
abaabbbbbbbabbaaaababbab
bbaaaaaaababaabbbaabaaabaababaaa
aabbbababaabababbabbbaab
abaabbbbbbaaaaaabbbbbbbabbbbabbbbabbaabb
aabbbbaabbababaabababbba
bababbabaaaabaaabaababaaaaaaaabb
bbbbaababbbabbaabbaabbaaabbbaabbbbabbaabaaaaaabb
bbbbabbabbbbaabaaaabaaaabaaaaabbaaabbbbaabaabbbaaabaaaaaabbaabbb
abbabaaabbaababbaabaaabbbbabbaabbbaabbbb
bbaaabbabbbbbababababaababaaaaaababaaaaaaabbbbab
aababbbaabbbbabaabbabaab
bbbaabbbaaaaabaabbaaaaab
bbabbabbbbaaabbbbbaaaaaababaabbaababbabbabaabbbabbaaaabb
aaabbabaaabaabbbbbaababbbaaaaaababbabaab
abbabbabbbaabbaabbaaabaa
abaabbabaaaabaaaaaaaabab
abbbbaabaabbabbbaabaaabbbaaaaaaa
abbabbaaaababbbabbabbababbaababaabbabaabbbbaaabb
aabaaaaabbbababbbaaababbabbbbababababaaabbabbbba
aaabbabababbbababbbaabbbbaabbbbaaababaaa
aabababbaaabaaaabbababaaaaaababb
abbaaaaaabababbaabaabaababbaaababaababbbaaaababbbabbaaabaabbabbaabbaabba
bbaaaabaaaabbaabbbaaaabaababbbbb
ababbbabbaababbbabaabaababbbababbbaabbaaabaababbabaaaaab
aabaaabaababaabaababaaaa
baabbbbbbaaaaabbbaabbbaa
abbabbabbabbabbbabbbbabaabbbabbb
ababbaabaabbababbbbababbbbbbabaabbabbbabbabbbbaa
bbbabaabbababbabbbabbbaa
aabaabbbaaabbababaabaaababababbbaabababbabaabbbabaaabaabbababbba
abaabaabababaababaabbabb
bbaabbbaaaabbbabaaababaa
bbbbabbbaabbaaaaabaaabba
baaaabbbbbbbaaabbaaaaabbabaabbabaabaabbbbaabbbabaababbaa
bbabaabbbaababbabbaabbaaaaabbbababaabbbaaaaabbab
babaaababbbabbbbabaabaaababaabbb
baaabbaabaaaabaaaaabaabaaaaabaaaaaabababababaaab
bbbbbabbbbaaaaaabaababbababbaaaaabbaabbb
abaaabbbabbbaabbbaaabaab
bbbabbaaaaabaabaaabababaaaabbbabbbbbabbbaababaab
bbbbabbbbaabbabbaabbbbbbabaaababbbbaaabaaaaabaabaabbaaab
baaaabbaaaaababbbbaaaaabbbbbbbaababbbabb
bbaabbbaababbaabbabbabababbbaababaabaaaa
bbbabbbbbaaaabbbabbbbbbaabaabbabbababaab
baababbbaabaabaabbaababaabaaabbbbbbababbbaaaabba
babbabababbbbbabababbbba
aabbbaaabbaaabbaabaaabab
bbbbbbbaabaaabaabbbbbabaabaababbabbabaab
bbaabbbbaaabbaababaaabbabababbbaaaabababbababaaaaabaaaab
babbbabaaabbabaaaabbbaabbabaabab
bbaaaabaaaaaaabbababbaaaababbbbbabaabaaababbabbbabbaaaaaaaaaababaaabbabbbbbbabaa
ababaabbaabbaaaabaaaaabbababbbba
baaaababbbbbaabbbaaabaaa
aababababbbaabbabbaabbbb
baababbaaaabbabbababbaba
babbabaabbbbbbbaaabbbabb
bbbbbbabbbbbbbabbbbbbabbabaaaabb
bbbaabbbbbbbbababababbbb
aabbaaaabbabbabbbbbaabaa
bbababababbbbaabaaabaababbbbaaabaaaabbab
ababbaabaabbbaababbbaababbabbabbaaabbababaabbaabababaaaaaabaaaaa
aabaababbabbbaaaabababbaaaaabbab
abbaaabbaabbaababbbabbbaababaaaa
aabaabaabbbbbabbaabbaabaaabaabaabaabaabbaaaabaaababbaabb
aabaaaabbbbbaaaabaaabbbbbbbbaaabababaaabababbaabbbaabaabaababbaabaaaabab
bbbabbabaaabaaaabababbaabaaabbbabbaabbba
bbaaaabababbbbaabaaabbaababbabbaaabbbababaaaabaaabbbbbbb
bbaabbaaaaaaabaaaaabbbbabbbbbabbbaabaabaaabbbabb
bbaabbbaabbaaaaaaaabaabababababbaabaaaaa
babbababbaabaababaababbabbbbbbabbbbbaabbbaabbbbbbabaabab
ababaabbaabbbaabaaaabbba
aaaabaaaabbabbbabbbbababbbaabbab
aaabaaaaaaabbabaaaaaabbb
bbbbabbaababbaabbbabbabbabaaaabbabaaabba
ababbaabbbabbbbbaaaabbba
abbbbabaaabbbaabbbbaaaabababaaaa
aaabaabaaabbbbbbaaabaababbabbabbbbbabbab
aaabaababaaaaaabbababbabbabaabbaabababbabaabaabaaaababbabbaabbaa
baaabbbabbabbaababbbaaab
aabbabababaabbabaaaaaaba
aabbbabaabbaaaaaaababbaa
bbbbbbabbaaaabaaabbabbabbaaaababbbababaa
aababababaaaaabbaaaaabaabbabbabbabbbabba
bbbbaaababbbbabaabbbaaaa
babababbbabababaabaabbabbbbbbbbbaaaabbaaaababababbabaaab
abaaabbbaabbbaabbbbaaaba
aabbaabbbabaaabaabbabaaabbbbbaba
bbbbaaabaaabaabaababbaabbbababbbabaaabbbabbaabaababaabababbbbabbbababbba
abaaabbbaabbaabbabbabbbabbbaaaaabaaabaabbbbbaabbaaabbbbaabababab
bbabbbbaaabbbabaababbbaaababaabb
aabababbbaabbabaaaaaabab
abaababaabbababaaabbaabbbbbaabbaaaaababa
aaabbbabaababbbabbbaaaabbabbbbaabaaabaaa

1728
input/2020/day20.txt
View File

File diff suppressed because it is too large Load Diff

38
input/2020/day21.txt
View File

@ -1,38 +0,0 @@
pblqsd tdtg rrzf rsbxb mml hgflmgp lsb lxvc mzxmthz mdhvtc sdpssq cdmln zmsn vfmsk slmjgj nvjql hjbq cxsvdm mfpgdr kndg chvtbb gstc hjjg bvqlhhd ggvzz tjlqrg mtnh rpxdc vxqg hvrqsz fqnzvb bkz kktl ppf tlrjcv dsjtkv txdmlzd zbsmv jssz npkdtv vlblq hlkb kpq fpjgdr lzkc lrcxf msfd ftx mptbpz rfdqzf nccr scjsx ncth fqqhkbm qvcr vvptj glf tlls qmnqtm tjlxs bnqbh vgpdr ftxzklk zpcj kqqmg fdzjc ckzc dcrnk cq bbfm xtgghn nnzm (contains soy, fish)
zpkv qvcr nvq xntsmjqf vqtqp tlls frng rmbn jssz bvqlhhd vsjpsl krlr mtnh fzrmkrdh txdmlzd cjfdvf ghjhv rkd ftxzklk dhlrh mptbpz mgtl tdv qjn gnvmv cq msfd zthtx prgck shc slssgt gn vxdrhp vgpdr fdzjc lrcxf cknhk tmt vlblq fhrc lvfph glf xbnmzr rrvq qmnqtm kvgctt pcjf tjlqrg ftx kktl cmgvvr ggzb stmnld rsbxb vvptj ctmf cdmln prhkvgbh cfvdq hgflmgp vpmfdct zntx (contains soy, eggs, wheat)
zrt rdtbcz krlr sdst mtdzn vqtqp slssgt dhlrh hghtp lzkc xtgghn qvcr sptc shc nvq mzmpqh ttpxk xzfd fqqhkbm ftx cxsvdm dfgjq cdmln dfdmj kktl lvfph fsxkvv cjfdvf ggvzz hlkb mzcpbs rzmtsz ckzc vfmsk rkd vjlpj bs rsbxb rrzf dmnxl mptbpz vpmfdct nnzm txrtjzx xbnmzr cxsmk tzlx tlrjcv glf mdhvtc gnvmv mchrgcrj pmznfk dkq ppf zpcj zcsmnq mgtl sdpssq mtnh ggzb zplxgb ftxzklk bftd zffkzcp zbblpvfb txdmlzd rfdqzf stbldpp rmxph xntsmjqf (contains dairy, eggs)
cvptv xhzkj glf tshxt rfdqzf vqtqp lrcxf pblqsd gblh bbfm chvtbb rsbxb mzxmthz zthtx fdzjc prgck cxsmk cjfdvf flcd ckzc vlblq sqmqz ppf rmbn vxgn mptbpz kll kqqmg cmgvvr tdkcd txdmlzd hgflmgp cxsvdm cdmln fhrc xbnmzr tdv vxqg dfdmj hvrqsz vvptj tjlqrg ncth hdbmkt zntx lvfph pcjf bftd dcrnk gn dhjrmdl (contains dairy)
vfmsk slmjgj cxsvdm nvq vlblq gnvmv cxsmk rl kpq dcrnk tgdk bhhmjbk qmnqtm fsxkvv bftd ggvzz cmgvvr fhrc zcsmnq vsjpsl xtgghn zthtx cjfdvf tlrjcv ftxzklk xbnmzr prgck zbblpvfb bkz frng zntx glf sfxd fdzjc fqnzvb ftx slssgt cknhk qtlnsrq lzkc thbx rrvq sptc xhzkj jzdzmg ggzb rsbxb mgdjxn kqqmg dmnxl mzmpqh dsjtkv fpjgdr txdmlzd mptbpz cfvdq (contains wheat)
nvq vlblq qvcr rkd rmbn ggzb xtgghn nvjql kslxsfnv mzmpqh fqqhkbm qnbf hgflmgp vxgn vgpdr sfxd cmgvvr zmsn tgdk ttpxk zcsmnq dmnxl stbldpp zpkv qtlnsrq klrnc vpmfdct nnzm tjlqrg pcjf pllr kll jssz ksfgf cxsmk rfdqzf prhkvgbh vvptj ncth nccr vjlpj flcd hjbq xjx cdmln slmjgj hghtp lsb xbnmzr zffkzcp tshxt cvptv ctmf lzkc ldl vfhkmn bkz slssgt txdmlzd mtnh sptc tdkcd dhjrmdl cxsvdm dhlrh rdtbcz lxvc vbsz bhhmjbk cq mptbpz rl vqtqp fdzjc glf zplxgb xzfd gnvmv xhzkj zbblpvfb tlls mgtl hvrqsz (contains peanuts, eggs, sesame)
msfd fqnzvb tjlqrg ksfgf gfkt zthtx dbds lxvc vgpdr glf zpcj xhzkj mptbpz rrzf krlr slmjgj cfvdq tlls rmxph mzcpbs dfgjq rfdqzf zmsn lrcxf tlrjcv thbx vzcgt lvfph dkq kslxsfnv tdkcd zcsmnq ttpxk kvff flcd mtnh hghtp kktl rmbn gn vlblq xntsmjqf prhkvgbh tjlxs pcjf hjbq bs kvgctt stmnld sn ctmf jgjx rhmpqn kcvgs rl cq vxdrhp pblqsd ggzb shc zntx rsbxb kqqmg cxsvdm txrtjzx hdbmkt dqldvn zbsmv kll txdmlzd jzdzmg klrnc mzmpqh zrt ldnvr nnzm prfjk (contains wheat, dairy)
kndg jzdzmg txdmlzd ldnvr vqtqp frng cxsvdm fsxkvv rhnd hglq gnvmv thbx bbfm shc zmsn sptc fqqhkbm qsvfj nkv lzkc pk ncth rhmpqn gdpdm bnqbh pcjf mchrgcrj dbds gn zthtx kpq stbldpp dqldvn rrzf mtnh zplxgb vlblq rsbxb mptbpz ncknc ccqpr ksfgf xbnmzr jgjx mzxmthz (contains peanuts, fish, dairy)
prgck bs kktl vjlpj rhnd gfkt rmxph vjrlml msfd zffkzcp mchrgcrj mptbpz cmgvvr zrt txrtjzx tjlxs kqqmg rdtbcz lzkc hjbq pblqsd sdst xntsmjqf hgflmgp bvqlhhd lsb sn txdmlzd kslxsfnv bkz vfmsk nnzm dhjrmdl sptc gblh vlblq hglq xhzkj rsbxb vsjpsl flcd kvgctt mgdjxn hghtp tjlqrg tdv tlls cxsvdm rfdqzf fqnzvb mtdzn kndg dsjtkv pvg sqmqz mzxmthz gnvmv vzcgt cq ggzb xbnmzr gstc rrvq dkq qmnqtm pmznfk krlr qtlnsrq vbsz lxvc pllr mtnh hdbmkt rl kffdz prfjk kvff jzdzmg qsvfj npkdtv rzmtsz (contains nuts, wheat, fish)
vxgn rhmpqn glf kqqmg fpjgdr ncknc tzlx kcvgs rl bftd tdtg hjjg xbnmzr rsbxb dhjrmdl xjx ksfgf tgdk jzdzmg dfgjq sn kpq vxdrhp qtlnsrq mchrgcrj krlr cxsvdm mptbpz vxqg cknhk jssz msfd cjfdvf tmt pblqsd ghjhv vfhkmn ttpxk ldnvr zdkxzm mzmpqh npkdtv vgpdr ggzb vjrlml zpkv bvqlhhd bqgjz vfmsk ggvzz tdv pllr vvptj scjsx txdmlzd nvq pcjf hghtp bhhmjbk kvff cq pmznfk pvg tjlxs vlblq ftx chvtbb lsb hgflmgp nxtvs (contains nuts)
kll flcd nccr tdkcd rpxdc ncth rrvq vlblq cdmln vfmsk krlr txrtjzx hrflzj cblbf tdv kndg mml fqnzvb shc slssgt qtlnsrq vxgn stbldpp ggzb gstc ncknc nxtvs vjlpj txdmlzd cxsvdm bs kvgctt hglq rfdqzf qnbf hvrqsz glf cknhk zntx msfd lrcxf rzsvmj zplxgb zpcj rhmpqn vzcgt xhzkj lsb kvff ghjhv hghtp mchrgcrj zbblpvfb sn qsvfj slmjgj ldl fsxkvv mdhvtc xjx vvptj pllr zbsmv kffdz dqldvn pmznfk frng pk sdpssq rsbxb vgpdr fqqhkbm rmbn bvqlhhd mzxmthz vsjpsl vbsz kqqmg tmt tlrjcv gdpdm xbnmzr mptbpz mgtl (contains nuts, peanuts, fish)
zpkv mtnh msfd zdkxzm zrt glv kll prhkvgbh rpxdc rfdqzf sn zffkzcp nvjql gblh gstc dhlrh hjbq kndg sqmqz mzmpqh bs vxqg rrzf kvff vbsz vgpdr cknhk sdpssq pcjf mzcpbs vlblq glf cmgvvr fqqhkbm shc stbldpp scjsx vzcgt lxvc lsb hghtp frng txdmlzd mptbpz rsbxb fpjgdr lvfph slmjgj ggzb xzfd cxsvdm tlls mzxmthz vxdrhp (contains sesame, soy)
kktl tjlqrg jssz rsbxb xzfd gfkt pblqsd tdv ncth dhjrmdl xtgghn pmznfk hjjg rfdqzf dfgjq mzxmthz mgtl bnqbh vxdrhp ppf ckzc lzkc mptbpz qtlnsrq gn prhkvgbh rdtbcz vjrlml qggdgf mtnh bhhmjbk kffdz fzrmkrdh glf vfhkmn pvg cmgvvr kll xbnmzr qmnqtm mtdzn kcvgs dkq dqldvn cxsvdm mml rmxph txdmlzd zpcj nkv vzcgt vbsz kndg nccr fqqhkbm hlkb nvq nnzm rzmtsz (contains eggs)
mptbpz glf chvtbb dkq xntsmjqf xjx bhhmjbk hgflmgp fpjgdr hvrqsz vfhkmn kndg vzcgt rhnd mgtl thbx rdtbcz rmxph zpkv pllr zbsmv nvjql xbnmzr tjlqrg pvg qggdgf fhrc bftd ckzc pmznfk cblbf mtdzn klrnc hglq kvff zntx mtnh dfgjq bnqbh txdmlzd ftx jgjx vfmsk slssgt frng vgpdr tgdk pblqsd lrcxf xhzkj kpq rl nvq dmnxl tlrjcv hdbmkt pk gnvmv tzlx cxsvdm rhmpqn cjfdvf lzkc qvcr mfpgdr mdhvtc rzsvmj hghtp tmt nxtvs vlblq tdkcd kvgctt ftxzklk vjlpj lvfph rzmtsz vqtqp slmjgj jzdzmg (contains dairy)
xjx xbnmzr prfjk mgdjxn glf hghtp cxsvdm vlblq mml sn qggdgf vjlpj frng vjrlml mzmpqh lrcxf rsbxb qmnqtm ckzc nccr rzmtsz hjjg hgflmgp stbldpp kvff cfvdq rhmpqn txdmlzd prhkvgbh hjbq prgck gnvmv fqqhkbm qjn stmnld slssgt kslxsfnv mgtl cmgvvr rl tzlx mfpgdr tlls zpkv ttpxk mptbpz ldl dbds kndg vsjpsl vpmfdct kqqmg qnbf mchrgcrj bs bkz flcd ncth ftxzklk cvptv tjlqrg bhhmjbk xhzkj vxgn cxsmk sfxd lsb qvcr zrt nkv sqmqz scjsx (contains dairy, peanuts, wheat)
mdhvtc tdkcd vlblq xtgghn cfvdq prgck nkv zcsmnq kvff rrzf cq rzsvmj hglq gnvmv mptbpz dcrnk pk nvq hlkb sqmqz xhzkj krlr prfjk tlrjcv cblbf kktl klrnc rpxdc cdmln ldl nccr glv lvfph mtnh kndg vfhkmn dkq ccqpr lzkc rsbxb rdtbcz hgflmgp vjrlml xjx dhlrh glf sdpssq bnqbh cxsvdm dmnxl stbldpp xbnmzr cknhk cmgvvr zthtx (contains sesame)
hglq nccr mzcpbs tlrjcv slssgt npkdtv ccqpr fdzjc vpmfdct vvptj dhjrmdl tjlqrg ldl ncth mzmpqh fqnzvb flcd fsxkvv glf ctmf rmbn bnqbh rsbxb pcjf dkq dhlrh txrtjzx cxsvdm rl lxvc ttpxk prhkvgbh kvff zrt ggvzz mptbpz klrnc bqgjz msfd rdtbcz fhrc gfkt qmnqtm tlls mchrgcrj kqqmg zbsmv hjjg dfgjq xbnmzr kndg kpq gn zbblpvfb mgtl sqmqz shc sptc zcsmnq ckzc ghjhv mzxmthz qnbf ftx glv qsvfj dqldvn mtnh rmxph xzfd rfdqzf txdmlzd gblh xtgghn ppf nvjql bvqlhhd kktl lsb cblbf tzlx vgpdr krlr (contains peanuts)
ncth kcvgs sptc cxsvdm fqnzvb mgdjxn ftxzklk ckzc kktl ccqpr tlrjcv txrtjzx kqqmg qnbf bqgjz vzcgt hrflzj kvff slssgt rsbxb mgtl mfpgdr cfvdq scjsx cvptv tshxt bnqbh cblbf glf jgjx xbnmzr vxdrhp xtgghn mzcpbs vjrlml dcrnk ksfgf fsxkvv fdzjc qvcr vbsz gnvmv txdmlzd rrvq npkdtv flcd frng rhmpqn gblh mptbpz vlblq tjlxs ldl (contains wheat, eggs)
tdkcd kktl cxsmk lrcxf rmxph tgdk vfhkmn dfgjq rzsvmj mptbpz flcd kffdz kcvgs bqgjz cvptv rrzf pllr klrnc kndg zffkzcp sdpssq rl pmznfk xbnmzr lxvc dsjtkv cknhk qnbf mtnh pcjf mtdzn sn tlrjcv kll qsvfj rsbxb krlr tdtg thbx vzcgt qjn tdv ktkbpp mzmpqh vgpdr vlblq ghjhv stbldpp bbfm dhjrmdl pblqsd rhmpqn fqnzvb fdzjc txdmlzd scjsx bhhmjbk gdpdm prgck ncknc bs chvtbb fhrc hghtp hjjg nvq cxsvdm ksfgf cjfdvf ncth (contains peanuts)
zpkv pmznfk qnbf shc dsjtkv zmsn fdzjc vlblq bs rhnd ttpxk mptbpz kndg mchrgcrj xhzkj txdmlzd cblbf nccr jssz xzfd flcd glv hghtp bbfm hdbmkt tdkcd kcvgs pblqsd vpmfdct gblh kktl mtnh pllr lzkc kvgctt hrflzj ldnvr ftx hlkb vbsz zbblpvfb dfgjq prgck qmnqtm nxtvs ggvzz ldl xbnmzr ftxzklk mfpgdr gnvmv stmnld zntx xjx glf vqtqp frng sdpssq vxdrhp kffdz hglq msfd vzcgt rsbxb cfvdq tzlx rzmtsz kqqmg gn rmbn (contains peanuts, sesame, soy)
bvqlhhd klrnc ggzb mptbpz dsjtkv qggdgf nxtvs zthtx hrflzj ldl ncth sptc prfjk txdmlzd scjsx zntx zcsmnq shc lsb txrtjzx tlrjcv bqgjz mtnh ldnvr xbnmzr chvtbb gnvmv sqmqz hgflmgp fdzjc zpkv bbfm kktl qvcr vjlpj ftxzklk xntsmjqf prhkvgbh rsbxb vqtqp zrt dmnxl ncknc cxsmk ctmf vlblq glv mdhvtc cxsvdm (contains fish, sesame, peanuts)
bhhmjbk zplxgb zmsn mzmpqh cq gblh fdzjc pblqsd mtnh dfgjq kffdz jzdzmg vfhkmn mchrgcrj npkdtv pvg tlrjcv rhmpqn cmgvvr pcjf cfvdq lsb kvgctt vxqg tgdk nccr nvq glf gstc nkv txdmlzd qvcr vzcgt txrtjzx ggzb nnzm sptc dsjtkv kslxsfnv zntx dhlrh jgjx vlblq prgck mptbpz thbx ghjhv gfkt lzkc jssz gdpdm rmbn rrvq fqnzvb xbnmzr pmznfk cblbf dbds stmnld mfpgdr kndg slssgt hglq rmxph bvqlhhd ncknc qmnqtm prhkvgbh cxsvdm xtgghn vqtqp rdtbcz pllr qsvfj kqqmg rpxdc hjbq (contains nuts, sesame, soy)
fhrc kktl fqqhkbm vjlpj zmsn qvcr zffkzcp qggdgf dbds rfdqzf sdpssq zcsmnq kll kvgctt zthtx cjfdvf cxsvdm ksfgf hghtp glf scjsx vfmsk fzrmkrdh bbfm kslxsfnv mtnh gstc rsbxb mptbpz rzmtsz hjbq qnbf vgpdr vzcgt dhjrmdl ggzb ldnvr vsjpsl txdmlzd vlblq ldl shc mzxmthz ncth kffdz mtdzn bnqbh pvg rdtbcz glv rrzf ghjhv gdpdm zbsmv bftd (contains peanuts, wheat)
xtgghn gnvmv mzxmthz vqtqp rsbxb slssgt zdkxzm rmxph prgck dcrnk txdmlzd kslxsfnv fzrmkrdh zrt vjrlml qtlnsrq dfdmj glf npkdtv lsb pllr tdtg bhhmjbk shc fhrc cblbf mptbpz bftd vbsz vlblq prfjk rkd nkv zffkzcp fpjgdr vxdrhp ldl mzmpqh rhmpqn hglq bs rhnd rl cfvdq xbnmzr jssz kll ncth mdhvtc zpcj tmt ncknc hjjg gstc pblqsd bqgjz mtnh flcd (contains peanuts, nuts)
gstc gdpdm rmbn sfxd mfpgdr tdv txdmlzd zntx ghjhv cdmln kcvgs pk xbnmzr nvq ncknc tdtg fpjgdr pmznfk stbldpp cknhk xtgghn tdkcd thbx jgjx hvrqsz zbblpvfb qsvfj gn frng glf sdpssq sqmqz rfdqzf txrtjzx rl ksfgf hjbq rsbxb dsjtkv tjlqrg kndg vlblq hglq ldl vxdrhp ggvzz cxsvdm ldnvr qggdgf vfmsk sdst ttpxk mtnh dqldvn (contains peanuts)
mzmpqh msfd qsvfj lxvc txdmlzd sfxd gstc cdmln bhhmjbk cxsmk xtgghn mtnh rfdqzf dbds ftxzklk zffkzcp mzxmthz vfmsk dmnxl zcsmnq mfpgdr rl mzcpbs rzsvmj bnqbh mgtl tdkcd dqldvn qmnqtm vsjpsl hvrqsz fhrc stmnld rmbn hlkb tzlx vjlpj glf cxsvdm txrtjzx mdhvtc fpjgdr nxtvs krlr bqgjz xbnmzr fsxkvv vvptj gn rzmtsz zmsn jssz pllr vlblq lrcxf nccr gfkt jgjx vgpdr qggdgf ccqpr sn kll zpcj dhlrh slssgt zbblpvfb tjlqrg mptbpz hgflmgp nnzm rhnd mtdzn flcd cknhk tlls nvjql pcjf jzdzmg (contains nuts, sesame, wheat)
cvptv ctmf glf tlrjcv ktkbpp zpcj vxdrhp cxsmk lsb ghjhv tzlx prfjk bftd rsbxb rpxdc dbds qtlnsrq dqldvn nvjql rhnd xbnmzr nnzm cxsvdm vbsz cfvdq cblbf txdmlzd dkq tdv mptbpz stmnld rrzf kcvgs qjn gfkt slssgt hlkb zpkv slmjgj prhkvgbh hgflmgp fhrc hvrqsz jssz vzcgt ftxzklk hjbq xntsmjqf tlls rmxph zcsmnq cmgvvr rhmpqn ldl dcrnk qggdgf mzmpqh sn vlblq thbx klrnc qnbf rzmtsz fdzjc bs ggzb gblh nvq mgtl pk jgjx dfgjq (contains wheat)
nxtvs sfxd sqmqz chvtbb ctmf cxsmk ccqpr zpkv frng xbnmzr rrvq rzsvmj fdzjc kcvgs gfkt zdkxzm ppf bhhmjbk scjsx qggdgf xntsmjqf vjrlml ftx nccr kktl zrt cjfdvf vlblq bvqlhhd bs lsb pllr fzrmkrdh mptbpz sdpssq thbx txdmlzd vxqg vjlpj rrzf kslxsfnv cxsvdm zmsn nkv ldnvr mtnh zbblpvfb dfgjq rl mzxmthz hdbmkt rhmpqn dsjtkv prhkvgbh tjlqrg dqldvn lxvc vxgn rsbxb gnvmv xzfd mml cknhk tmt mdhvtc jzdzmg tdkcd vfhkmn pcjf kqqmg vpmfdct (contains sesame, peanuts)
kcvgs ldnvr dhlrh fsxkvv tlls vjlpj gfkt gnvmv hgflmgp tgdk nnzm sdst vlblq dhjrmdl tdkcd sfxd cfvdq xzfd fqqhkbm ghjhv txdmlzd ggzb sptc mgdjxn zpcj cxsvdm rl rkd cjfdvf mtnh vxgn bbfm xbnmzr zntx ctmf dqldvn jssz cdmln cq rsbxb hghtp ppf sdpssq mchrgcrj lvfph fqnzvb hrflzj sn zbsmv nvjql zcsmnq mptbpz (contains peanuts, fish, wheat)
tjlqrg stbldpp tlls nvjql vqtqp lsb zntx bnqbh msfd kll klrnc ktkbpp npkdtv fqnzvb cxsvdm ftxzklk sdpssq thbx mtnh fqqhkbm dsjtkv dfgjq vvptj txdmlzd xntsmjqf bftd xjx dcrnk fpjgdr rdtbcz txrtjzx lxvc hrflzj zpkv krlr rsbxb xhzkj zdkxzm vlblq qsvfj mfpgdr zmsn ggzb kpq qtlnsrq rzsvmj hglq sqmqz gdpdm rkd gblh prfjk glf jgjx pk xbnmzr lvfph kndg dkq vxdrhp (contains peanuts)
zffkzcp vjrlml mfpgdr lvfph sqmqz sptc jgjx msfd hvrqsz lzkc rdtbcz cjfdvf sdst zpcj ghjhv bkz ncth sn ckzc tjlxs fsxkvv ncknc bvqlhhd hjjg kffdz mdhvtc vxdrhp ccqpr tdv glf dsjtkv hgflmgp rfdqzf ttpxk xbnmzr ktkbpp rsbxb vfhkmn stmnld ftxzklk vlblq dhjrmdl pblqsd gdpdm fqqhkbm ftx ksfgf nccr vzcgt mzmpqh nkv nnzm lxvc glv rkd txdmlzd hrflzj vjlpj xtgghn ldnvr qtlnsrq nxtvs zdkxzm dhlrh jssz cxsvdm jzdzmg ppf mzcpbs bftd dfdmj hglq cvptv dmnxl mptbpz zntx xntsmjqf (contains fish, nuts, sesame)
qnbf tdtg pblqsd tmt gblh ftx qtlnsrq bftd mgtl mzmpqh xbnmzr rpxdc sdst krlr mchrgcrj rsbxb vxdrhp bs ctmf sdpssq glv ggvzz mtnh ppf glf dfdmj dkq nvq dhlrh tlrjcv pmznfk dfgjq gstc mzxmthz zbsmv vxgn fqqhkbm rhmpqn hrflzj lrcxf vvptj vfmsk rhnd slmjgj gnvmv kslxsfnv flcd scjsx rrvq lzkc mfpgdr bhhmjbk pcjf zntx txdmlzd hjbq cjfdvf frng lsb qmnqtm mzcpbs ccqpr cxsvdm mptbpz rdtbcz rrzf nvjql vgpdr (contains wheat, dairy)
ttpxk dqldvn xtgghn stbldpp tzlx qggdgf qvcr pvg xbnmzr zbsmv zpkv kslxsfnv rmxph vjlpj gdpdm sfxd hghtp vxqg vlblq ktkbpp jgjx klrnc stmnld ftxzklk hvrqsz slssgt cq gnvmv glf kll vqtqp rfdqzf dcrnk zcsmnq bbfm ldl flcd gstc cxsvdm vsjpsl prgck mchrgcrj nvjql hdbmkt sptc mtdzn frng ldnvr nccr dkq fzrmkrdh vgpdr kktl cdmln rsbxb tshxt mtnh kcvgs mptbpz lzkc nnzm rrzf ftx (contains eggs, soy, sesame)
ccqpr tzlx zpcj mptbpz cjfdvf bkz zrt rdtbcz tmt cxsmk pvg fdzjc lxvc vlblq hvrqsz dhjrmdl msfd dcrnk ttpxk tdtg ftxzklk rsbxb mtnh cxsvdm vbsz fqnzvb xntsmjqf xjx shc dbds qnbf dkq txrtjzx zcsmnq prfjk glf sdpssq nnzm cmgvvr cblbf flcd lsb xhzkj cfvdq lzkc vjrlml rmbn frng gdpdm bs tlls ghjhv nvjql rrzf kktl txdmlzd hjjg zpkv zntx hgflmgp ggvzz dhlrh jzdzmg (contains fish, peanuts, soy)
kqqmg rfdqzf dfgjq cxsvdm glf sn mzcpbs ktkbpp vxqg mzmpqh ttpxk mzxmthz rsbxb tzlx zplxgb dcrnk zbsmv fdzjc dsjtkv sdpssq kvgctt xhzkj stmnld bnqbh bqgjz tdv stbldpp rhmpqn cq lxvc klrnc mtnh hjjg rkd vlblq gnvmv lsb cdmln dhjrmdl qtlnsrq vjrlml scjsx txdmlzd lzkc mfpgdr dkq tlrjcv xjx chvtbb ghjhv ppf cfvdq kcvgs xzfd kndg nnzm jzdzmg hdbmkt gdpdm kpq rzsvmj mgtl cjfdvf qmnqtm gstc dqldvn qsvfj vfhkmn rrzf zthtx cxsmk mtdzn xbnmzr qjn rmbn hvrqsz bhhmjbk dhlrh ldl flcd vjlpj fsxkvv (contains nuts, fish)
tlrjcv cxsvdm nccr vsjpsl vfhkmn vlblq xbnmzr prgck frng bhhmjbk zplxgb thbx jssz tdtg lrcxf pvg cjfdvf dmnxl vvptj stbldpp mtnh txrtjzx xzfd zpcj cmgvvr flcd bs qsvfj ggzb gdpdm zdkxzm rpxdc rhmpqn sdst rhnd ftxzklk nnzm fdzjc kndg vjrlml qmnqtm ldl cq cfvdq ttpxk tgdk xhzkj bnqbh fpjgdr lzkc vjlpj ggvzz glf prhkvgbh txdmlzd vxqg mfpgdr mzmpqh tjlqrg kqqmg cxsmk gfkt kvgctt kll mptbpz fqqhkbm xntsmjqf cvptv ftx zbblpvfb xjx qggdgf bqgjz chvtbb (contains soy, dairy, sesame)
cxsvdm zplxgb mtnh vfmsk ckzc hdbmkt tshxt dmnxl zpcj mtdzn nkv glv vzcgt txdmlzd vxdrhp rsbxb krlr zbblpvfb tdtg ccqpr lvfph nccr sdpssq qtlnsrq prhkvgbh klrnc rhnd mdhvtc bkz vgpdr dsjtkv tlrjcv cfvdq pmznfk dkq vlblq tzlx glf rl rzmtsz ttpxk kvgctt chvtbb nnzm scjsx mptbpz tdkcd xjx jzdzmg zffkzcp npkdtv cdmln tdv bs nvq prgck sptc gn ftx (contains soy)
ccqpr slssgt gfkt rzmtsz xtgghn prfjk cxsmk xbnmzr ghjhv gnvmv dsjtkv jgjx pllr bvqlhhd hlkb pcjf vfhkmn cq vsjpsl mtnh nvjql stbldpp mml mchrgcrj pvg dfgjq sdpssq shc fqqhkbm tdkcd sqmqz ldl mptbpz scjsx mfpgdr lzkc vlblq hdbmkt glf slmjgj thbx ksfgf dmnxl gn cjfdvf dbds tjlxs mtdzn xhzkj tdtg nxtvs zmsn ggzb xntsmjqf tgdk kslxsfnv zthtx vxgn zbblpvfb tjlqrg xzfd dkq cxsvdm rsbxb bkz vqtqp mzcpbs (contains eggs, soy, dairy)

53
input/2020/day22.txt
View File

@ -1,53 +0,0 @@
Player 1:
10
21
37
2
47
13
6
29
9
3
4
48
46
25
44
41
23
20
24
12
45
43
5
27
50
Player 2:
39
42
31
36
7
1
49
19
40
35
8
11
18
30
14
17
15
34
26
33
32
38
28
16
22

222
src/day16.rs
View File

@ -1,11 +1,15 @@
use crate::split_once;
use aoc_runner_derive::aoc;
use std::ops::RangeInclusive;
fn split_once<'a>(input: &'a str, delimeter: &str) -> Option<(&'a str, &'a str)> {
let idx = input.find(delimeter)?;
Some((&input[..idx], &input[idx + delimeter.len()..]))
}
struct Rule<'a> {
name: &'a str,
a: RangeInclusive<u16>,
b: RangeInclusive<u16>,
a: RangeInclusive<usize>,
b: RangeInclusive<usize>,
}
impl<'a> Rule<'a> {
fn parse(input: &'a str) -> Option<Self> {
@ -13,22 +17,22 @@ impl<'a> Rule<'a> {
let (a, b) = split_once(rem, " or ")?;
let a = {
let (start, end) = split_once(a, "-")?;
RangeInclusive::<u16>::new(start.parse().ok()?, end.parse().ok()?)
RangeInclusive::<usize>::new(start.parse().ok()?, end.parse().ok()?)
};
let b = {
let (start, end) = split_once(b, "-")?;
RangeInclusive::<u16>::new(start.parse().ok()?, end.parse().ok()?)
RangeInclusive::<usize>::new(start.parse().ok()?, end.parse().ok()?)
};
Some(Rule { name, a, b })
}
fn matches(&self, value: u16) -> bool {
fn matches(&self, value: usize) -> bool {
self.a.contains(&value) || self.b.contains(&value)
}
}
#[aoc(day16, part1)]
fn solve_d16_p1(input: &str) -> u16 {
fn solve_d16_p1(input: &str) -> usize {
let (rules, rem) = split_once(input, "\n\nyour ticket:\n").unwrap();
let (_your_ticket, nearby_tickets) = split_once(rem, "\n\nnearby tickets:\n").unwrap();
@ -37,7 +41,7 @@ fn solve_d16_p1(input: &str) -> u16 {
.split('\n')
.flat_map(|line| line.split(','))
.filter_map(|x| {
let value: u16 = x.parse().unwrap();
let value: usize = x.parse().unwrap();
if rules.iter().any(|rule| rule.matches(value)) {
None
} else {
@ -108,196 +112,18 @@ fn solve_d16_p2(input: &str) -> usize {
.product()
}
#[aoc(day16, part2, avx2)]
fn solve_d16_p2_avx2(input: &str) -> usize {
unsafe { avx2::solve_d16_p2(input) }
}
#[test]
fn test_foo() {
const INPUT: &str = "class: 0-1 or 4-19
row: 0-5 or 8-19
seat: 0-13 or 16-19
#[cfg(all(target_arch = "x86_64", target_feature = "avx2"))]
mod avx2 {
use super::{split_once, Rule};
use std::arch::x86_64::*;
your ticket:
11,12,13
struct RuleEval {
lo_start: [__m256i; 2],
lo_end: [__m256i; 2],
hi_start: [__m256i; 2],
hi_end: [__m256i; 2],
}
impl RuleEval {
#[target_feature(enable = "avx2")]
unsafe fn new(rules: &[Rule]) -> Option<Self> {
if rules.len() > 31 {
return None;
}
let lo_start = {
let mut lo_start = [_mm256_setzero_si256(); 2];
let lo_start_16 = &mut *(&mut lo_start as *mut [__m256i; 2] as *mut [i16; 32]);
let mut rules_iter = rules.iter();
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_start_16[idx] = *rule.a.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_start_16[idx + 16] = *rule.a.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_start_16[idx + 8] = *rule.a.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_start_16[idx + 24] = *rule.a.start() as i16 - 1;
}
lo_start
};
let lo_end = {
let mut lo_end = [_mm256_setzero_si256(); 2];
let lo_end_16 = &mut *(&mut lo_end as *mut [__m256i; 2] as *mut [i16; 32]);
let mut rules_iter = rules.iter();
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_end_16[idx] = *rule.a.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_end_16[idx + 16] = *rule.a.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_end_16[idx + 8] = *rule.a.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
lo_end_16[idx + 24] = *rule.a.end() as i16 + 1;
}
lo_end
};
let hi_start = {
let mut hi_start = [_mm256_setzero_si256(); 2];
let hi_start_16 = &mut *(&mut hi_start as *mut [__m256i; 2] as *mut [i16; 32]);
let mut rules_iter = rules.iter();
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_start_16[idx] = *rule.b.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_start_16[idx + 16] = *rule.b.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_start_16[idx + 8] = *rule.b.start() as i16 - 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_start_16[idx + 24] = *rule.b.start() as i16 - 1;
}
hi_start
};
let hi_end = {
let mut hi_end = [_mm256_setzero_si256(); 2];
let hi_end_16 = &mut *(&mut hi_end as *mut [__m256i; 2] as *mut [i16; 32]);
let mut rules_iter = rules.iter();
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_end_16[idx] = *rule.b.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_end_16[idx + 16] = *rule.b.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_end_16[idx + 8] = *rule.b.end() as i16 + 1;
}
for (idx, rule) in rules_iter.by_ref().take(8).enumerate() {
hi_end_16[idx + 24] = *rule.b.end() as i16 + 1;
}
hi_end
};
Some(RuleEval {
lo_start,
lo_end,
hi_start,
hi_end,
})
}
#[target_feature(enable = "avx2")]
unsafe fn eval(&self, value: u16) -> u32 {
let value = _mm256_set1_epi16(value as i16);
let within_lo = [
_mm256_and_si256(
_mm256_cmpgt_epi16(self.lo_end[0], value),
_mm256_cmpgt_epi16(value, self.lo_start[0]),
),
_mm256_and_si256(
_mm256_cmpgt_epi16(self.lo_end[1], value),
_mm256_cmpgt_epi16(value, self.lo_start[1]),
),
];
let within_hi = [
_mm256_and_si256(
_mm256_cmpgt_epi16(self.hi_end[0], value),
_mm256_cmpgt_epi16(value, self.hi_start[0]),
),
_mm256_and_si256(
_mm256_cmpgt_epi16(self.hi_end[1], value),
_mm256_cmpgt_epi16(value, self.hi_start[1]),
),
];
let valid = [
_mm256_or_si256(within_lo[0], within_hi[0]),
_mm256_or_si256(within_lo[1], within_hi[1]),
];
let packed = _mm256_packs_epi16(valid[0], valid[1]);
_mm256_movemask_epi8(packed) as u32
}
}
#[target_feature(enable = "avx2")]
pub unsafe fn solve_d16_p2(input: &str) -> usize {
let (rules, rem) = split_once(input, "\n\nyour ticket:\n").unwrap();
let (my_ticket, nearby_tickets) = split_once(rem, "\n\nnearby tickets:\n").unwrap();
let rules: Vec<_> = rules.split('\n').map(|x| Rule::parse(x).unwrap()).collect();
assert!(rules.len() < 32);
let rule_eval = RuleEval::new(&rules).unwrap();
let mut candidates = [_mm256_set1_epi32((1i32 << rules.len()) - 1); 4];
let mut scratch_space = [_mm256_set1_epi32(1); 4];
for line in nearby_tickets.split('\n') {
let scratch_slice = &mut *(&mut scratch_space as *mut _ as *mut [u32; 32]);
for (field, scratch) in line.split(',').zip(scratch_slice.iter_mut()) {
let field = field.parse().unwrap();
*scratch = rule_eval.eval(field);
}
if scratch_space.iter().copied().any(|elem| {
_mm256_movemask_epi8(_mm256_cmpeq_epi32(elem, _mm256_set1_epi32(0))) != 0
}) {
continue;
}
for (candidate, valid_bitmask) in candidates.iter_mut().zip(scratch_space.iter()) {
*candidate = _mm256_and_si256(*candidate, *valid_bitmask);
}
}
let candidates = &mut *(&mut candidates as *mut _ as *mut [u32; 32]);
let candidates = &mut candidates[..rules.len()];
while candidates.iter().copied().any(|x| x.count_ones() > 1) {
for idx in 0..candidates.len() {
let candidate = candidates[idx];
if candidate.count_ones() == 1 {
let mask = !candidate;
for before in &mut candidates[..idx] {
*before &= mask;
}
for after in &mut candidates[idx + 1..] {
*after &= mask;
}
}
}
}
my_ticket
.split(',')
.map(|x| x.parse::<usize>().unwrap())
.zip(candidates.into_iter().map(|x| x.trailing_zeros() as usize))
.filter_map(|(field, rule_idx)| {
if rules[rule_idx].name.starts_with("departure") {
Some(field)
} else {
None
}
})
.product()
}
nearby tickets:
3,9,18
15,1,5
5,14,9";
solve_d16_p2(INPUT);
}

101
src/day17.rs
View File

@ -1,101 +0,0 @@
use aoc_runner_derive::aoc;
use std::collections::HashSet;
#[aoc(day17, part1)]
fn solve_d17_p1(input: &str) -> usize {
let mut world = HashSet::new();
for (y, line) in input.split('\n').enumerate() {
for (x, _) in line
.as_bytes()
.iter()
.copied()
.enumerate()
.filter(|&(_, byte)| byte == b'#')
{
world.insert((x as isize, y as isize, 0isize, 0isize));
}
}
for _ in 0..6 {
world = step(world);
}
world.len()
}
fn neighbors(
world: &HashSet<(isize, isize, isize, isize)>,
(x, y, z, w): (isize, isize, isize, isize),
) -> usize {
let mut count = 0;
for xa in x - 1..=x + 1 {
for ya in y - 1..=y + 1 {
for za in z - 1..=z + 1 {
for wa in w - 1..=w + 1 {
count += world.contains(&(xa, ya, za, wa)) as usize;
}
}
}
}
count - world.contains(&(x, y, z, w)) as usize
}
fn step(world: HashSet<(isize, isize, isize, isize)>) -> HashSet<(isize, isize, isize, isize)> {
struct MinMax {
x_min: isize,
x_max: isize,
y_min: isize,
y_max: isize,
z_min: isize,
z_max: isize,
w_min: isize,
w_max: isize,
}
let MinMax {
x_min,
x_max,
y_min,
y_max,
z_min,
z_max,
w_min,
w_max,
} = world.iter().fold(
MinMax {
x_min: isize::MAX,
x_max: isize::MIN,
y_min: isize::MAX,
y_max: isize::MIN,
z_min: isize::MAX,
z_max: isize::MIN,
w_min: isize::MAX,
w_max: isize::MIN,
},
|minmax, &(x, y, z, w)| MinMax {
x_min: std::cmp::min(minmax.x_min, x),
x_max: std::cmp::max(minmax.x_max, x),
y_min: std::cmp::min(minmax.y_min, y),
y_max: std::cmp::max(minmax.y_max, y),
z_min: std::cmp::min(minmax.z_min, z),
z_max: std::cmp::max(minmax.z_max, z),
w_min: std::cmp::min(minmax.w_min, w),
w_max: std::cmp::max(minmax.w_max, w),
},
);
let mut new_world = HashSet::new();
for x in x_min - 1..=x_max + 1 {
for y in y_min - 1..=y_max + 1 {
for z in z_min - 1..=z_max + 1 {
for w in w_min - 1..=w_max + 1 {
let active = world.contains(&(x, y, z, w));
let n = neighbors(&world, (x, y, z, w));
if active && (n == 2 || n == 3) {
new_world.insert((x, y, z, w));
}
if !active && n == 3 {
new_world.insert((x, y, z, w));
}
}
}
}
}
new_world
}

164
src/day18.rs
View File

@ -1,164 +0,0 @@
use aoc_runner_derive::aoc;
fn num(i: &str) -> Option<(&str, usize)> {
let i = i.trim_start();
let end_idx = i
.as_bytes()
.iter()
.copied()
.position(|b| !(b'0'..=b'9').contains(&b))
.unwrap_or(i.len());
let n = (&i[..end_idx]).parse().ok()?;
let rem = &i[end_idx..];
Some((rem, n))
}
#[aoc(day18, part1)]
fn solve_d18_p1(input: &str) -> usize {
#[derive(Debug, Copy, Clone)]
enum Operator {
Add,
Mul,
}
// The next token is an operator '+' or '*'
fn operator(i: &str) -> Option<(&str, Operator)> {
let i = i.trim_start();
let op = match i.as_bytes()[0] {
b'+' => Operator::Add,
b'*' => Operator::Mul,
_ => return None,
};
Some((&i[1..], op))
}
// The next token is '('. Evaluate the entire expression within the parens.
fn paren(i: &str) -> Option<(&str, usize)> {
let i = i.trim_start();
if i.is_empty() || i.as_bytes()[0] != b'(' {
return None;
}
let (rem, n) = expr(&i[1..])?;
if rem.is_empty() || rem.as_bytes()[0] != b')' {
return None;
}
let rem = &rem[1..];
Some((rem, n))
}
// the next token is either a bare number or an expression within a paren,
// return either the number of the evaluation of the paren enclosed
// expression.
fn num_or_paren(i: &str) -> Option<(&str, usize)> {
num(i).or_else(|| paren(i))
}
// the next token is an operator ('+' or '*') followed by a number or an
// expression within a paren.
fn operator_and_rhs(i: &str) -> Option<(&str, (Operator, usize))> {
let (i, op) = operator(i)?;
let (i, rhs) = num_or_paren(i)?;
Some((i, (op, rhs)))
}
// evaluate the expression provided as input. Return the remaining input
// after evaluation is complete.
fn expr(i: &str) -> Option<(&str, usize)> {
let (mut rem, mut lhs) = num_or_paren(i)?;
loop {
if rem.is_empty() {
break;
}
if let Some((irem, (op, rhs))) = operator_and_rhs(rem) {
rem = irem;
lhs = match op {
Operator::Add => lhs + rhs,
Operator::Mul => lhs * rhs,
};
} else {
break;
}
}
Some((rem, lhs))
}
input.split('\n').map(|line| expr(line).unwrap().1).sum()
}
#[aoc(day18, part2)]
fn solve_d18_p2(input: &str) -> usize {
// The next token is '('. Evaluate the entire expression within the parens.
fn paren(i: &str) -> Option<(&str, usize)> {
let i = i.trim_start();
if i.is_empty() || i.as_bytes()[0] != b'(' {
return None;
}
let (rem, n) = expr(&i[1..])?;
if rem.is_empty() || rem.as_bytes()[0] != b')' {
return None;
}
let rem = &rem[1..];
Some((rem, n))
}
// the next token is either a bare number or an expression within a paren,
// return either the number of the evaluation of the paren enclosed
// expression.
fn num_or_paren(i: &str) -> Option<(&str, usize)> {
num(i).or_else(|| paren(i))
}
// The next token is a number or an expression within a paren, optionally
// followed by some number of '+' and number or paren enclosed expressions.
// The returned value is the sum of the entire sequence.
fn add_or_paren(i: &str) -> Option<(&str, usize)> {
let (mut i, mut lhs) = num_or_paren(i)?;
loop {
i = i.trim_start();
if i.is_empty() || i.as_bytes()[0] != b'+' {
break;
}
i = &i[1..];
if let Some((rem, rhs)) = num_or_paren(i) {
lhs += rhs;
i = rem;
} else {
break;
}
}
Some((i, lhs))
}
// Evaluate the expression.
fn expr(i: &str) -> Option<(&str, usize)> {
// add_or_paren will evaluate any consecutive elements of the expression
// that are separated by '+'. This enforces that '+' has a higher order
// of operation than '*'.
let (mut i, mut lhs) = add_or_paren(i)?;
loop {
// The next token is expected to be '*'. Remember that all '+'
// operations will have already been handled by add_or_paren above.
i = i.trim_start();
if i.is_empty() || i.as_bytes()[0] != b'*' {
break;
}
i = &i[1..];
// '*' has been seen, now get the rhs of the multiplication. Using
// add_or_paren here again will first sum all consecutive
// '+' tokens prior to doing the multiplication.
if let Some((rem, rhs)) = add_or_paren(i) {
lhs *= rhs;
i = rem;
} else {
break;
}
}
Some((i, lhs))
}
input.split('\n').map(|line| expr(line).unwrap().1).sum()
}

103
src/day19.rs
View File

@ -1,103 +0,0 @@
use crate::split_once;
use aoc_runner_derive::aoc;
use std::collections::HashMap;
#[derive(Debug)]
enum Parser<'a> {
Lit(&'a str),
Seq(Vec<usize>),
Alt(Vec<usize>, Vec<usize>),
}
impl<'a> Parser<'a> {
fn new(parser_def: &'a str) -> Option<(usize, Self)> {
let (idx, def) = split_once(parser_def, ": ")?;
let idx = idx.parse().ok()?;
if let Some((a, b)) = split_once(def, " | ") {
let a = a
.split(' ')
.map(|x| x.parse().ok())
.collect::<Option<Vec<usize>>>()?;
let b = b
.split(' ')
.map(|x| x.parse().ok())
.collect::<Option<Vec<usize>>>()?;
Some((idx, Parser::Alt(a, b)))
} else if let Some(_) = def.find('"') {
Some((idx, Parser::Lit(&def[1..def.len() - 1])))
} else {
let seq = def
.split(' ')
.map(|x| x.parse().ok())
.collect::<Option<Vec<usize>>>()?;
Some((idx, Parser::Seq(seq)))
}
}
// returns Some(remaining_input) when valid, None when doesn't match.
fn parse<'b>(&self, parsers: &HashMap<usize, Parser>, input: &'b str) -> Option<&'b str> {
match self {
&Parser::Lit(s) => {
if input.is_empty() || &input[..s.len()] != s {
None
} else {
Some(&input[s.len()..])
}
}
Parser::Seq(a) => {
let mut input = input;
let mut iter = a.iter().copied();
while let Some(parser_idx) = iter.next() {
input = parsers
.get(&parser_idx)
.and_then(|p| p.parse(parsers, input))?;
}
Some(input)
}
Parser::Alt(a, b) => {
let parser_a = Parser::Seq(a.clone());
match parser_a.parse(parsers, input) {
Some(input) => Some(input),
None => {
let parser_b = Parser::Seq(b.clone());
parser_b.parse(parsers, input)
}
}
}
}
}
}
#[aoc(day19, part1)]
fn solve_d19_p1(input: &str) -> usize {
let (parser_input, pattern_input) = split_once(input, "\n\n").unwrap();
let parsers: HashMap<usize, Parser> = parser_input
.split('\n')
.map(|parser_def| Parser::new(parser_def).unwrap())
.collect();
let rule0 = parsers.get(&0).unwrap();
pattern_input
.split('\n')
.filter(|pattern| rule0.parse(&parsers, pattern) == Some(""))
.count()
}
#[aoc(day19, part2)]
fn solve_d19_p2(input: &str) -> usize {
let (parser_input, pattern_input) = split_once(input, "\n\n").unwrap();
let mut parsers: HashMap<usize, Parser> = parser_input
.split('\n')
.map(|parser_def| Parser::new(parser_def).unwrap())
.collect();
parsers.insert(8, Parser::Alt(vec![42], vec![42, 8]));
parsers.insert(11, Parser::Alt(vec![42, 31], vec![42, 11, 31]));
let rule0 = parsers.get(&0).unwrap();
pattern_input
.split('\n')
.filter(|pattern| rule0.parse(&parsers, pattern) == Some(""))
.count()
}

220
src/day20.rs
View File

@ -1,220 +0,0 @@
use crate::split_once;
use aoc_runner_derive::aoc;
use std::collections::HashMap;
#[derive(Debug)]
struct Tile {
id: usize,
data: [bool; 100],
}
impl Tile {
fn parse(input: &str) -> Option<Tile> {
let (id_line, input_data) = split_once(input, ":\n")?;
let (_, id) = split_once(id_line, " ")?;
let mut data = [false; 100];
for idx in input_data
.as_bytes()
.iter()
.cloned()
.filter(|&b| b != b'\n')
.enumerate()
.filter_map(|(idx, b)| if b == b'#' { Some(idx) } else { None })
{
data[idx] = true;
}
Some(Tile {
id: id.parse().ok()?,
data,
})
}
fn sides(&self) -> Vec<u16> {
let top = self.data[0..10]
.iter()
.cloned()
.enumerate()
.filter(|&(_, b)| b)
.fold(0u16, |accum, (idx, _)| accum | (1 << idx));
let bottom = self.data[90..100]
.iter()
.cloned()
.enumerate()
.filter(|&(_, b)| b)
.fold(0u16, |accum, (idx, _)| accum | (1 << idx));
let left = self
.data
.iter()
.step_by(10)
.cloned()
.enumerate()
.filter(|&(_, b)| b)
.fold(0u16, |accum, (idx, _)| accum | (1 << idx));
let right = self
.data
.iter()
.skip(9)
.step_by(10)
.cloned()
.enumerate()
.filter(|&(_, b)| b)
.fold(0u16, |accum, (idx, _)| accum | (1 << idx));
// Put the id's in a consistent order.
fn consistent_id(id: u16) -> u16 {
let reversed = id.reverse_bits() >> 6;
if id < reversed {
reversed
} else {
id
}
}
vec![
consistent_id(top),
consistent_id(right),
consistent_id(bottom),
consistent_id(left),
]
}
}
const EXAMPLE: &str = "Tile 2311:
..##.#..#.
##..#.....
#...##..#.
####.#...#
##.##.###.
##...#.###
.#.#.#..##
..#....#..
###...#.#.
..###..###
Tile 1951:
#.##...##.
#.####...#
.....#..##
#...######
.##.#....#
.###.#####
###.##.##.
.###....#.
..#.#..#.#
#...##.#..
Tile 1171:
####...##.
#..##.#..#
##.#..#.#.
.###.####.
..###.####
.##....##.
.#...####.
#.##.####.
####..#...
.....##...
Tile 1427:
###.##.#..
.#..#.##..
.#.##.#..#
#.#.#.##.#
....#...##
...##..##.
...#.#####
.#.####.#.
..#..###.#
..##.#..#.
Tile 1489:
##.#.#....
..##...#..
.##..##...
..#...#...
#####...#.
#..#.#.#.#
...#.#.#..
##.#...##.
..##.##.##
###.##.#..
Tile 2473:
#....####.
#..#.##...
#.##..#...
######.#.#
.#...#.#.#
.#########
.###.#..#.
########.#
##...##.#.
..###.#.#.
Tile 2971:
..#.#....#
#...###...
#.#.###...
##.##..#..
.#####..##
.#..####.#
#..#.#..#.
..####.###
..#.#.###.
...#.#.#.#
Tile 2729:
...#.#.#.#
####.#....
..#.#.....
....#..#.#
.##..##.#.
.#.####...
####.#.#..
##.####...
##..#.##..
#.##...##.
Tile 3079:
#.#.#####.
.#..######
..#.......
######....
####.#..#.
.#...#.##.
#.#####.##
..#.###...
..#.......
..#.###...
";
#[aoc(day20, part1)]
fn solve_d20_p1(input: &str) -> usize {
let tiles: Vec<_> = input
.split("\n\n")
.map(|i| Tile::parse(i).unwrap())
.collect();
let mut side_to_tile: HashMap<_, Vec<_>> = HashMap::new();
for tile in &tiles {
for side in tile.sides() {
side_to_tile.entry(side).or_default().push(tile.id);
}
}
tiles
.iter()
.filter_map(|tile| {
let num_unique_sides = tile.sides().iter().fold(0, |accum, side| {
if side_to_tile.get(&side).unwrap().len() == 1 {
accum + 1
} else {
accum
}
});
if num_unique_sides == 2 {
Some(tile.id)
} else {
None
}
})
.product()
}

75
src/day21.rs
View File

@ -1,75 +0,0 @@
use crate::split_once;
use aoc_runner_derive::aoc;
use std::collections::{HashMap, HashSet};
#[derive(Debug)]
struct Food<'a> {
ingredients: HashSet<&'a str>,
allergens: HashSet<&'a str>,
}
impl<'a> Food<'a> {
fn parse(input: &'a str) -> Option<Self> {
let (ingredients, allergens) = split_once(input, " (contains ")?;
let allergens = allergens.strip_suffix(")")?;
Some(Food {
ingredients: ingredients.split(" ").collect(),
allergens: allergens.split(", ").collect(),
})
}
}
#[aoc(day21, part1)]
fn solve_d2_p1(input: &str) -> usize {
//let input = EXAMPLE;
let foods: Vec<_> = input.split('\n').map(|l| Food::parse(l).unwrap()).collect();
let mut allergen_causes = HashMap::new();
for food in &foods {
for &allergen in &food.allergens {
let ingredients = allergen_causes
.entry(allergen)
.or_insert_with(|| food.ingredients.clone());
ingredients.retain(|ingredient| food.ingredients.contains(ingredient));
}
}
let possible_allergens: HashSet<_> = allergen_causes.values().flatten().collect();
foods
.iter()
.flat_map(|food| &food.ingredients)
.filter(|ingredient| !possible_allergens.contains(ingredient))
.count()
}
#[aoc(day21, part2)]
fn solve_d2_p2(input: &str) -> String {
let foods: Vec<_> = input.split('\n').map(|l| Food::parse(l).unwrap()).collect();
let mut allergen_causes = HashMap::new();
for food in &foods {
for &allergen in &food.allergens {
let ingredients = allergen_causes
.entry(allergen)
.or_insert_with(|| food.ingredients.clone());
ingredients.retain(|ingredient| food.ingredients.contains(ingredient));
}
}
let mut dangerous_ingredients = Vec::new();
while let Some(&allergen) = allergen_causes
.iter()
.find(|(_k, v)| v.len() == 1)
.map(|(k, _v)| k)
{
let (allergen, mut ingredient) = allergen_causes.remove_entry(allergen).unwrap();
let ingredient = ingredient.drain().next().unwrap();
dangerous_ingredients.push((allergen, ingredient));
for ingredient_set in allergen_causes.values_mut() {
ingredient_set.remove(&ingredient);
}
}
dangerous_ingredients.sort_by(|(a, _), (b, _)| a.cmp(b));
dangerous_ingredients
.into_iter()
.map(|(_allergen, ingredient)| ingredient)
.collect::<Vec<_>>()
.join(",")
}

87
src/day22.rs
View File

@ -1,87 +0,0 @@
use crate::split_once;
use aoc_runner_derive::aoc;
use std::borrow::Cow;
use std::collections::{HashSet, VecDeque};
fn deck_score(deck: VecDeque<usize>) -> usize {
deck.iter()
.rev()
.enumerate()
.map(|(idx, value)| (idx + 1) * value)
.sum()
}
#[aoc(day22, part1)]
fn solve_d22_p1(input: &str) -> usize {
let (p1, p2) = split_once(input, "\n\n").unwrap();
let mut p1_deck: VecDeque<usize> = p1.split('\n').skip(1).map(|x| x.parse().unwrap()).collect();
let mut p2_deck: VecDeque<usize> = p2.split('\n').skip(1).map(|x| x.parse().unwrap()).collect();
while !p1_deck.is_empty() && !p2_deck.is_empty() {
let p1_value = p1_deck.pop_front().unwrap();
let p2_value = p2_deck.pop_front().unwrap();
if p1_value > p2_value {
p1_deck.push_back(p1_value);
p1_deck.push_back(p2_value);
} else {
p2_deck.push_back(p2_value);
p2_deck.push_back(p1_value);
}
}
deck_score(if p1_deck.is_empty() { p2_deck } else { p1_deck })
}
enum Winner {
Player1(VecDeque<usize>),
Player2(VecDeque<usize>),
}
#[aoc(day22, part2)]
fn solve_d22_p2(input: &str) -> usize {
let (p1, p2) = split_once(input, "\n\n").unwrap();
let p1_deck: VecDeque<usize> = p1.split('\n').skip(1).map(|x| x.parse().unwrap()).collect();
let p2_deck: VecDeque<usize> = p2.split('\n').skip(1).map(|x| x.parse().unwrap()).collect();
match play_recursive_combat(p1_deck, p2_deck) {
Winner::Player1(deck) | Winner::Player2(deck) => deck_score(deck),
}
}
fn play_recursive_combat(mut p1_deck: VecDeque<usize>, mut p2_deck: VecDeque<usize>) -> Winner {
let mut previous_rounds = HashSet::new();
while !p1_deck.is_empty() && !p2_deck.is_empty() {
if previous_rounds.contains(&(Cow::Borrowed(&p1_deck), Cow::Borrowed(&p2_deck))) {
return Winner::Player1(p1_deck);
}
previous_rounds.insert((Cow::Owned(p1_deck.clone()), Cow::Owned(p2_deck.clone())));
let p1_value = p1_deck.pop_front().unwrap();
let p2_value = p2_deck.pop_front().unwrap();
if p1_deck.len() >= p1_value && p2_deck.len() >= p2_value {
match play_recursive_combat(
p1_deck.iter().copied().take(p1_value).collect(),
p2_deck.iter().copied().take(p2_value).collect(),
) {
Winner::Player1(_) => {
p1_deck.push_back(p1_value);
p1_deck.push_back(p2_value);
}
Winner::Player2(_) => {
p2_deck.push_back(p2_value);
p2_deck.push_back(p1_value);
}
}
} else {
if p1_value > p2_value {
p1_deck.push_back(p1_value);
p1_deck.push_back(p2_value);
} else {
p2_deck.push_back(p2_value);
p2_deck.push_back(p1_value);
}
}
}
if p1_deck.is_empty() {
Winner::Player2(p2_deck)
} else {
Winner::Player1(p1_deck)
}
}

11
src/lib.rs
View File

@ -6,13 +6,7 @@ pub mod day13;
pub mod day14;
pub mod day15;
pub mod day16;
pub mod day17;
pub mod day18;
pub mod day19;
pub mod day2;
pub mod day20;
pub mod day21;
pub mod day22;
pub mod day3;
pub mod day4;
pub mod day5;
@ -22,8 +16,3 @@ pub mod day8;
pub mod day9;
aoc_runner_derive::aoc_lib! { year = 2020 }
fn split_once<'a>(input: &'a str, delimeter: &str) -> Option<(&'a str, &'a str)> {
let idx = input.find(delimeter)?;
Some((&input[..idx], &input[idx + delimeter.len()..]))
}