simplify. refactor in terms of pt 2 solution

2024/src/day19.clj

@@ -1,85 +1,43 @@
 (ns day19
   (:require
-   [clojure.string :as str] ; [core :as c]
+   [clojure.string :as str]
-   input-manager
+   input-manager))
-   [orchard.pp :as pp]))
-
-(def sample-input "r, wr, b, g, bwu, rb, gb, br
-
-brwrr
-bggr
-gbbr
-rrbgbr
-ubwu
-bwurrg
-brgr
-bbrgwb")
 
 (let [[w _ & p]
-      #_(str/split-lines sample-input)
       (input-manager/get-input 2024 19)]
   (def words (into #{} (str/split w #", ")))
   (def puzzles p)
   (def word-sizes (->> words
                        (map count)
-                       distinct
+                       distinct)))
-                       sort
-                       reverse)))
 
-(defn p [x]
+(defn valid-combination-count
-  (println x)
-  x)
-
-(defn next-search-index [puzzle searched valid-subsets]
-  (if (every? (complement true?) searched)
-    0
-    (some->> valid-subsets
-             (map-indexed vector)
-             (filter second)
-             (filter (fn [[idx :as el]]
-                       (not (searched (inc idx)))))
-             last
-             first
-             inc)))
-
-(defn find-valid-subsets [puzzle search-idx valid-subsets]
-  (let [max-idx (count puzzle)]
-    (->> word-sizes
-         (map (partial + search-idx)) ; get end pos
-         (filter #(<= % max-idx))
-         (map (partial subs puzzle search-idx)) ;get substrings
-         (filter words)
-         (map (comp (partial + search-idx) dec count))
-         (reduce (fn [acc idx]
-                   (assoc acc idx true))
-                 valid-subsets))))
-
-(defn is-valid
   ([puzzle]
-   (is-valid puzzle
+   (valid-combination-count puzzle
-             (mapv (constantly false) puzzle)
+                            0
-             (mapv (constantly false) puzzle)
+                            1
-             0))
+                            (mapv (constantly 0) puzzle)))
-  ([puzzle searched valid-subsets n]
+  ;; dp is vec of ints which contains the count of combinations for substring from puzzle[0] and ending at puzzle[n]
-   (let [search-idx (next-search-index puzzle searched valid-subsets)]
+  ([puzzle pos weight dp]
-     (cond
+   (if (>= pos (count puzzle))
-       (or (not search-idx)
+     (last dp)
-           (= search-idx -1))
+     (let [dp' (->> (map (partial + pos) word-sizes)
-       false
+                    (filter (partial >= (count puzzle)))
-
+                    (map (partial subs puzzle pos))
-       (>= search-idx (count puzzle))
+                    (filter words)
-       true
+                    (map (comp dec count))
-
+                    (map (partial + pos))
-       :else
+                    (reduce (fn [acc idx] (update acc idx (partial + weight)))
-       (let [next-subsets (find-valid-subsets puzzle search-idx valid-subsets)]
+                            dp))]
-         (if (last next-subsets)
+       (recur puzzle (inc pos) (get dp' pos) dp')))))
-           true
-           (recur puzzle
-                  (assoc searched search-idx true)
-                  next-subsets
-                  (inc n))))))))
 
+;; part 1 solution
 (->> puzzles
-     (map is-valid)
+     (map valid-combination-count)
-     (filter identity)
+     (filter (partial < 0))
      count)
+
+;; part 2 solution
+(->> puzzles
+     (map valid-combination-count)
+     (apply +))