Day 17.

lib.rkt

@@ -142,8 +142,8 @@
   (if (negative? n) 0 n))
 
 ;; % : number -> number -> number
-(define (% d)
+(define %
-  (λ (n) (remainder n d)))
+  (∂ (λ (d n) (remainder n d))))
 
 ;; number->digits-reverse : number -> (listof number)
 ;; Return the digits of the given number in reverse order (i.e. RTL)
@@ -199,7 +199,8 @@
 
 ;; repeat : number -> (listof any) -> (listof any)
 (define (repeat m lst)
-  (apply append (make-list m lst)))
+  (if (zero? m) '()
+      (append lst (repeat (sub1 m) lst))))
 
 ;; chunks-of : (listof any) -> nonzero? -> (listof (listof any))
 ;; Partitions a list into lists of the given size in order,

src/16.rkt

@@ -35,7 +35,12 @@
         (loop (fft signal) (add1 count)))))
 
 (define (fft-half ns)
-  (map (∘ (% 10) abs) (reverse (scanr + 0 ns))))
+  (second
+   (foldr (λ (v acc)
+            (match-let ([(list sum lst) acc])
+              (let ([sum (+ v sum)])
+                (list sum (cons (% 10 (abs sum)) lst)))))
+          (list 0 '(0)) ns)))
 
 (define (part2)
   (let* ([offset (digits->number (take input 7))]

src/17.rkt

@@ -0,0 +1,46 @@
+#lang racket
+
+(require "../lib.rkt"
+         "IntCode.rkt")
+
+(define input
+  (string->program (car (problem-input 17))))
+
+(define scaffolds
+  (string-trim (list->string (map integer->char (resume-with-io (exec input) '())))))
+
+(define part1
+  (let* ([list-grid (map string->list (string-split scaffolds "\n"))]
+         [vector-grid (list->vector (map list->vector list-grid))]
+         [width (length (car list-grid))]
+         [height (length list-grid)])
+    (foldl (λ (xy sum)
+             (match-let ([(list x y) xy])
+               (if (and (char=? #\# (vector-ref (vector-ref vector-grid (add1 y)) x))
+                        (char=? #\# (vector-ref (vector-ref vector-grid (sub1 y)) x))
+                        (char=? #\# (vector-ref (vector-ref vector-grid y) (add1 x)))
+                        (char=? #\# (vector-ref (vector-ref vector-grid y) (sub1 x))))
+                   (+ sum (* x y))
+                   sum)))
+           0 (cartesian-product (range 1 (sub1 width)) (range 1 (sub1 height))))))
+
+;; I did this manually. sue me
+(define A "L,10,R,10,L,10,L,10\n")
+(define B "R,10,R,12,L,12\n")
+(define C "R,12,L,12,R,6\n")
+(define main "A,B,A,B,C,C,B,A,B,C\n")
+
+(define part2
+  (let* ([program (vector-set!* input 0 2)]
+         [input (append (map char->integer (string->list main))
+                        (map char->integer (string->list A))
+                        (map char->integer (string->list B))
+                        (map char->integer (string->list C))
+                        (map char->integer (string->list "n\n")))]
+         [output (resume-with-io (exec program) input)]
+         [map-list (take output (sub1 (length output)))]
+         [map-string (list->string (map integer->char map-list))])
+    (display map-string)
+    (last output)))
+
+(show-solution part1 part2)