From a87daecd7d2f05e17be643e523a92baf96e94f8d Mon Sep 17 00:00:00 2001
From: Adam Jeniski <adam.jeniski@flashtalking.com>
Date: Fri, 15 Dec 2023 15:29:56 -0500
Subject: [PATCH] fix memoiation

---
 2023/src/day13.clj | 101 +++++++++++++++++++++++----------------------
 1 file changed, 52 insertions(+), 49 deletions(-)

diff --git a/2023/src/day13.clj b/2023/src/day13.clj
index 7f51d5a..84b973d 100644
--- a/2023/src/day13.clj
+++ b/2023/src/day13.clj
@@ -34,45 +34,38 @@
                          (filter (fn [[[row]]] (= r row)))
                          (map second)))
 
-(defn get-refl-value [m num-rows num-cols & [discriminator]]
+(defn get-refl-value [m num-rows num-cols]
   (let [rows (range 0 num-rows)
         cols (range 0 num-cols)]
-    (when discriminator
-      (println discriminator))
-    (or (->> cols
-             (map #(for [c (range (min (inc %) (- (dec num-cols) %)))]
-                     [(- % c) (inc (+ % c))]))
-             (filter not-empty)
-             (filter #(or (not= (second discriminator) :row)
-                          (not= (first discriminator) %)))
-             (map (partial map (fn [[a b]]
-                                 ; (println a b :col discriminator)
-                                 (= (get-col m a)
-                                    (get-col m b)))))
-             (map-indexed vector)
-             (filter (comp (partial every? identity)
-                           second))
-             (filter second)
-             first
-             (#(when %
-                 [(inc (first %)) :col])))
-        (->> rows
+    (apply
+     concat
+     (filter
+      not-empty
+      (list (->>
+             rows
              (map #(for [r (range (min (inc %) (- (dec num-rows) %)))]
                      [(- % r) (inc (+ % r))]))
              (filter not-empty)
-             (filter #(or (not= (second discriminator) :row)
-                          (not= (first discriminator) %)))
              (map (partial map (fn [[a b]]
-                                 ; (println a b :row discriminator)
                                  (=  (get-row m a)
                                      (get-row m b)))))
              (map-indexed vector)
              (filter (comp (partial every? identity)
                            second))
              (filter second)
-             first
-             (#(when %
-                 [(inc (first %)) :row]))))))
+             (map #(vector (inc (first %)) :row)))
+            (->> cols
+                 (map #(for [c (range (min (inc %) (- (dec num-cols) %)))]
+                         [(- % c) (inc (+ % c))]))
+                 (filter not-empty)
+                 (map (partial map (fn [[a b]]
+                                     (= (get-col m a)
+                                        (get-col m b)))))
+                 (map-indexed vector)
+                 (filter (comp (partial every? identity)
+                               second))
+                 (filter second)
+                 (map #(vector (inc (first %)) :col))))))))
 
 (defn gen-map [input]
   (->> input
@@ -87,31 +80,41 @@
      (map #(get-refl-value (gen-map %)
                            (count %)
                            (count (first %))))
+     (map first)
+     (map #(update % 1 (fn [x] (condp = x
+                                 :col 1
+                                 :row 100))))
+     (map (partial apply *))
+     (reduce +)
+     )
+
+(defn print-board [m num-rows num-cols]
+  (println)
+  (doseq [row (range num-rows)]
+    (doseq [col (range num-cols)]
+      (print (m [row col])))
+    (println)))
+
+;; part 2
+(->> input
+     (mapv
+      #(let [num-rows (count %)
+             num-cols (count (first %))
+             m (gen-map %)
+             smudge (first (get-refl-value m num-rows num-cols))]
+         (->> (for [r (range num-rows)
+                    c (range num-cols)]
+                (->> (get-refl-value
+                      (update m [r c] (fn [c] (if (= c \#) \. \#)))
+                      num-rows
+                      num-cols)
+                     (filter (partial not= smudge))))
+              (filter not-empty)
+              (apply concat))))
+     (map first)
      (map #(update % 1 (fn [x] (condp = x
                                  :col 1
                                  :row 100))))
      (map (partial apply *))
      (reduce +))
 
-;; part 2
-(->> sample-input
-     (mapv #(let [num-rows (count %)
-                  num-cols (count (first %))
-                  m (gen-map %)
-                  smudge (get-refl-value m num-rows num-cols)]
-              (->>
-               (for [r (range num-rows)
-                     c (range num-cols)]
-                 (let [m-prime (update m [r c] (fn [c] (if (= c \#) \. \#)))
-                       res (get-refl-value m-prime num-rows num-cols smudge)]
-                   res))
-               (filter identity)
-               first)))
-     ; (map get-refl-value)
-     ; (map #(update % 1 (fn [x] (condp = x
-     ;                             :col 1
-     ;                             :row 100))))
-     ; (map (partial apply *))
-     ; (reduce +)
-     )
-