Day 8 more refactoring

lib.rkt

@@ -333,3 +333,10 @@
   (for/first ([i (vector-length vec)]
               #:when (p (vector-ref vec i)))
     i))
+
+
+;; Sequence helpers ;;
+
+;; in-reverse-range : number? -> sequence?
+(define (in-reverse-range n)
+  (in-range (sub1 n) -1 -1))

src/08.rkt

@@ -24,32 +24,32 @@
 
 (define (part1)
   (define talls (mutable-set))
-  (for ([r (range height)])
+  (for ([r (in-range height)])
     (set-add! talls (cons r 0))
     (set-add! talls (cons r (sub1 width)))
     (for/fold ([tallest (get-tree r 0)])
-              ([c (range width)])
+              ([c (in-range width)])
       (define t (get-tree r c))
       (if (< tallest t)
           (begin (set-add! talls (cons r c)) t)
           tallest))
     (for/fold ([tallest (get-tree r (sub1 width))])
-              ([c (reverse (range width))])
+              ([c (in-reverse-range width)])
       (define t (get-tree r c))
       (if (< tallest t)
           (begin (set-add! talls (cons r c)) t)
           tallest)))
-  (for ([c (range width)])
+  (for ([c (in-range width)])
     (set-add! talls (cons 0 c))
     (set-add! talls (cons (sub1 height) c))
     (for/fold ([tallest (get-tree 0 c)])
-              ([r (range height)])
+              ([r (in-range height)])
       (define t (get-tree r c))
       (if (< tallest t)
           (begin (set-add! talls (cons r c)) t)
           tallest))
     (for/fold ([tallest (get-tree (sub1 height) c)])
-              ([r (reverse (range height))])
+              ([r (in-reverse-range height)])
       (define t (get-tree r c))
       (if (< tallest t)
           (begin (set-add! talls (cons r c)) t)
@@ -58,36 +58,23 @@
 
 (define (score r c)
   (define t (get-tree r c))
-  (define s1
-    (let loop ([c* (add1 c)])
-      (if (or (>= c* (sub1 width))
-              (>= (get-tree r c*) t))
-          (- c* c)
-          (loop (add1 c*)))))
-  (define s2
-    (let loop ([c* (sub1 c)])
-      (if (or (<= c* 0)
-              (>= (get-tree r c*) t))
-          (- c c*)
-          (loop (sub1 c*)))))
-  (define s3
-    (let loop ([r* (add1 r)])
-      (if (or (>= r* (sub1 height))
-              (>= (get-tree r* c) t))
-          (- r* r)
-          (loop (add1 r*)))))
-  (define s4
-    (let loop ([r* (sub1 r)])
-      (if (or (<= r* 0)
-              (>= (get-tree r* c) t))
-          (- r r*)
-          (loop (sub1 r*)))))
-  (* s1 s2 s3 s4))
+  (* (for/last ([c* (in-range (add1 c) width)]
+                #:final (>= (get-tree r c*) t))
+       (- c* c))
+     (for/last ([c* (in-reverse-range c)]
+                #:final (>= (get-tree r c*) t))
+       (- c c*))
+     (for/last ([r* (in-range (add1 r) height)]
+                #:final (>= (get-tree r* c) t))
+       (- r* r))
+     (for/last ([r* (in-reverse-range r)]
+                #:final (>= (get-tree r* c) t))
+       (- r r*))))
 
 (define part2
   (maximum
-   (for*/list ([r (range 1 (sub1 height))]
-               [c (range 1 (sub1 width))])
+   (for*/list ([r (in-range 1 (sub1 height))]
+               [c (in-range 1 (sub1 width))])
      (score r c))))
 
 (show-solution (part1) part2)