Advent of Code

Guile is nice. A previous post looked at Guix, so I had some familiarity in the back pocket. Going through the first few puzzles wasn't terribly difficult once I'd figured out turning input into lists.

Getting to that point was not immediate - I understand but dislike the ports system when applied to filesystem access.

I ran up against minor issues caused by my usage of Fedora Kinoite. For example, the most recent version of Guile is packaged in Fedora as 'guile30', and provides a guile3.0 binary (but no guile symlink). Geiser was not amused.

Guile does have TCO, because it's a proper Scheme. I feel like if you could ask me for the top three things that define a lisp - TCO would probably be in there. With that said, coming from Ruby, writing recursive functions isn't something that comes naturally.

To me, TCO is more of a thing I stumble into. Like "Oh, I could avoid another function by tweaking this one to have an accumulator".

I found writing Guile in Emacs with Geiser to be fun. The in-editor-eval / C-x C-e process is to Ruby's binding.pry as vaping is to chewing Kendal Black Irish XXX Extra Thick Twist Rope Tobacco. It feels like a fully realised process, rather than an enhancement to printing variables at certain points in code.

Below is Guile for day 1, 2024. It is a naive implementation, that I would write quite differently now.

(use-modules (ice-9 rdelim)
             (ice-9 string-fun)
             (srfi srfi-1))

(define (file->lines path)
  (call-with-input-file path
    (lambda (port)
      (let loop ((line (read-line port))
                 (lines '()))
        (if (eof-object? line)
            (reverse lines)
            (loop (read-line port) (cons line lines)))))))

(define (pair->delta pair)
  (let ((first (car pair))
    (second (cadr pair)))
    (abs (- first second))))

(define (string-pair->int-pair pair)
  (list (string->number (car pair))
    (string->number (cadr pair))))

(define (day1-part1 input-file)
  (letrec ((data (map string-tokenize (file->lines input-file)))
       (pairs (map string-pair->int-pair data))
       (left (sort (map car pairs) <))
       (right (sort (map cadr pairs) <))
       (sorted-pairs (map list left right)))
    (apply + (map pair->delta sorted-pairs))))

(define (multiply-by-right n right-list)
  (* n (count (lambda (x) (= x n)) right-list)))

(define (day1-part2 input-file)
  (letrec ((data (map string-tokenize (file->lines input-file)))
       (pairs (map string-pair->int-pair data))
       (left (map car pairs))
       (right (map cadr pairs)))
    (apply + (map (lambda (n) (multiply-by-right n right)) left))))

(day1-part1 "input")
(day1-part2 "input")

Elisp is so quick to get started with. Most of this is down to how elisp is deeply embedded in emacs - any familiarity with emacs can be translated into the same with elisp.

The starting point for all advent of code challenges is to get the input into a form you can work with. You can do this in one-go, or you can do it line by line. Either way, you need to read a file. If you already know M-x insert-file, you already know you're looking for something (insert-file "./file.txt").

By executing C-h f insert-file, emacs will pop a buffer with documentation for insert-file, which will explain you want (insert-file-contents FILENAME &optional VISIT BEG END REPLACE). For functions that aren't called interactively, it's usually enough to guess. C-h f split lists a plethora of functions, including (string-split STRING &optional SEPARATORS OMIT_NULLS TRIM).

I believe that I reached day 8 in elisp solely because of Emacs' internal documentation. My past experiences with Common Lisp tend to devolve into a lot of context-switching trying to figure out precisely what form of loop to use. There's a lot of ways to iterate.

Being able to bring up documentation on any function is about the only thing that makes that constant context-switching bearable.

There is no TCO. Humorously, I forgot that, spent an age writing a solution to day 7 part 1, and then realised when I switched from test input to real input and blew the stack. Guile Emacs may change that in the long-run.

The one thing I think I'd have liked to see is cl-X functions as the default. I appreciate it's a far too late to replace vanilla mapcar with cl-mapcar - you'd probably break an unfathomable number of emacs packages. But one can't help but wish the more versatile cl- functions weren't segmented behind a prefix.

Here's the same naive solution as above, in elisp. As I figured things out, things got a bit neater, and I spent less time hoying thing into random variables:

(add-to-list 'load-path (pwd))
(require 'utils)

(setq strings (file-to-string-lists "day1-test"))
(setq data (numberize-string-lists strings))
(setq left-data (mapcar 'car data))
(setq right-data (mapcar 'cadr data))

;; Part 1
(setq sorted-left (sort left-data))
(setq sorted-right (sort right-data))
(setq sorted-joined (cl-mapcar #'list sorted-left sorted-right))
(setq distances (mapcar (lambda (pair) 
                          (abs (- (car pair) (cadr pair)))) sorted-joined))
(setq day1-part1 (apply '+ distances))

;; Part2
(setq right-occurences (make-hash-table :test 'eq))
(dolist (num right-data right-occurences)
  (puthash num (1+ (gethash num right-occurences 0)) right-occurences))

(setq day1-part2 (apply '+ 
  (mapcar (lambda (num) 
            (* num (gethash num right-occurences 0))) left-data)))

(message "Day 1 Part 1: %d" day1-part1)
(message "Day 1 Part 2: %d" day1-part2)