AOC 2023 Day 2 (Common Lisp)

(unless (find-package :cl-ppcre)
  (ql:quickload "cl-ppcre"))

(defparameter *red-max*   12)
(defparameter *green-max* 13)
(defparameter *blue-max*  14)

(defun colour-totals (colour-list)
  "Return a p-list of different 'hands' of colour cubes"
  (let ((red '())
        (blue '())
        (green '()))
    (dolist (item colour-list (list :red red :blue blue :green green))
      (cond ((string= (second item) "red") (push (parse-integer (first item)) red))
            ((string= (second item) "green") (push (parse-integer (first item)) green))
            ((string= (second item) "blue") (push (parse-integer (first item)) blue))))))

(defun make-game-list (str)
  (let ((game-num (multiple-value-bind (s match) (cl-ppcre:scan-to-strings "Game (\\d+):" str)
                    (aref match 0)))
        (colours (cl-ppcre:all-matches-as-strings "(\\d+)\\s(blue|green|red)" str))
        (colour-list '())
        (game-list '()))
    (dolist (item colours)
      (push (cl-ppcre:split "\\s" item) colour-list))
    (setf game-list (colour-totals colour-list))
    (setf (getf game-list :game) (parse-integer game-num))
    game-list))

(defun extract-game-info-from-file (filename)
  "Extract game number and totals of each colour cube"
  (let ((result '()))
    (with-open-file (stream filename)
      (loop for line = (read-line stream nil)
            while line do (push (make-game-list line) result)) )
    result))


(defun greater-than-limit (lst limit)
  "Check if any value in a list is greater than a limit"
  (some #'(lambda (val)
            (> val limit))
        lst))

(defun remove-impossible-games (games)
  "Make a new list of games that are possible given max constraints above"
  (remove-if #'(lambda (game)
                 (or (greater-than-limit (getf game :red) *red-max*)
                     (greater-than-limit (getf game :blue) *blue-max*)
                     (greater-than-limit (getf game :green) *green-max*)))
             games))

(defparameter *input* (extract-game-info-from-file "./input.txt"))
; (defparameter *input* (extract-game-info-from-file "./example1.txt"))
; (defparameter *input* (extract-game-info-from-file "./example2.txt"))

(defun solve-a (games)
  ;; Example 1 answer: 8
  (let ((answer 0))
    (dolist (game (remove-impossible-games games) answer)
      (incf answer (getf game :game)))))

(defun get-game-power (game)
  (let ((fewest-red (reduce #'max (getf game :red)))
        (fewest-blue (reduce #'max (getf game :blue)))
        (fewest-green (reduce #'max (getf game :green))))
    (* fewest-red fewest-blue fewest-green)))

(defun solve-b (games)
  ;; Example 2 answer: 2286
  (let ((list-of-powers '()))
    (dolist (game games list-of-powers)
      (push (get-game-power game) list-of-powers))
    (reduce #'+ list-of-powers)))

(defun solutions ()
  (format t "Part 1: ~A~%" (solve-a *input*))   ; My answer: 2207
  (format t "Part 2: ~A~%" (solve-b *input*)))  ; My answer: 62241