fc803d8a0f
Day 24 part 2.
2023-11-14 19:35:00 +01:00
3a9379f877
Day 24 part 1.
2023-11-14 18:48:45 +01:00
241c417a77
intermediate
2023-11-14 16:56:16 +01:00
4cbe831115
Removed warnings.
2023-11-14 16:41:54 +01:00
a4c33ae3d2
Day 21 part 2. Shitty bitty.
2023-11-13 23:22:51 +01:00
48ad7e7a96
Day 21 part 1.
2023-11-13 19:52:52 +01:00
caf307bf2d
Day 19 part 2 (manually reverse engineered the assembler instructions).
2023-11-12 23:12:46 +01:00
2792304040
Day 19 part 1.
2023-11-12 21:25:31 +01:00
42ead11aa0
Day 16 part 2.
2023-11-12 19:15:31 +01:00
8e1f42205c
Day 16 part 1.
2023-11-12 16:14:45 +01:00
c4ae25d579
Updated dependencies.
2023-11-12 12:36:02 +01:00
f472ace665
Day 25 part 1.
2023-11-10 21:15:00 +01:00
a9b3c90a6c
Fixed compiler warnings.
2023-11-10 19:17:51 +01:00
30ef81cfac
Day 18 part 2
2023-05-27 01:45:15 +02:00
861e31efee
Day 18 part 1
2023-05-27 01:00:21 +02:00
d6c728ccfe
Day 17 part 2
2023-05-26 22:25:26 +02:00
8bc589488c
Day 17 part 1
2023-05-26 22:23:19 +02:00
cfb3ae497e
Reformatted
2023-05-26 10:02:22 +02:00
b922b808fc
Day 17 stuff
2023-05-26 10:02:17 +02:00
5c4e9a9e9d
Day 17 parsing
2023-05-25 23:01:57 +02:00
b480601ee8
clippy fixes
...
clippy fixes #2
clippy fixed #3
removed unnecessary stuff
2023-05-20 23:28:37 +02:00
ef2340eaae
Migrated to rust edition 2021
2023-05-20 22:39:07 +02:00
Johannes
b2a5da3222
day23 part 2 correct intersection test (speed up by factor 2, yay!)
2019-01-03 11:43:38 +01:00
Johannes
9cbbf63eb1
day23 part 2 (with a shortcut that could potentially break some cases)
...
I'm only using a lower bound on the number of intersections a cube has.
2019-01-01 18:40:00 +01:00
Johannes
c162fcb6d9
day24 p1 wrong (example ok)
2018-12-29 16:43:39 +01:00
Johannes
097cfac516
day24 part1 input parsing
2018-12-26 23:30:39 +01:00
Johannes
2b51e67fc6
day23 hmmm
2018-12-26 22:27:36 +01:00
Johannes
6e438127ec
day23 part1
2018-12-25 17:15:51 +01:00
Johannes
21dfc7f630
day22 little speed improvement
2018-12-25 14:32:50 +01:00
Johannes
719db128cf
day22 with hashmaps
...
slower, but more flexible
2018-12-25 14:04:03 +01:00
Johannes
12f32ed232
removed warnings
2018-12-25 14:03:45 +01:00
Johannes
768d328e87
day22 2nd part
2018-12-24 17:19:50 +01:00
Johannes
31075fa449
day22 refactored part1 into extra struct
2018-12-24 15:49:00 +01:00
Johannes
d5aa1ddc74
day22 part1
2018-12-22 15:07:46 +01:00
Johannes Schaefer
8badd4a416
day20 part 2
2018-12-21 11:26:21 +01:00
Johannes
241ca8ea18
day20 part1 fast
2018-12-21 10:32:11 +01:00
Johannes
a35881fb01
day20 part 1 super slow
2018-12-21 10:03:06 +01:00
Johannes
0438a052d2
day20 WIP
2018-12-20 10:19:41 +01:00
Johannes
ba622fd408
day15 part 2 optimized
...
instead of senselessly trying to find the best starting point, just rely
on the order of neighbor point generation. Since we use a queue
to manage open points and he neighbors are added in the correct
order, they neighbor that has precedence due to reading order will
automatically be the one to be predecessor on a final path, if he is on
a shortest path.
2018-12-18 22:43:10 +01:00
Johannes
cef96d55be
day15 part 2
2018-12-18 22:20:03 +01:00
Johannes
3f2ff6e5a2
day15 part1 done
2018-12-18 19:11:55 +01:00
Johannes Schaefer
ac3a741f0d
day15 part1 combat with errors
2018-12-18 17:46:44 +01:00
Johannes Schaefer
2bf8edf315
day15 part1 movement
2018-12-18 16:59:41 +01:00
Johannes Schaefer
6f2e046080
day14 both parts
2018-12-17 17:45:35 +01:00
Johannes Schaefer
6f9ca4dfb6
2018-12-17 11:06:12 +01:00
Johannes
807bff7977
day13 part2
2018-12-16 01:37:37 +01:00
Johannes
c1c761f2ba
day13 part 1
2018-12-16 01:14:09 +01:00
Johannes Schaefer
2fa6c40f33
day12 part 1
2018-12-14 14:09:57 +01:00
Johannes Schaefer
54103e8fa6
day11 part2 fast
2018-12-11 16:02:22 +01:00
Johannes Schaefer
fc328d82af
day11 part2
2018-12-11 11:37:32 +01:00
