Advent of Code day 2

AOC2023d2.clj

(ns y2023.d2)

(def input (->> "input/2023/2.txt"
                (slurp)))

(def cube-limits {:red 12 , :green 13, :blue 14})

(defn legal-game? [game]
  (= cube-limits (merge-with max game cube-limits)))

(defn cubetxt->kv [cubetxt]
  {(keyword (re-find #"blue|green|red" cubetxt))
   (parse-long (re-find #"\d+" cubetxt))})

(defn game-txt->map [game-txt]
  (reduce conj (map cubetxt->kv (re-seq #"\d+ \w+" game-txt))))

(defn parse-game [game-line]
  (let [[game-label cube-sets-text] (-> game-line
                                      (clojure.string/split #":"))
         game-number (parse-long (re-find #"\d+" game-label))
         cube-sets (-> cube-sets-text
                       (clojure.string/split #";"))
         game-maps  (->> cube-sets
                         (map game-txt->map)
                         (map legal-game?)
                         vec)]
      {game-number (every? true? game-maps)}))

(defn solve-1 [input]
  (let [game-list (clojure.string/split-lines input)]
    (->> game-list
         (map parse-game)
         (reduce conj)
         (filter #(val %))
         keys
         (reduce +))))

(comment (solve-1 input))
 ;;2369 is correct)

(defn parse-game2 [game-line]
  (let [[game-label cube-sets-text] (-> game-line
                                        (clojure.string/split #":"))
        cube-sets (-> cube-sets-text
                      (clojure.string/split #";"))
        game-powers  (->> cube-sets
                          (map game-txt->map)
                          (apply merge-with max)
                          vals
                          (reduce *))]
     game-powers))

(defn solve-2 [input]
  (let [game-list (clojure.string/split-lines input)]
    (->> game-list
         (map parse-game2)
         (reduce +))))

(comment ( solve-2 input))
;;66363