Import 2018

2018/01/solution.clj

@@ -0,0 +1,17 @@
+(require '[clojure.string :as str])
+
+(def data (map read-string (str/split-lines (slurp "input"))))
+
+(defn solution-1 []
+  (reduce + 0 data))
+
+(defn solution-2 []
+  (let [f (fn [[freq seen] cur]
+            (let [new (+ freq cur)]
+              (if (seen new)
+                (reduced [new seen])
+                [new (conj seen new)])))]
+    (first (reduce f [0 #{}] (cycle data)))))
+
+(print (format "Solution 1: %d\n" (solution-1)))
+(print (format "Solution 2: %d\n" (solution-2)))

2018/02/solution.clj

@@ -0,0 +1,35 @@
+(require '[clojure.string :as str])
+
+(def data (str/split-lines (slurp "input")))
+
+(defn checksum-diff [counts]
+  (let [values (vals counts)]
+    (map (fn [target] (if (some #(= % target) values) 1 0)) [2 3])))
+
+(defn drop-nth [n coll]
+  (concat
+   (take n coll)
+   (drop (inc n) coll)))
+
+(defn partial-batch [n coll]
+  (map #(apply str (drop-nth n %)) coll))
+
+(defn find-duplicate [coll]
+  (let [reduction (fn [[acc result] cur]
+                    (if (acc cur) (reduced [acc [cur]]) [(conj acc cur) nil]))]
+    (->> coll
+         (reduce reduction [#{} nil])
+         (last))))
+
+(defn solution-1 []
+  (->> data
+       (map #(checksum-diff (frequencies %)))
+       (reduce (fn [[a2 a3] [c2 c3]] [(+ a2 c2) (+ a3 c3)]) '(0 0))
+       (reduce *)))
+
+(defn solution-2 []
+  (let [length (count (first data))]
+    (->> (range 0 length)
+         (mapcat #(find-duplicate (partial-batch % data)))
+         (first))))
+

2018/03/solution.clj

@@ -0,0 +1,48 @@
+(require '[clojure.string :as str])
+
+(def data (str/split-lines (slurp "input")))
+
+(defn parse-line [line]
+  (let [[_ & captures] (re-matches #"#(\d+) @ (\d+),(\d+): (\d+)x(\d+)$" line)]
+    (zipmap [:id :x :y :width :height] (map read-string captures))))
+
+(defn claim-to-points [claim]
+  (for [x (range (claim :width))
+        y (range (claim :height))]
+    [(+ x (claim :x)) (+ y (claim :y))]))
+
+(defn claim-to-points-with-info [claim]
+  (assoc claim :points (claim-to-points claim)))
+
+(defn solution-1 [data]
+  (->> data
+       (map parse-line)
+       (mapcat claim-to-points)
+       (frequencies)
+       (vals)
+       (filter #(> % 1))
+       (count)))
+
+(defn unique-claim? [freqs claim]
+  (->> (claim :points)
+       (map #(= 1 (freqs %)))
+       (every? true?)))
+
+(defn find-unique-claim [claims]
+  (let [freqs (frequencies (mapcat #(% :points) claims))]
+    (->> claims
+         (filter #(unique-claim? freqs %))
+         (first))))
+
+(defn solution-2 [data]
+  (->> data
+       (map parse-line)
+       (map claim-to-points-with-info)
+       (find-unique-claim)
+       (#(% :id))))
+
+(solution-1 data)
+(solution-2 data)
+
+(print (format "Solution 1: %s\n" (solution-1 data)))
+(print (format "Solution 2: %s\n" (solution-2 data)))