Day 8.

src/08.rkt

@@ -0,0 +1,53 @@
+#lang racket
+
+(require "../lib.rkt")
+
+(define input
+  (car (problem-input 8)))
+
+(define width 25)
+(define height 6)
+
+;; partition-into : (listof any) -> nonzero? -> (listof (listof any))
+;; Partitions a list into lists of the given size in order,
+;; with the final list possibly being smaller
+;; e.g. '(1 2 3 4 5) 2 => '((1 2) (3 4) (5))
+(define (partition-into lst size)
+  (if (< (length lst) size) (list lst)
+      (cons (take lst size)
+            (partition-into (drop lst size) size))))
+
+;; pivot : (listof (listof any)) -> (listof (listof any))
+;; Turns a list of lists into a list of lists of
+;; the first elements of the lists, ..., the nth elements
+;; where n is the length of the shortest list.
+;; In short, it pivots a list of rows into a list of columns.
+;; e.g. '((1 2 3 4)          '((1 5 8)
+;;        (5 6 7)         =>   (2 6 9)
+;;        (8 9 10 11 12))      (3 7 10))
+(define (pivot layers)
+  (if (ormap empty? layers) '()
+      (let ([pixels (map car layers)]
+            [layers (map cdr layers)])
+        (cons pixels (pivot layers)))))
+
+(define layers
+  (let* ([area (* width height)]
+         [chars (string->list input)])
+    (partition-into chars area)))
+
+(define part1
+  (let* ([zeroes (map (curry count (curry eq? #\0)) layers)]
+         [min-index (index-of zeroes (apply min zeroes))]
+         [min-layer (list-ref layers min-index)]
+         [ones (count (curry eq? #\1) min-layer)]
+         [twos (count (curry eq? #\2) min-layer)])
+    (* ones twos)))
+
+(define part2
+  (let* ([image (map (curry findf (curry neq? #\2)) (pivot layers))]
+         [image* (map (λ (pixel) (if (eq? pixel #\1) #\█ #\░)) image)]
+         [msg (map list->string (partition-into image* width))])
+    (for-each displayln msg)))
+
+(show-solution part1 #f)