aoc2020/24.rkt

#lang curly-fn racket

(require "scripts/aoc.rkt")

;; solution for day 24

(define *dirs* (hash 'e 1-1i 'ne 1 'nw +1i 'w -1+1i 'sw -1 'se -1i))
(define *dirs-values* (hash-values *dirs*))

(define (paths->tiles input)
  ;; white is #f
  ;; black is #t
  (define tiles (make-hash))
  (for ([path (in-list input)])
    (define posn
      (for/fold ([posn 0]) ([p (in-list path)])
        (+ posn (hash-ref *dirs* p))))
    (hash-update! tiles posn not #f))
  tiles)

(define (count-black tiles)
  (for/sum ([(_ v) (in-hash tiles)] #:when v) 1))

(define (part1 input)
  (count-black (paths->tiles input)))

(define (part2 input)
  (define tiles (paths->tiles input))

  (define (step tiles radius)
    (define new-tiles (hash-copy tiles))
    (for* ([x (in-range (- radius) (add1 radius))] [y (in-range (- radius) (add1 radius))])
      (define thispos (make-rectangular x y))
      (define thistile (hash-ref tiles thispos #f))
      (define num-blacks
        (for/sum ([neigh (in-list *dirs-values*)] #:when (hash-ref tiles (+ thispos neigh) #f))
          1))
      (hash-set! new-tiles thispos
                 (match* (thistile num-blacks)
                   [(#t (or 0 (not (or 1 2)))) #f]
                   [(#t _) #t]
                   [(#f 2) #t]
                   [(#f _) #f])))
    new-tiles)

  (define radius (apply max (map #{max (abs (real-part %)) (abs (imag-part %))}
                                 (hash-keys tiles))))
  (count-black
    (for/fold ([tiles tiles]) ([i (in-range 100)] [radius (in-range (add1 radius) +inf.0)])
      (step tiles radius))))

;; parse input file
(define (parse fname)
  (for/list ([line (in-list (file->lines fname))])
    (map string->symbol (regexp-match* #px"(e|se|sw|w|nw|ne)" line))))


(module+ test
  (require rackunit)
  ;; tests here
  (displayln "no tests :("))

(module+ main
  (define input (parse "inputs/24"))
  (answer 24 1 (time (part1 input)))
  (answer 24 2 (time (part2 input)))
  (displayln "meow"))