Merry Christmas to all!
Advent of Code 2020 has come to an end. At the time of this writing, around seven thousand people finished the whole thing, out of the 150000 that had submitted a solution to the first day's problem. And I'm one of them!
You can see my solutions here. I started out with C, moved on to Ruby, and near the end switched to Lua. I'm going to need some Lua knowledge for the Redis section of the databases class I'm taking right now, so AoC was a good time to get familiar with the language.
I found most of the problems fairly simple, but it was fun to go through them all anyways.
Day 20 Part 2. My solution ended up being a good 340 lines of Lua split between two scripts. This is the last problem I solved because I knew it would require a lot of work to get working, so I procrastinated on it until the end.
In the end, the process of solving this was actually kind of fun, and getting the final solution satisfying. I think it might have something to do with the geometric/visual nature of the problem. There's just something nice about rotating and flipping ASCII squares with code, and seeing them all line up correctly in the end.
Day 19 Part 2. Rather than implementing a parser generator that could handle this grammar by hand, I bodged together a Bison (aka Yacc) solution . It's not very pretty, especially the Bash script that just calls the parser with each input word separately and counts how many times it didn't exit with a syntax error. But it works! And I finally learned something about Bison/Yacc and Flex/Lex, which I've had indirect exposure to before, but never actually used.
I was quite pleased with my Part 1 solution though, where I implemented a simple recursive parser generator.
Day 13 Part 2. I'll admit it, I just copied a Chinese Remainder Theorem
implementation from Rosetta Code. I'm sure the Python guys just used
numpy's CRT, so treating it as a library function doesn't seem too
cheaty for me.
Probably a tie between the already mentioned Day 20 Part 2 and Day 19 Part 1. Day 20 had that cool geometric component and satisfaction of putting a puzzle together, but I'm a sucker for recursive parsers implemented with higher order functions.
Learning Lua was probably the most useful outcome of this year's AoC for me. I feel pretty comfortable with the basic constructs of the language, and even played around a bit with metatable-driven OOP. I don't know how closely I stuck to general conventions, and didn't interact with any external libraries, but can definitely read and write the language comfortably now.
My one sentence summary of feelings towards Lua is that Go is to Java what Lua is to Python/Ruby/JavaScript. Its very small vocabulary means you learn the language quickly and don't need to think much while writing it, but your programs can end up more verbose than the equivalent Ruby/Python.