aoc2023/day2.ss

108 lines
3.4 KiB
Scheme

(import (rnrs) (only (chezscheme) define-values))
(define-syntax curry
(syntax-rules ()
[(_ f x ...) (lambda (y) (f x ... y))]))
(define (mapmap f lst) (map (curry map f) lst))
(define-syntax let-pair
(syntax-rules ()
[(_ [(x y) pair] . body)
(let* [(xpair pair) (x (car xpair)) (y (cdr xpair))] . body)]))
(define-syntax case-list
(syntax-rules (nil cons)
[(_ lst [nil . nbody] [(cons x xs) . cbody])
(let [(xlst lst)]
(if (null? xlst) (begin . nbody) (let-pair [(x xs) xlst] . cbody)))]
[(_ lst [(cons x xs) . cbody] [nil . nbody])
(case-list lst [nil . nbody] [(cons x xs) . cbody])]))
(define-syntax split-list
(syntax-rules () [(_ names lst) (define-values names (apply values lst))]))
(define sum (curry apply +))
(define product (curry apply *))
(define concat (curry apply append))
(define (split-at ch str)
(define len (string-length str))
(let loop [(start 0) (end 0) (acc '())]
(cond [(>= end len)
(reverse (cons (substring str start len) acc))]
[(char=? ch (string-ref str end))
(loop (+ end 1) (+ end 1) (cons (substring str start end) acc))]
[else (loop start (+ end 1) acc)])))
(define (split-at-nested chs0 str)
(define chs (cond [(list? chs0) chs0] [(string? chs0) (string->list chs0)]))
(case-list chs
[nil str]
[(cons ch chs) (map (curry split-at-nested chs) (split-at ch str))]))
(define (trim-by p str)
(define (ok k) (not (p (string-ref str k))))
(define i (do [(i 0 (+ i 1))] [(ok i) i]))
(define j (do [(j (string-length str) (- j 1))] [(ok (- j 1)) j]))
(substring str i j))
(define trim (curry trim-by char-whitespace?))
(define (one-col str)
(split-list (count col) (split-at #\space (trim str)))
(cons (string->symbol col) (string->number count)))
(define (split-line line0)
(split-list (id-str line) (split-at #\: line0))
(define id (string->number (cadr (split-at #\space id-str))))
(define pairs (mapmap one-col (split-at-nested ";," line)))
(cons id pairs))
(define (maybe-split-line line)
(and (not (string=? line "")) (split-line line)))
(define max-counts '((red . 12) (green . 13) (blue . 14)))
(define (max-count col) (cond [(assq col max-counts) => cdr] [else 0]))
(define (valid-draw draws)
(define (ok p) (let-pair [(col n) p] (<= n (max-count col))))
(for-all ok draws))
(define (valid line)
(let-pair [(id draws) line] (and (for-all valid-draw draws) id)))
(define (map-filter p lst)
(define (one x ys) (let [(y (p x))] (if y (cons y ys) ys)))
(fold-right one '() lst))
(define (read-file path)
(map-filter maybe-split-line
(split-at #\newline (call-with-input-file path get-string-all))))
(define (total lines)
(sum (map (lambda (line) (or (valid line) 0)) lines)))
(define input (read-file "in/day2"))
(define (part1) (total input))
(display (cons "part1" (part1))) (newline)
(define (get-col col draw) (cond [(assq col draw) => cdr] [else 0]))
(define (get-max draw1 draw2 col)
(cons col (max (get-col col draw1) (get-col col draw2))))
(define (combine draw1 draw2)
(define (get-max-of col) (get-max draw1 draw2 col))
(list (get-max-of 'red) (get-max-of 'green) (get-max-of 'blue)))
(define (min-cubes draws) (fold-left combine '() draws))
(define (power line) (product (map cdr (min-cubes (cdr line)))))
(define (part2) (sum (map power input)))
(display (cons "part2" (part2))) (newline)