blob: 06b2bcd22129e5c6a677941dc45509f1a11a1a85 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
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)))))
|
