do day 3

2017/src/day03.clj

@@ -0,0 +1,51 @@
+(ns day03
+  (:require input-manager))
+
+(def input (parse-long (input-manager/get-input-raw 2017 3)))
+
+(def directions [:right :up :left :down])
+(def to-the-left {:right :up
+                  :up :left
+                  :down :right
+                  :left :down})
+(def cardinal-dir-offsets {:right [1 0]
+                           :left [-1 0]
+                           :down [0 -1]
+                           :up [0 1]})
+
+(def all-offsets #{[1 0] [-1 0] [0 -1] [0 1] [1 1] [-1 -1] [1 -1] [-1 1]})
+
+(->> (loop [loc [1 0]
+            i 2
+            grid {[0 0] 1}
+            [dir :as dirs] (cycle directions)]
+       (if (< i input)
+         (let [left-loc (mapv + loc (cardinal-dir-offsets (to-the-left dir)))
+               grid' (assoc grid loc i)
+               i' (inc i)]
+           (if (contains? grid left-loc)
+             (recur (mapv + loc (cardinal-dir-offsets dir)) i' grid' dirs)
+             (recur left-loc i' grid' (rest dirs))))
+         loc))
+     (map abs)
+     (apply +))
+
+(->> (loop [loc [1 0]
+            grid {[0 0] 1}
+            [dir :as dirs] (cycle directions)]
+       (let [left-loc (mapv + loc (cardinal-dir-offsets (to-the-left dir)))
+             value (->> all-offsets
+                        (map (comp
+                              #(or (grid %) 0)
+                              #(mapv + % loc)))
+                        (reduce +))
+             grid' (assoc grid loc value)]
+         (cond
+           (> value input)
+           value
+
+           (contains? grid left-loc)
+           (recur (mapv + loc (cardinal-dir-offsets dir)) grid' dirs)
+
+           :else
+           (recur left-loc grid' (rest dirs))))))

2017/src/day07.clj

@@ -0,0 +1,67 @@
+(ns day07
+  (:require
+   [clojure.string :as str]
+   [core :refer [split-whitespace]]
+   [input-manager]))
+
+(def input
+  (->> (input-manager/get-input-raw 2017 7)
+       str/split-lines
+       (map (comp split-whitespace
+                  #(str/replace % #"," "")))))
+
+;; part 1
+(def base-node
+  (->> input
+       (filter (fn [[_ _ _ & children]] children))
+       (filter (fn [[node]]
+                 (empty? (filter (fn [[_ _ _ & children]]
+                                   (some #(= % node) children))
+                                 input))))
+       ffirst))
+
+(do
+  (def get-depth
+    (memoize (fn [node]
+               (let [[_ w-str _ & children] (first (filter (fn [[n]] (= node n))
+                                                           input))
+                     w (parse-long (subs w-str 1 (dec (count w-str))))]
+                 (apply + w (map get-depth children))))))
+  (def get-weight
+    (memoize (fn [node]
+               (let [w-str (->> input
+                                (filter (fn [[n]] (= node n)))
+                                first
+                                second)]
+                 (parse-long (subs w-str 1 (dec (count w-str))))))))
+  (def get-children
+    (memoize (fn [node] (->> input
+                             (filter (fn [[n]] (= node n)))
+                             first
+                             (drop 3))))))
+
+(defn get-children-data [node]
+  (map (juxt identity get-depth get-weight) (get-children node)))
+
+(defn get-counts [data]
+  (->> data
+         (map second)
+         frequencies
+         (sort-by second)))
+
+;; part 2
+(let [[bad-parent bad-node]
+      (loop [parent nil
+             node base-node]
+        (let [data (get-children-data node)
+              counts (get-counts data)
+              row (first (filter #(= (second %) (ffirst counts)) data))]
+          (if (= (count counts) 1)
+            [parent node]
+            (recur node (first row)))))
+      diff (->> bad-parent
+                get-children-data
+                get-counts
+                (map first)
+                (apply -))]
+  (- (get-weight bad-node) diff))

2017/src/day08.clj

@@ -0,0 +1,46 @@
+(ns day08
+  (:require
+   [clojure.string :as str]
+   [core]
+   [input-manager]))
+
+(def op {"inc" +
+         "dec" -})
+(def cond-op {"<" <
+              "<=" <=
+              ">" >
+              ">=" >=
+              "==" =
+              "!=" not=})
+(def input (map (comp
+                 (fn [[name operation num _ cond-name cond-operation cond-val]]
+                   [name
+                    (op operation)
+                    (parse-long num)
+                    cond-name
+                    (cond-op cond-operation)
+                    (parse-long cond-val)])
+                 core/split-whitespace)
+                (input-manager/get-input 2017 8)))
+
+(defn compute [acc [reg reg-op val cond-reg cond-op cond-val]]
+  (if (cond-op (acc cond-reg 0) cond-val)
+    (assoc acc reg (reg-op (acc reg 0) val))
+    acc))
+
+;; part 1
+(->> input
+    (reduce compute {})
+    (sort-by second)
+    last
+    second)
+
+;; part 2
+(->> input
+     (reductions compute {})
+     (mapcat identity)
+     set
+     (sort-by second)
+     last
+     second)
+

2017/src/day09.clj

@@ -0,0 +1,34 @@
+(ns day09
+  (:require [clojure.string :as str]
+            core
+            input-manager))
+
+(def input (input-manager/get-input-raw 2017 9))
+
+(defn sum-recursive-depths [s sum idx depth]
+  (if (>= idx (count s))
+    sum
+    (condp = (.charAt s idx)
+      \, (recur s sum (inc idx) depth)
+      \{ (recur s
+                (+ sum depth)
+                (inc idx)
+                (inc depth))
+      \} (recur s
+                sum
+                (inc idx)
+                (max (dec depth) 0)))))
+
+(defn exlam-canceler [s] (str/replace s #"!." ""))
+(def angle-bracket-regex #"<[^>]*>")
+
+(-> input
+    exlam-canceler
+    (str/replace angle-bracket-regex "")
+    (sum-recursive-depths 0 0 1))
+
+(->> input
+     exlam-canceler
+     (re-seq angle-bracket-regex)
+     (map #(- (count %) 2))
+     (reduce +))

2017/src/day11.clj

@@ -0,0 +1,27 @@
+(ns day11
+  (:require [core]
+            input-manager
+            [clojure.string :as str]))
+
+(def input (-> (input-manager/get-input-raw 2017 11)
+               (str/split #",")))
+
+(def offsets {"n" [0 1]
+              "ne" [0.5 0.5]
+              "se" [0.5 -0.5]
+              "s"  [0 -1]
+              "sw" [-0.5 -0.5]
+              "nw" [-0.5 0.5]})
+
+(defn distance-from-origin [pos]
+  (let [[x y] (map abs pos)]
+    (+ (* x 2) (- y x))))
+
+
+(->> input
+     (map offsets)
+     (reductions #(map + %1 %2) [0 0])
+     (map distance-from-origin)
+     ((juxt last (partial apply max)))
+     (zipmap [:part-one :part-two]))
+

2017/src/day12.clj

@@ -0,0 +1,34 @@
+(ns day12
+  (:require
+   [clojure.string :as str]
+   core
+   input-manager
+   [clojure.set :refer [difference]]))
+
+(def input (->> (input-manager/get-input 2017 12)
+                (map #(str/replace % #"," ""))
+                (map core/split-whitespace)
+                (map (fn [[a _ & rst]]
+                       [(parse-long a) (mapv parse-long rst)]))
+                (into {})))
+
+(defn group-from-start [start]
+  (loop [visited #{}
+         queue [start]]
+    (if-not (seq queue)
+      visited
+      (let [[curr & rst] queue
+            ns (filter (complement visited) (input curr))]
+        (recur (into visited ns)
+               (concat rst ns))))))
+
+;; part one
+(count (group-from-start 0))
+
+;; part two
+(loop [ks (into #{} (keys input))
+       i 0]
+  (if-not (seq ks)
+    i
+    (recur (difference ks (group-from-start (first ks)))
+           (inc i))))

2017/src/day13.clj

@@ -0,0 +1,58 @@
+(ns day13
+  (:require
+   [clojure.string :as str]
+   [core]
+   [input-manager]))
+
+(def lengths (->> (input-manager/get-input 2017 13)
+                  (map (comp #(mapv parse-long %)
+                             #(str/split % #": ")))
+                  (into {})))
+
+(defn move-sensor [{:keys [idx depth increasing-depth] :as sensor}]
+  (let [[keep-moving reverse-step] (if increasing-depth [inc dec] [dec inc])
+        depth' (keep-moving depth)]
+    (if (or (> depth' (dec (lengths idx)))
+            (< depth' 0))
+      (-> sensor
+          (update :depth reverse-step)
+          (update :increasing-depth not))
+      (assoc sensor :depth depth'))))
+
+(def initial-sensors (->> lengths
+                          keys
+                          (map #(hash-map :depth 0
+                                          :idx %
+                                          :increasing-depth true))))
+
+(defn is-spotted-by-sensors [acc pos]
+  (some #(when (and (= (:idx %) pos)
+                    (= (:depth %) 0))
+           %)
+        (:sensors acc)))
+
+(->> lengths keys (apply max) inc range
+     (reduce (fn [acc pos]
+               (let [spotted (is-spotted-by-sensors acc pos)]
+                 (-> acc
+                     (update :sensors (partial map move-sensor))
+                     (update :solution + (if spotted
+                                           (* pos (lengths pos))
+                                           0)))))
+             {:sensors initial-sensors
+              :solution 0})
+     :solution)
+
+(loop [i 0
+       start-val initial-sensors]
+  (if
+   (= true
+      (->> lengths keys (apply max) inc range
+           (reduce (fn [acc pos]
+                     (let [spotted (is-spotted-by-sensors acc pos)]
+                       (if spotted
+                         (reduced true)
+                         (update acc :sensors (partial map move-sensor)))))
+                   {:sensors start-val})))
+    (recur (inc i) (map move-sensor start-val))
+    i))

2024/src/day03.clj

@@ -1,37 +1,31 @@
 (ns day03
-  (:require [core :as c]
+  (:require [input-manager]
-            [input-manager :refer [get-input]]
             [clojure.string :as str]))
 
-(def input (str/join (get-input 3)))
+(def input (input-manager/get-input-raw 2024 3))
 
-(defn parse-muls
+(defn compute-muls [s]
-  "takes in a string containing mul instructions
+  (map (comp #(reduce * %)
-  returns list of parsed integral multiplication results"
+             #(map parse-long %)
-  [s]
+             #(str/split % #",")
-  (->> (c/get-match-groups #"mul\((\d{1,3}),(\d{1,3})\)" s)
+             #(subs % 4 (dec (count %)))) ;; remove `mul(` prefix and `)` suffix
-       (map #(map parse-long %))
+       s))
-       (map #(reduce * %))))
+
+(defn enforce-toggles [[el & rst]]
+  (cond (= el "do()")    (recur rst)
+        (= el "don't()") (recur (drop-while #(not= % "do()") rst))
+        el               (conj (lazy-seq (enforce-toggles rst)) el)))
 
 ;; part 1
 (->> input
-     parse-muls
+     (re-seq #"mul\(\d{1,3},\d{1,3}\)")
+     compute-muls
      (reduce +))
 
 ;; part 2
 (->> input
-     (c/re-pos #"mul\((\d{1,3}),(\d{1,3})\)|(do\(\))|(don't\(\))")
+     (re-seq #"mul\(\d{1,3},\d{1,3}\)|do\(\)|don't\(\)")
-     (sort-by key)
+     enforce-toggles
-     (reduce
+     compute-muls
-      (fn [acc [_idx instr]]
+     (reduce +))
-        (cond
-          (.startsWith instr "mul") (if (:on acc)
-                                      (update acc :val
-                                              + (->> instr parse-muls first))
-                                      acc)
-          (.startsWith instr "don't") (assoc acc :on false)
-          (.startsWith instr "do") (assoc acc :on true)))
-      {:on true
-       :val 0})
-     :val)