From 8d43e37df99f280377bed90284d6ac2428334804 Mon Sep 17 00:00:00 2001
From: Clyne Sullivan <clyne@bitgloo.com>
Date: Wed, 30 Nov 2022 19:55:31 -0500
Subject: move 2021 days to folder; update README

---
 year2021/day12/part1.clj | 27 ++++++++++++++++++++++++++
 year2021/day12/part2.clj | 50 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 77 insertions(+)
 create mode 100644 year2021/day12/part1.clj
 create mode 100644 year2021/day12/part2.clj

(limited to 'year2021/day12')

diff --git a/year2021/day12/part1.clj b/year2021/day12/part1.clj
new file mode 100644
index 0000000..cdd4a43
--- /dev/null
+++ b/year2021/day12/part1.clj
@@ -0,0 +1,27 @@
+(require '[clojure.string :as str])
+
+(def caves (->> (slurp "./in")
+           (str/split-lines)
+           (map #(str/split % #"-"))
+           (map (partial map str))
+           (#(concat % (map reverse %)))
+           ))
+
+(defn get-caves-forward [klst]
+  (map #(cons (second %) klst)
+    (filter
+      #(or (< (int (first (second %))) 96)
+           (not-any? (partial = (second %)) klst))
+      (filter #(= (first %) (first klst)) caves)
+      )))
+
+(loop [lst (get-caves-forward ["start"]) ms '()]
+  (let [nxt (->> lst
+                 (map get-caves-forward)
+                 (apply concat))
+        mtchs  (concat ms (filter #(= (first %) "end") nxt))
+        nxtlst (filter #(not= (first %) "end") nxt)]
+    (if (empty? nxtlst)
+      (println (count mtchs))
+      (recur nxtlst mtchs))))
+
diff --git a/year2021/day12/part2.clj b/year2021/day12/part2.clj
new file mode 100644
index 0000000..06b2bcd
--- /dev/null
+++ b/year2021/day12/part2.clj
@@ -0,0 +1,50 @@
+(require '[clojure.string :as str])
+(require '[clojure.core.reducers :as r])
+
+; Build list of cave connections:
+(def caves (->> (slurp "./in")
+           (str/split-lines)
+           (map #(str/split % #"-"))
+           (map (partial map str))
+           (#(concat % (map reverse %)))
+           ))
+
+; Try to help execution speed by memoizing cave searches:
+(def search-caves
+  (memoize (fn [id]
+    (filter
+      #(and (= (first %) id)
+            (not (str/starts-with? (second %) "start")))
+      caves
+      ))))
+
+; Given current path 'path', return a list of valid paths that branch
+; from 'path'. Note, paths are stored in reverse order.
+(defn get-caves-forward [path]
+  (r/map #(cons (second %) path)
+    (r/filter
+      (fn [cv]
+        (or
+          ; Always allow uppercase paths
+          (< (int (first (second cv))) 96)
+          ; Or, allow lowercase paths that have never been visited
+          (not-any? #(= % (second cv)) path)
+          ; Or, allow one duplicate if there are none yet
+          (apply distinct? (filter #(= (str/lower-case %) %) path))))
+      ; Only work with paths that we connect to
+      (search-caves (first path))
+      )))
+
+(loop [paths (into [] (get-caves-forward ["start"])) complete-paths 0]
+  (let [results (->> paths
+                     (r/mapcat get-caves-forward)
+                     (r/foldcat)
+                     (r/reduce
+                       (fn [r b] (if (not= (first b) "end")
+                                   (update r :next-paths #(conj % b))
+                                   (update r :complete-counts inc)))
+                       {:next-paths [] :complete-counts complete-paths}))]
+    (println (results :complete-counts))
+    (when-not (empty? (results :next-paths))
+      (recur (results :next-paths) (results :complete-counts)))))
+
-- 
cgit v1.2.3