Marketing Pitch and Impressions#

Mature: Racket is a mature and stable product. From the beginning, it has supported cross-platform graphical programming (Windows, macOS, Linux).

Practical: Racket includes a rich set of libraries, covering the full range from web server apps to mathematics and scientific simulation software.

Extensible: In Racket, programmers define their own loops with powerful macros. Indeed, these macros are so powerful that programmers make entire domain-specific languages as libraries. No tools, no Makefiles required.

Robust: Racket is the first language to support higher-order software contracts and safe gradual typing. Programmers can easily deploy these tools to harden their software.

Polished: Racket comes with support for major editors. The main bundle includes an innovative and extensible interactive development environment that has inspired other IDE projects.

— racket-lang.org

The syntax relies on parenthesised S-expressions, which is likely the single most disliked feature of lisp family languages.

Visual Studio Code support is for Racket is excellent. Racket also has it’s own excellent IDE.

The Code#

Use of the λ character in place of the lambda symbol is cute and makes the code more compact. I probably should have used let instead of define in main too.

I parse all the input lines into a set of 2D points. This makes existence checking easier, and we don’t have to worry about grid boundaries as much.

For part 1, we just count points in the set that have less than 5 points in their neighbourhood (ie 4 + self).

For part 2, we iterate over the set, totalling and removing accessible rolls until there are no more accessible rolls.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#lang racket

(struct p2d (x y) #:transparent)

(define (neighbourhood p)
  (for*/list ([dy (in-range -1 2)]
              [dx (in-range -1 2)])
    (p2d (+ (p2d-x p) dx) (+ (p2d-y p) dy))))

(define (parse-input filename)
  (for*/list ([(line y) (in-indexed (file->lines filename))]
              [(c x) (in-indexed (in-string line))]
              #:when (char=? c #\@))
    (p2d x y)))

(define (count-neighbors p points-set)
  (count (λ (neighbor) (set-member? points-set neighbor))
         (neighbourhood p)))

(define (main)
  (let ([points (list->set (parse-input "y25d04.txt"))])
    (let ([result1
           (count (λ (p) (< (count-neighbors p points) 5))
                  (set->list points))])
      (displayln (format "Result1: ~a" result1)))

    (let ([result2
           (let loop ([total 0] [current-points points])
             (let ([to-remove
                    (for/set ([p (in-set current-points)]
                              #:when (< (count-neighbors p current-points) 5))
                      p)])
               (if (set-empty? to-remove)
                   total
                   (loop (+ total (set-count to-remove))
                         (set-subtract current-points to-remove)))))])
      (displayln (format "Result2: ~a" result2)))))

(main)

Install Racket and run#

# I installed via Homebrew
brew install --cask racket

# Official installer (Linux/macOS/Windows)
# https://download.racket-lang.org/

# Execute the code
racket d04.rkt