attmin
42ead11aa0
Day 16 part 2.
2023-11-12 19:15:31 +01:00
attmin
8e1f42205c
Day 16 part 1.
2023-11-12 16:14:45 +01:00
attmin
c4ae25d579
Updated dependencies.
2023-11-12 12:36:02 +01:00
attmin
f472ace665
Day 25 part 1.
2023-11-10 21:15:00 +01:00
attmin
a9b3c90a6c
Fixed compiler warnings.
2023-11-10 19:17:51 +01:00
attmin
30ef81cfac
Day 18 part 2
2023-05-27 01:45:15 +02:00
attmin
861e31efee
Day 18 part 1
2023-05-27 01:00:21 +02:00
attmin
d6c728ccfe
Day 17 part 2
2023-05-26 22:25:26 +02:00
attmin
8bc589488c
Day 17 part 1
2023-05-26 22:23:19 +02:00
attmin
cfb3ae497e
Reformatted
2023-05-26 10:02:22 +02:00
attmin
b922b808fc
Day 17 stuff
2023-05-26 10:02:17 +02:00
attmin
5c4e9a9e9d
Day 17 parsing
2023-05-25 23:01:57 +02:00
attmin
b480601ee8
clippy fixes
...
clippy fixes #2
clippy fixed #3
removed unnecessary stuff
2023-05-20 23:28:37 +02:00
attmin
ef2340eaae
Migrated to rust edition 2021
2023-05-20 22:39:07 +02:00
b2a5da3222
day23 part 2 correct intersection test (speed up by factor 2, yay!)
2019-01-03 11:43:38 +01:00
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
c162fcb6d9
day24 p1 wrong (example ok)
2018-12-29 16:43:39 +01:00
097cfac516
day24 part1 input parsing
2018-12-26 23:30:39 +01:00
2b51e67fc6
day23 hmmm
2018-12-26 22:27:36 +01:00
6e438127ec
day23 part1
2018-12-25 17:15:51 +01:00
21dfc7f630
day22 little speed improvement
2018-12-25 14:32:50 +01:00
719db128cf
day22 with hashmaps
...
slower, but more flexible
2018-12-25 14:04:03 +01:00
12f32ed232
removed warnings
2018-12-25 14:03:45 +01:00
768d328e87
day22 2nd part
2018-12-24 17:19:50 +01:00
31075fa449
day22 refactored part1 into extra struct
2018-12-24 15:49:00 +01:00
d5aa1ddc74
day22 part1
2018-12-22 15:07:46 +01:00
8badd4a416
day20 part 2
2018-12-21 11:26:21 +01:00
241ca8ea18
day20 part1 fast
2018-12-21 10:32:11 +01:00
a35881fb01
day20 part 1 super slow
2018-12-21 10:03:06 +01:00
0438a052d2
day20 WIP
2018-12-20 10:19:41 +01:00
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
cef96d55be
day15 part 2
2018-12-18 22:20:03 +01:00
3f2ff6e5a2
day15 part1 done
2018-12-18 19:11:55 +01:00
ac3a741f0d
day15 part1 combat with errors
2018-12-18 17:46:44 +01:00
2bf8edf315
day15 part1 movement
2018-12-18 16:59:41 +01:00
6f2e046080
day14 both parts
2018-12-17 17:45:35 +01:00
6f9ca4dfb6
2018-12-17 11:06:12 +01:00
807bff7977
day13 part2
2018-12-16 01:37:37 +01:00
c1c761f2ba
day13 part 1
2018-12-16 01:14:09 +01:00
2fa6c40f33
day12 part 1
2018-12-14 14:09:57 +01:00
54103e8fa6
day11 part2 fast
2018-12-11 16:02:22 +01:00
fc328d82af
day11 part2
2018-12-11 11:37:32 +01:00
267dfb8068
day11 part 1
2018-12-11 11:25:57 +01:00
6d4bdccc6e
day10 part 2
2018-12-11 09:35:19 +01:00
4eb90ac047
day10 part 1
2018-12-10 20:51:13 +01:00
2cf9933300
day09 part 2
2018-12-10 15:16:06 +01:00
e5a3a1458a
day09 part 1
2018-12-10 13:10:09 +01:00
d84e3bff27
day08 part 2
2018-12-09 21:34:43 +01:00
51418b709e
day08 part 1
2018-12-09 21:17:29 +01:00
4946263a37
day07-1
2018-12-07 11:17:48 +01:00
attmin
Johannes