mbutterick
/
aoc-racket
Archived
Racket solutions & explanations for the Advent of Code puzzles
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
This repo is archived. You can view files and clone it, but cannot push or open issues/pull-requests.
Matthew Butterick 14cae851fe

## 2015 edition

Racket solutions & explanations for the Advent of Code puzzles. Written in Racket's literate-programming dialect, `scribble/lp2`.

Install from the command line:

``````raco pkg install aoc-racket
``````

Explanations will be installed automatically as part of the Scribble documentation.

Or just read the code and explanations online, right now.

## 2016 & onward editions

Solutions in the respective annual subdirectories.

## MB’s Advent of Code tips

• The problems are often designed around a particular computer-y abstraction. If you notice what the abstraction is, and then find the closest analog in Racket, the solution tends to come together quickly. Otherwise, you can spend a lot of time reinventing the wheel.

• Complex numbers are a nice way of modeling two-dimensional positions.

• Use lists whenever feasible, because there are many useful list functions in the Racket library that dont have vector equivalents. In particular, these list functions are very useful, especially `argmin` and `argmax`.

• Vectors are better than lists in situations where you need random access to members.

• `eq?` is the fastest equality check, but it only works for symbols and fixnums (therefore, use more symbols and fixnums so you can use `eq?`!)

• `match` is fantastic.

• Association lists (= lists of pairs) are underrated. Theyre compatible with all the usual list functions, of course, but also dictionary forms (like `dict-ref` and `in-dict`).

• The `graph` library can be helpful for graph-based problems.

• Its good to know about sets and mutable pairs.

• Also the fancier `for` iterators, like `for/first` and `for/or`.

• `let/ec` is a way of jumping out of a deeply nested computation, akin to how `return` works in other languages.

## My solutions

• I try to write solutions that are succinct but not cryptic.

• I dont optimize for speed.

• I like doing the Advent of Code problems because it forces me to use parts of Racket that I dont ordinarily use. So I treat it as a chance to expand my awareness of the Racketverse.

• Im unlikely to finish every problem. Judging by past years, there is a point where the problems get sufficiently complex that Id rather put that time into improving my other Racket projects 🤘

## Project status

I only work on this project during puzzling season.