Day 9 some refactoring

src/09.rkt

@@ -2,7 +2,10 @@
 
 (require "../lib.rkt")
 
-(define input (map #{string-split %1 " "} (problem-input 9)))
+(define input
+  (map (match-lambda [(pregexp "(\\w) (\\d+)" `(,_ ,d ,n))
+                      (list (string->symbol d) (string->number n))])
+       (problem-input 9)))
 
 (define (sign H T)
   (cond
@@ -10,38 +13,35 @@
     [(= H T)  0]
     [(< H T) -1]))
 
+(define (lead d x y)
+  (match d
+    ['U (values x (add1 y))]
+    ['D (values x (sub1 y))]
+    ['R (values (add1 x) y)]
+    ['L (values (sub1 x) y)]))
+
 (define (follow xH yH xT yT)
-  (if (or (and (= xH xT) (> (abs (- yH yT)) 1))
-          (and (= yH yT) (> (abs (- xH xT)) 1))
+  (if (or (and (= xH xT) (= (abs (- yH yT)) 2))
+          (and (= yH yT) (= (abs (- xH xT)) 2))
           (> (+ (abs (- xH xT)) (abs (- yH yT))) 2))
       (values (+ xT (sign xH xT)) (+ yT (sign yH yT)))
       (values xT yT)))
 
 (define (model knots)
   (define visited (mutable-set))
-  (for/fold ([xH 0] [yH 0]
-             [xTs (repeat knots '(0))]
-             [yTs (repeat knots '(0))])
-            ([motion input])
-    (match-let* ([`(,dir , n) motion]
-                 [n (string->number n)])
-      (for/fold ([xH  xH]  [yH  yH]
-                 [xTs xTs] [yTs yTs])
-                ([_ (in-range n)])
-        (define-values (xH* yH*)
-          (match dir
-            ["U" (values xH (add1 yH))]
-            ["D" (values xH (sub1 yH))]
-            ["R" (values (add1 xH) yH)]
-            ["L" (values (sub1 xH) yH)]))
-        (define-values (xTs* yTs*)
-          (for/fold ([xTs `(,xH)] [yTs `(,yH)]
-                     #:result (values (rest (reverse xTs)) (rest (reverse yTs))))
-                    ([xT xTs] [yT yTs])
-            (define-values (xT* yT*) (follow (first xTs) (first yTs) xT yT))
-            (values (cons xT* xTs) (cons yT* yTs))))
-        (set-add! visited (cons (last xTs*) (last yTs*)))
-        (values xH* yH* xTs* yTs*))))
+  (for*/fold ([xs (repeat (add1 knots) '(0))]
+              [ys (repeat (add1 knots) '(0))])
+             ([motion input]
+              [_ (in-range (second motion))])
+    (for/fold ([xs '()] [ys '()]
+               #:result (begin (set-add! visited (cons (first xs) (first ys)))
+                               (values (reverse xs) (reverse ys))))
+              ([x xs] [y ys])
+      (define-values (x* y*)
+        (if (empty? xs)
+            (lead (first motion) x y)
+            (follow (first xs) (first ys) x y)))
+      (values (cons x* xs) (cons y* ys))))
   (set-count visited))
 
 (show-solution (model 1) (model 9))