src/2024/day19.lisp

@@ -1,3 +1,4 @@
+
 (defpackage :aoc/2024/19
   (:use :cl :aoc :alexandria :trivia :lla)
   (:export
@@ -43,13 +44,72 @@ bbrgwb"))
 (defparameter sample-data 
   (parse-input sample-text))
 
-(defvar *pattern-cache* (make-hash-table :test #'equal))
+(defstruct node
-(defvar *valid-cache* (make-hash-table :test #'equal))
+  name
-(defvar *possible-cache* (make-hash-table :test #'equal))
+  terminates
+  next)
+
+(defun towel-tree (towels word)
+  (let ((towel-tree (make-hash-table))
+	(terminates nil))
+    (loop
+      for towel in towels
+      if (emptyp towel
+	do (setf terminates t)
+      else
+	do (setf (gethash (char towel 0) towel-tree)
+		 (sort
+		  (let ((r (subseq towel 1)))
+		    (cons r (gethash (char towel 0) towel-tree)))
+		  #'(lambda (a b)
+		      (cond
+			((< (length a) (length b)) t)
+			((> (length a) (length b)) nil)
+			(t (string-lessp a b)))
+		      ))))
+    (loop
+      for k being the hash-keys in towel-tree
+      for v being the hash-values in towel-tree
+      do (setf (gethash k towel-tree) (towel-tree v (concatenate 'string word (list k))))      
+      )
+    (make-node
+     :name word
+     :terminates terminates
+     :next towel-tree)))
+
+(defun show-tree (tree &optional (depth 0))
+  (loop
+    for k being the hash-keys in (node-next tree)
+    for v being the hash-values in (node-next tree)
+    do (format t "~v@{~A~:*~}" depth "  ")
+       (format t "~A(~A)~%" k (if (node-terminates v) " OK" ""))
+       (show-tree  v (1+ depth))))
+
+(defun valid-pattern-p-old (og-tree pattern)
+  (defun check (tree pattern word words)
+    (let ((terminate (node-terminates tree)))
+      (if (emptyp pattern)
+	  terminate
+	  (let* ((c (char pattern 0))
+		 (np (subseq pattern 1))
+		 (nw (concatenate 'string word (list c))))
+	    (or
+	     (if-let ((nt (gethash c (node-next tree))))
+	       (check nt np nw words))
+	     (and terminate
+		  (if-let ((nt (gethash c (node-next og-tree))))
+		    (check nt np "" (cons word words))
+		    ))
+	     )))))
+  (check og-tree pattern "" '()))
+
+(defvar *patterns* (make-hash-table :test #'equal))
+(defvar *valid-patterns* (make-hash-table :test #'equal))
+(defvar *possible-patterns* (make-hash-table :test #'equal))
 (defun reset-patterns ()
-  (setf *pattern-cache* (make-hash-table :test #'equal))
+  (setf *patterns* (make-hash-table :test #'equal))
-  (setf *valid-cache* (make-hash-table :test #'equal))
+  (setf *valid-patterns* (make-hash-table :test #'equal))
-  (setf *possible-cache* (make-hash-table :test #'equal))
+  (setf *possible-patterns* (make-hash-table :test #'equal))
   )
 
 (defun string-prefix-p (prefix string)
@@ -59,20 +119,20 @@ bbrgwb"))
 
 (defun remaining-patterns (towels pattern)
   (or
-   (gethash pattern *pattern-cache*)
+   (gethash pattern *patterns*)
    (let ((remaining (loop
 		      for towel in towels
 		      if (string-prefix-p towel pattern)
 			collect (subseq pattern (length towel))
 		      )))
-     (setf (gethash pattern *pattern-cache*) remaining))))
+     (setf (gethash pattern *patterns*) remaining))))
 
 (defun valid-pattern-p (towels pattern)
   (multiple-value-bind (is-valid found)
-      (gethash pattern *valid-cache*)
+      (gethash pattern *valid-patterns*)
     (if found
 	is-valid
-	(setf (gethash pattern *valid-cache*)
+	(setf (gethash pattern *valid-patterns*)
 	      (if (emptyp pattern)
 		  t
 		  (if-let (ps (remaining-patterns towels pattern))
@@ -86,7 +146,7 @@ bbrgwb"))
 (defun towels-to-regex (onsen)
   (format nil "^(~{~A~^|~})*$" (onsen-towels onsen)))
 
-(defun valid-cache (onsen)
+(defun valid-patterns (onsen)
   (reset-patterns)
   (loop
     for pattern in (onsen-patterns onsen)
@@ -94,11 +154,12 @@ bbrgwb"))
       collect pattern))
 
 (defun possible-patterns (towels pattern)
-  (multiple-value-bind (n found)
+  (multiple-value-bind (is-valid found)
-      (gethash pattern *possible-cache*)
+      (gethash pattern *possible-patterns*)
+    (format t "~A ~A ~A~%" pattern is-valid found)
     (if found
-	n
+	(if is-valid 1 0)
-	(setf (gethash pattern *possible-cache*)
+	(setf (gethash pattern *possible-patterns*)
 	      (if (emptyp pattern)
 		  1		  
 		  (if-let (ps (remaining-patterns towels pattern))
@@ -111,14 +172,10 @@ bbrgwb"))
     ))
 
 (defun part1 (onsen)
-  (format nil "~A" (length (valid-cache onsen))))
+  (format nil "~A" (length (valid-patterns onsen))))
 
 (defun part2 (data)
-  (reset-patterns)
+  (length data))
-  (format nil "~A"
-	  (loop for p in (onsen-patterns data)
-		for n = (possible-patterns (onsen-towels data) p)
-		sum n)))
 
 (defun solve-day ()
   (format t "part1: ~A~%" (part1 input-data))

tests/2024/day19-test.lisp

@@ -64,13 +64,21 @@
 
   )
 
+
+
+(define-test test-bar
+  :parent suite-2024-19
+  )
+
+
+
 (define-test+run test-part1
                  :parent suite-2024-19
                  (is equal "6" (part1 sample-data)))
 
 (define-test+run test-part2
                  :parent suite-2024-19
-  (is equal "16" (part2 sample-data)))
+                 (is equal nil (part2 sample-data)))
 
 (defun run-tests ()
   (test 'suite-2024-19))