Merge branch 'master' of git.ajet.fyi:ajet/advent-of-code

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))