init day12 part 1

2024/src/core.clj

@@ -43,23 +43,23 @@
 
 (defn mmap
   "map map f coll"
-  [f coll]
-  (map (partial map f) coll))
+  [f & colls]
+  (apply map (partial map f) colls))
 
 (defn mmapv
   "mapv mapv f coll"
-  [f coll]
-  (mapv (partial mapv f) coll))
+  [f & colls]
+  (apply mapv (partial mapv f) colls))
 
 (defn mmmap
   "map map map f coll"
-  [f coll]
-  (map (partial map (partial map f)) coll))
+  [f & colls]
+  (apply map (partial map (partial map f)) colls))
 
 (defn mmmapv
   "mapv mapv mapv f coll"
-  [f coll]
-  (mapv (partial mapv (partial mapv f)) coll))
+  [f & colls]
+  (apply mapv (partial mapv (partial mapv f)) colls))
 
 (defn partition-by-counts [counts coll]
   (->> counts
@@ -68,3 +68,21 @@
                    [(conj acc a) b]))
                [[] coll])
        first))
+
+(defn update-last [v f & args]
+  (let [idx (dec (count v))]
+    (apply update v idx f args)))
+
+(defn partition-by-range-gap [sorted-nums]
+  (:acc (reduce (fn [{acc :acc
+                      a :last}
+                     el]
+                  (if (= el (inc a))
+                    {:acc (update-last acc conj el)
+                     :last el}
+                    {:acc (conj acc [el])
+                     :last el}))
+                {:acc [[(first sorted-nums)]]
+                 :last (first sorted-nums)}
+                (rest sorted-nums))))
+

2024/src/day12.clj

@@ -0,0 +1,50 @@
+(ns day12
+  (:require
+   [clojure.set :as s]
+   [core :as c]
+   [input-manager :refer [get-input]]))
+
+(def input (c/map-by-coords (get-input 12)))
+
+(def cardinal-offsets [[0 1] [0 -1] [1 0] [-1 0]])
+(defn steps [loc]
+  (c/mmap + (repeat loc) cardinal-offsets))
+(defn steps-that-meet-perimeter [loc]
+  (let [c (input loc)]
+    (->> (steps loc)
+         (filter (comp (partial not= c) input)))))
+
+(defn get-shape [loc]
+  (let [c (input loc)]
+    (loop [acc #{loc}
+           seen #{}
+           [loc & locs] #{loc}]
+      (if (nil? loc)
+        acc
+        (let [new-locs (->> (steps loc)
+                            (filter #(= (input %) c))
+                            (filter #(not (seen %))))]
+          (recur
+           (into acc new-locs)
+           (conj seen loc)
+           (into locs new-locs)))))))
+
+(defn get-perimeter-count [shape]
+  (->> shape
+       (map (juxt identity steps-that-meet-perimeter))
+       (filter #(seq (second %)))
+       (map #(count (second %)))
+       (reduce +)))
+
+(defn get-ans [get-perimeter-value]
+  (loop [acc 0
+         [loc & to-see] (set (keys input))]
+    (if (nil? loc)
+      acc
+      (let [shape (get-shape loc)]
+        (recur (+ acc (* (count shape)
+                         (get-perimeter-value shape)))
+               (s/difference (set to-see) (set shape)))))))
+
+;; part 1
+(get-ans get-perimeter-count)