day 19: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

19.rkt

@@ -0,0 +1,107 @@
+#lang curly-fn racket
+
+(require "scripts/aoc.rkt")
+
+;; solution for day 19
+(struct basic [value] #:transparent)
+(struct alias [target] #:transparent)
+(struct concat [left right] #:transparent)
+(struct orr [left right] #:transparent)
+
+(define (rule-match? rules line [rulenum 0])
+  (define rule (hash-ref rules rulenum))
+  (cond
+    [(basic? rule)
+     (cond
+       [(zero? (length line)) (values #f '())]
+       [(char=? (basic-value rule) (first line)) (values #t (list (rest line)))]
+       [else (values #f '())])]
+    [(alias? rule) (rule-match? rules line (alias-target rule))]
+    [(orr? rule)
+     (define-values [p1 p2] (rule-match? rules line (orr-left rule)))
+     (define-values [q1 q2] (rule-match? rules line (orr-right rule)))
+     (cond
+       [(and p1 q1) (values #t (append p2 q2))]
+       [p1 (values #t p2)]
+       [q1 (values #t q2)]
+       [else (values #f '())])]
+    [(concat? rule)
+     (define-values [p1 p2] (rule-match? rules line (concat-left rule)))
+     (cond
+       [p1
+        (define rst '())
+        (define m? #f)
+        (for ([sub (in-list p2)])
+          (define-values [q1 q2] (rule-match? rules sub (concat-right rule)))
+          (when q1
+            (set! rst (append rst q2))
+            (set! m? #t)))
+        (values m? rst)]
+       [else (values #f '())])]))
+
+(define (part1 input)
+  (match-define (cons rules lines) input)
+  (for/sum ([line (in-list lines)])
+    (define-values [m? r] (rule-match? rules (string->list line)))
+    ; (printf "~a: ~a\n" line m?)
+    (if (and m? (member '() r)) 1 0)))
+
+(define (part2 input)
+  (match-define (cons rules lines) input)
+  (define c2 (gensym))
+  (hash-set! rules 8 (orr 42 c2))
+  (hash-set! rules c2 (concat 42 8))
+
+  (define c3 (gensym))
+  (define c4 (gensym))
+  (define c5 (gensym))
+  (hash-set! rules 11 (orr c3 c4))
+  (hash-set! rules c3 (concat 42 31))
+  (hash-set! rules c4 (concat 42 c5))
+  (hash-set! rules c5 (concat 11 31))
+
+  (for/sum ([line (in-list lines)])
+    (define-values [m? r] (rule-match? rules (string->list line)))
+    ; (printf "~a: ~a\n" line m?)
+    (if (and m? (member '() r)) 1 0)))
+
+;; parse input file
+(define (parse fname)
+  (define sn string->number)
+  (match-define (list rules-lines input) (string-split (file->string fname) "\n\n"))
+  (define rules (make-hash))
+  (for ([line (in-list (string-split rules-lines "\n"))])
+    (match line
+      [(pregexp #px"^(\\d+): \"(.)\"$" (list _ num char))
+       (hash-set! rules (sn num) (basic (string-ref char 0)))]
+      [(pregexp #px"^(\\d+): (\\d+)$" (list _ num alias-to))
+       (hash-set! rules (sn num) (alias (sn alias-to)))]
+      [(pregexp #px"^(\\d+): (\\d+) (\\d+)$" (list _ num l r))
+       (hash-set! rules (sn num) (concat (sn l) (sn r)))]
+      [(pregexp #px"^(\\d+): (\\d+) (\\d+) (\\d+)$" (list _ num l r r2))
+       (define tmp (gensym))
+       (hash-set! rules (sn num) (concat (sn l) tmp))
+       (hash-set! rules tmp (concat (sn r) (sn r2)))]
+      [(pregexp #px"^(\\d+): (\\d+) \\| (\\d+)$" (list _ num l r))
+       (hash-set! rules (sn num) (orr (sn l) (sn r)))]
+      [(pregexp #px"^(\\d+): (\\d+) (\\d+) \\| (\\d+) (\\d+)$" (list _ num l1 l2 r1 r2))
+       (define ls (gensym))
+       (define rs (gensym))
+       (hash-set! rules ls (concat (sn l1) (sn l2)))
+       (hash-set! rules rs (concat (sn r1) (sn r2)))
+       (hash-set! rules (sn num) (orr ls rs))]
+      [_ (error "not shonks" line)]))
+  (cons rules (string-split input "\n")))
+
+
+
+(module+ test
+  (require rackunit)
+  ;; tests here
+  (displayln "no tests :("))
+
+(module+ main
+  (define input (parse "inputs/19"))
+  (answer 19 1 (time (part1 input)))
+  (answer 19 2 (time (part2 input)))
+  (displayln "meow"))