Day 19 actually works

Author: abyala

src/advent_2020_clojure/day19.clj

@@ -1,6 +1,7 @@
 (ns advent-2020-clojure.day19
   (:require [clojure.string :as str]
-            [advent-2020-clojure.utils :as utils]))
+            [advent-2020-clojure.utils :as utils]
+            [clojure.set :as set]))
 
 (defn parse-rule [input]
   (let [[_ id rule-str] (re-matches #"(\d+): (.*)" input)]
@@ -12,30 +13,42 @@
 (defn parse-rules [rule-str]
   (->> rule-str str/split-lines (map parse-rule) (into {})))
 
-(defn word-combinations [[a-words b-words & others]]
-  (if (some? b-words)
-    (let [words (for [a a-words
-                      b b-words]
-                  (str a b))]
-      (word-combinations (cons words others)))
-    a-words))
+(defn match-length [rules word rule]
+  (let [{:keys [s paths]} (rules rule)]
+    (cond
+      (str/blank? word) nil
+      (some? s) (when (= s (subs word 0 (count s))) #{(count s)})
+      :else (->> (for [path paths]
+                   (reduce (fn [lengths id]
+                             (if (empty? lengths)
+                               #{}
+                               (->> (map (fn [length]
+                                           (->> (match-length rules (subs word length) id)
+                                                (keep identity)
+                                                (map (fn [p] (+ length p)))
+                                                set))
+                                         lengths)
+                                    (apply set/union))))
+                           #{0}
+                           path))
+                 (keep identity)
+                 (apply set/union)))))
 
-(defn valid-strings [rules id]
-  (let [{:keys [s paths]} (rules id)]
-    (if (some? s)
-      (list s)
-      (->> paths
-           (map (fn [path]
-                  (->> path
-                       (map #(valid-strings rules %))
-                       word-combinations)))
-           (apply concat)))))
+(defn valid? [rules word]
+  (some #(= % (count word)) (match-length rules word "0")))
 
 (defn part1 [input]
   (let [[rule-str message-str] (utils/split-blank-line input)
-        rules (parse-rules rule-str)
-        messages (str/split-lines message-str)
-        valids (set (valid-strings rules "0"))]
-    (->> messages
-         (filter #(valids %))
+        rules (parse-rules rule-str)]
+    (->> (str/split-lines message-str)
+         (keep #(valid? rules %))
+         count)))
+
+(defn part2 [input]
+  (let [[rule-str message-str] (utils/split-blank-line input)
+        rules (-> (parse-rules rule-str)
+                  (assoc "8" (second (parse-rule "8: 42 | 42 8")))
+                  (assoc "11" (second (parse-rule "11: 42 31 | 42 11 31"))))]
+    (->> (str/split-lines message-str)
+         (keep #(when (valid? rules %) %))
          count)))

test/advent_2020_clojure/day19_test.clj

@@ -2,9 +2,14 @@
   (:require [clojure.test :refer :all]
             [advent-2020-clojure.day19 :refer :all]))
 
-(def TEST_DATA "0: 4 1 5\n1: 2 3 | 3 2\n2: 4 4 | 5 5\n3: 4 5 | 5 4\n4: \"a\"\n5: \"b\"\n\nababbb\nbababa\nabbbab\naaabbb\naaaabbb")
+(def TEST_DATA_1 "0: 4 1 5\n1: 2 3 | 3 2\n2: 4 4 | 5 5\n3: 4 5 | 5 4\n4: \"a\"\n5: \"b\"\n\nababbb\nbababa\nabbbab\naaabbb\naaaabbb")
+(def TEST_DATA_2 "42: 9 14 | 10 1\n9: 14 27 | 1 26\n10: 23 14 | 28 1\n1: \"a\"\n11: 42 31\n5: 1 14 | 15 1\n19: 14 1 | 14 14\n12: 24 14 | 19 1\n16: 15 1 | 14 14\n31: 14 17 | 1 13\n6: 14 14 | 1 14\n2: 1 24 | 14 4\n0: 8 11\n13: 14 3 | 1 12\n15: 1 | 14\n17: 14 2 | 1 7\n23: 25 1 | 22 14\n28: 16 1\n4: 1 1\n20: 14 14 | 1 15\n3: 5 14 | 16 1\n27: 1 6 | 14 18\n14: \"b\"\n21: 14 1 | 1 14\n25: 1 1 | 1 14\n22: 14 14\n8: 42\n26: 14 22 | 1 20\n18: 15 15\n7: 14 5 | 1 21\n24: 14 1\n\nabbbbbabbbaaaababbaabbbbabababbbabbbbbbabaaaa\nbbabbbbaabaabba\nbabbbbaabbbbbabbbbbbaabaaabaaa\naaabbbbbbaaaabaababaabababbabaaabbababababaaa\nbbbbbbbaaaabbbbaaabbabaaa\nbbbababbbbaaaaaaaabbababaaababaabab\nababaaaaaabaaab\nababaaaaabbbaba\nbaabbaaaabbaaaababbaababb\nabbbbabbbbaaaababbbbbbaaaababb\naaaaabbaabaaaaababaa\naaaabbaaaabbaaa\naaaabbaabbaaaaaaabbbabbbaaabbaabaaa\nbabaaabbbaaabaababbaabababaaab\naabbbbbaabbbaaaaaabbbbbababaaaaabbaaabba")
 (def PUZZLE_DATA (slurp "resources/day19_data.txt"))
 
 (deftest part1-test
-  (is (= 2 (part1 TEST_DATA)))
+  (is (= 2 (part1 TEST_DATA_1)))
   (is (= 109 (part1 PUZZLE_DATA))))
+
+(deftest part2-test
+  (is (= 12 (part2 TEST_DATA_2)))
+  (is (= 301 (part2 PUZZLE_DATA))))