Advent of Code solutions in Common Lisp
TODO
- This works with SBCL only
- Get 2018 solutions to use DEFINE-SOLUTION -- and review the solutions too, given that I was just getting stated with CL back then
- 2016/11: it's taking 50+ seconds to generate solutions, and by looking at Reddit's megathread it seems like there might be a few optimizations worth implementing
- 2016/14: it takes around 40 seconds to generate the solution for part 2, and I am not sure there is a more efficient way to solve this (e.g. faster md5 implementation, avoid repeated string-to-bytes conversions)
- 2016/18: fiddle with integers and bits instead of creating new strings (currently it takes 1.5 seconds to run part2)
- 2016/21: inverse scramble operations instead of bruteforcing with all the
8!permutations of the input - 2016/23: 160 seconds to naively solve part2 -- try to optimize the input by converting add-loops into multiplications?!
- 2019/10: needs some serious refactoring around phases, and vector math
- 2019/17: implement a solution for this (I solved this with pen and paper)
- 2019/18: the implementation is a bit of a mess, and it takes around 10 seconds to complete
- 2019/19: figure out how to calculate the slope of the upper border of the beam
- 2019/24: better logic for recursive neighbors + how to efficiently add levels to the state? Currently we end up with way more states than we actually use
- 2019/25: implement a solution for this (I solved this by playing it)
- Add PERMUTATIONS function that works with strings too (currently, for 2016/21 I COERCE'd like there is no tomorrow)
- 2020/11: cache recursive calls IN-SIGHT-OCCUPIED, or change how the problem is modeled...completely
- 2020/15: implement a solution that uses a single HASH-TABLE (the realization
is that
turn-1is always equal toturn - 1) - 2020/18: Solve using Shunting yard algorithm
- 2020/19: Solve implementing a Context-free grammar parser
- 2020/20: Clean up the solution (remove hard-coded stuff, regexps, ...)
- 2020/23: Takes 6 seconds to generate the answer
- 2015/24: Properly verify that, once I find a combination of packages that fit into the first group, all the remaining packages can be evenly split into 2 or 3 groups
- 2021/18: Solve using Zippers!
- 2021/19: Speed things up -- 2 minutes to complete, plus
13,399,299,136 bytes consed - 2021/21: 15 seconds to run -- check out this comment full of alternate solutions to this problem
- Should PARTIAL-1 locally bind all its free arguments? For example:
(partial-1 #'function (some-expensive-function))should the result of the invocation of SOME-EXPENSIVE-FUNCTION be cached, or instead should the function be invoked each time the PARTIAL-1 lambda gets called - Review all 2022 solutions -- I gave up moping things up on the 10th, so they loop more like scratch buffers than anything functional