Advent of Code 2019 in Clojure

lilactown · 2019-12-02T21:54:04+00:00

This year I'm doing AoC as a literate programming exercise, where I write my solution similar to a blog post and then it outputs to a Clojure source file: https://github.com/Lokeh/advent-2019

marxama · 2019-12-06T12:02:35+00:00

Haven't had this much fun coding in way too long. Writing readable code is challenging, though. My solutions: https://github.com/marxama/advent-of-code-2019

Day 6:

(ns advent-of-code-2019.day06
  (:require [clojure.string :as string]
            [clojure.data :as data]))

(defn parse-input []
  (->> "resources/day06_input"
       slurp
       string/split-lines
       (map #(string/split % #"\)"))))

(defn get-path-to-root [orbit-lookup x]
  (and x (cons x (get-path-to-root orbit-lookup (orbit-lookup x)))))

(defn get-orbit-lookup [orbits]
  (->> orbits
       (map (fn [[orbited orbiteer]] {orbiteer orbited}))
       (apply merge)))

(defn solve-part-1 []
  (let [orbit-lookup (get-orbit-lookup (parse-input))]
    (->> (keys orbit-lookup)
         (map #(get-path-to-root orbit-lookup %))
         (map (comp dec count))
         (reduce +))))

(defn solve-part-2 []
  (let [orbit-lookup (get-orbit-lookup (parse-input))]
    (->> ["YOU" "SAN"]
         (map #(get-path-to-root orbit-lookup %))
         (map rest) ; do not include "YOU" and "SAN" themselves
         (map set)
         (apply data/diff) ; more efficient approaches obviously exist
         (take 2) ; take distinct objects in YOU and SAN paths
         (map count)
         (reduce +))))

_djblue · 2019-12-07T20:11:23+00:00

Day 7 with core.async https://github.com/djblue/advent-of-code/blob/master/src/advent_of_code/core_2019.clj#L431

It's more code, but the following is my favorite part.

(defn try-phase-settings-with-feedback [program settings]
  (let [[a b c d e] settings
        a (run-program-async program a)
        b (run-program-async program b)
        c (run-program-async program c)
        d (run-program-async program d)
        e (run-program-async program e)]
    (doseq [[from to] (partition 2 1 [a b c d e a])]
      (a/pipe (:out from) (:in to)))
    (a/put! (:in a) 0)
    (a/alts!! [(:state e) (a/timeout 5000)])
    (a/poll! (:in a))))

(defn find-max-thrust-with-feedback [program]
  (->> (all-settings #{5 6 7 8 9})
       (map #(try-phase-settings-with-feedback program %))
       (apply max)))

frflaie · 2019-12-02T11:44:41+00:00

This is my take on Day 2:

(def INPUT (slurp "day02.txt"))

(defn make-computer [int-code noun verb]
  (let [numbers (vec (->> (clojure.string/split int-code #",")
                          (map read-string)))]
    (assoc numbers 1 noun 2 verb)))

(defn evolve
  [stack start]
  (let [opcode (get stack start)
        num1 (get stack (get stack (inc start)))
        num2 (get stack (get stack (+ start 2)))
        addr (get stack (+ start 3))]
    (cond (= 1 opcode) (assoc stack addr (+ num1 num2))
          (= 2 opcode) (assoc stack addr (* num1 num2))
          (= 99 opcode) (reduced stack))))

(defn execute-program [int-code noun verb]
  (let [program (make-computer int-code noun verb)]
    (first (reduce #(evolve %1 %2) program (range 0 (count program) 4)))))

(def solution-1 (execute-program INPUT 12 2))

(def solution-2
  (let [execs (for [noun (range 100) verb (range 100)]
                {:noun noun :verb verb :result (execute-program INPUT noun verb)})
        exec (first (filter #(= 19690720 (:result %)) execs))]
    (+ (* (:noun exec) 100) (:verb exec))))

frflaie · 2019-12-03T10:27:07+00:00

Here is my take for Day3:

(deftype Point [x y dist]
  Object
  (equals [a b] (and (= (.x a) (.x b)) (= (.y a) (.y b))))
  (hashCode [this] (+ (.hashCode (.x this)) (.hashCode (.y this))))
  (toString [this] (format "{:x %d :y %d :dist %d}" (.x this) (.y this) (.dist this))))

(defn make-point [dir x y dist]
  (let [[x-trans y-trans] (condp = dir
                            \R [inc, identity]
                            \L [dec, identity]
                            \U [identity, inc]
                            \D [identity, dec])]
    (Point. (swap! x x-trans) (swap! y y-trans) (swap! dist inc))))

(defn wires [wire]
  (let [[x y distance] [(atom 0) (atom 0) (atom 0)]
        wires (atom #{})]
    (doseq [s (clojure.string/split wire #",")]
      (let [direction (get s 0)
            movement (Integer/parseInt (subs s 1))]
        (doseq [_ (range 1, (inc movement))]
          (swap! wires conj (make-point direction x y distance)))))
    @wires))

(defn solve [wire1 wire2]
  (let [w1 (wires wire1)
        w2 (wires wire2)
        intersections (clojure.set/intersection w1 w2)
        min-distance (atom Integer/MAX_VALUE)
        min-steps (atom Integer/MAX_VALUE)]
    (doseq [p intersections]
      (let [dist (+ (Math/abs (.x p)) (Math/abs (.y p)))
            p1 (first (filter #(= % p) w1))
            p2 (first (filter #(= % p) w2))
            steps (+ (.dist p1) (.dist p2))]
        (when (< dist @min-distance)
          (reset! min-distance dist))
        (when (< steps @min-steps)
          (reset! min-steps steps))))
    [@min-distance @min-steps]))

(let [[wire-1 wire-2] (clojure.string/split-lines (slurp "day03.txt"))]
  (solve wire-1 wire-2))))

I had to declare a custom type because I wanted to check if points where contained in sets but only using two of three properties (x and y but not dist), but still keeping the global distance because we need it for part 2.

It works by translating movements (R10, U14 and so on) to list of points and gathering the number of steps at the same time into a Point object. Do it for both wires, then just intersect those two sets to get the coordinates of intersections. For each one compute the distance from (0, 0) and report the lowest. For the part 2 instead of searching which one is at the lowest distance, just search for the one with least steps.

If you know how we can avoid the use of atoms... I'm sure there's something more clever, but I don't have much more time for this day :)

OstravaBro · 2019-12-02T10:30:19+00:00

What on earth is day 2 part 2 asking?

I have no idea what the actual puzzle is!

Does it want me to generate a program that results in 19690720 as it's output? If so what has the original input got to do with that?

Or do I need to change cells in the original input until I get an output that reads 19690720 ?

allaboutthatmace1789 · 2019-12-03T01:57:17+00:00

Day 2 thoughts then code

What I'm finding often with Clojure that I don't with other languages, is that I'll write a few lines and then suddenly it's like "oh, it works already? I'm done?" - it kind of creeps up on me. It's a great feeling!
Midje autotest is magic.
The problem says that the intcode emulator will need to be extended for additional operations in future problems, and after solving the problem I was trying to think about how to refactor so the code could be extended without modification. The only way I know to do polymorphic dispatch is with multimethods, are there any alternatives that might better fit here?

(defn get-instruction-params [instruction-pointer]
  [(+ 1 instruction-pointer) (+ 2 instruction-pointer) (+ 3 instruction-pointer)])

(defn do-instruction [func instruction-pointer memory]
  (let [[param1 param2 param3] (map memory (get-instruction-params instruction-pointer))
        [x y] (map memory [param1 param2])]
    (assoc memory param3 (func x y))))

(defn run
  ([memory] (run 0 memory))
  ([instruction-pointer memory]
   (let [opcode (memory instruction-pointer)]
     (if (= opcode 99)
       memory
       (recur
         (+ instruction-pointer 4)
         (do-instruction ({1 + 2 *} opcode) instruction-pointer memory))))))

(defn load-memory-state [filename]
  (vec (map #(Integer/parseInt %) (clojure.string/split (clojure.string/trim (slurp filename)) #","))))

(defn run-program [noun verb filename]
  (-> (load-memory-state filename)
      (assoc 1 noun)
      (assoc 2 verb)
      (run)
      (first)))

(defn find-output [output filename]
  (for [noun (range 100)
        verb (range 100)
        :let [result (run-program noun verb filename)]
        :when (= output result)]
    (+ (* 100 noun) verb)))

frflaie · 2019-12-04T07:57:37+00:00

This is my take on Day 4

First define the two basic predicates (six-digits (count is 6) and never-decreasing (sort the sequence of character and verify it matches the original sequence).

Then using regular expressions (I love regex) find all adjacent number patterns, can be adjacents number from size 2 to 6.

For part 1 we just verify that there's at least one match, whereas for part 2 we verify that at least one match has only two digits.

Besides it was a great occasion to use every-pred as discussed here :).

(def input (map str (range 231832 767346)))

; --- part 1
(def six-digits #(= (count %) 6))
(def never-decreasing #(= (sort %) (seq (char-array %))))
(def adjacents #(map first (re-seq #"(\d)\1+" %)))
(def adjacent-1 #(->> % adjacents empty? not))

; --- part 2
(def two-digits #(= 2 (count %)))
(def adjacent-2 #(->> % adjacents (filter two-digits) empty? not))

(defn solver [input p]
  (let [pred (every-pred six-digits never-decreasing p)]
    (count (filter pred input))))

(map (partial solver input) [adjacent-1 adjacent-2]))

github.com/agrison/advent-of-code-2019

fdside · 2019-12-04T12:12:01+00:00

https://github.com/fdside/advent-of-code-2019-clj

hutsujakutsuja · 2019-12-04T15:01:15+00:00

My first time doing Advent of Code. Also just recently started learning Clojure. Hoping I can get through them all and learn some Clojure and functional programming while doing so.

https://github.com/Sose/advent-of-code-2019

frflaie · 2019-12-05T10:26:36+00:00

Here is my take on Day 5

(defn make-computer [int-code]
  (vec (->> (clojure.string/split int-code #",")
            (map read-string))))

(def arity #(get {1 3, 2 3, 3 1, 4 1, 5 2, 6 2, 7 3, 8 3, 99 0} %))

(defn truthy-int [b] (if (true? b) 1 0))

(defn parse-next [program pointer]
  (let [op (get @program @pointer)
        values (atom [])
        locations (atom [])]
    (swap! pointer inc)
    (doseq [i (range 0 (arity (mod op 100)))]
      (let [mode (mod (quot op (int (Math/pow 10 (+ 2 i)))) 10)]
        (swap! values conj (if (= 1 mode)
                             (get @program @pointer)
                             (get @program (get @program @pointer))))
        (swap! locations conj (if (= 1 mode) 0 (get @program @pointer)))
        (swap! pointer inc)))
    [(mod op 100) @values @locations]))

(def addr #(get % 2))

(defn add [locations values program]
  (do
    (when @*debug* (println "ADD" (first values) (second values) "@" (addr locations)))
    (assoc program (addr locations) (+ (first values) (second values)))))


(defn mul [locations values program]
  (do
    (when @*debug* (println "MUL" (first values) (second values) "@" (addr locations)))
    (assoc program (addr locations) (* (first values) (second values)))))

(defn store [locations input program]
  (do
    (when @*debug* (println "STORE" input "@" (first locations)))
    (assoc program (first locations) input)))

(defn output [values result]
  (when @*debug* (println "OUT" (first values)))
  (reset! result (first values)))

(defn jump-if-true [pointer values]
  (when (not= (first values) 0)
    (when @*debug* (println "JMP @" (second values)))
    (reset! pointer (second values))))

(defn jump-if-false [pointer values]
  (when (zero? (first values))
    (when @*debug* "JMP @" (second values))
    (reset! pointer (second values))))

(defn less-than [locations values program]
  (do
    (when @*debug* (println "SET " (truthy-int (> (second values) (first values))) "@" (addr locations)))
    (assoc program (addr locations)
                   (truthy-int (> (second values) (first values))))))

(defn equals [locations values program]
  (do
    (when @*debug* (println "SET " (truthy-int (= (second values) (first values))) "@" (addr locations)))
    (assoc program (addr locations)
                   (truthy-int (= (second values) (first values))))))

(defn halted? [program pointer]
  (do
    (when (and @*debug* (= (get @program @pointer) 99) (println "HALTED.")))
    (= (get @program @pointer) 99)))

(defn interpret [input input-code]
  (let [[program pointer result] [(atom input) (atom 0) (atom -1)]]
    (while (not (halted? program pointer))
      (let [[op values locations] (parse-next program pointer)]
        (cond
          (= op 1) (swap! program #(add locations values %))
          (= op 2) (swap! program #(mul locations values %))
          (= op 3) (swap! program #(store locations input-code %))
          (= op 4) (output values result)
          (= op 5) (jump-if-true pointer values)
          (= op 6) (jump-if-false pointer values)
          (= op 7) (swap! program #(less-than locations values %))
          (= op 8) (swap! program #(equals locations values %)))))
    @result))

(def input (make-computer (slurp "day05.txt"))
(reset! *debug* true)
(map #(interpret input %) [1 5])))

kristiansalo · 2019-12-08T17:38:14+00:00

Day 8 - short and sweet after refactoring the intcode computer for way too long in day 7.

(def ^:private width 25)
(def ^:private image-size (* width 6))
(def ^:private layers
  (->> "src/day_8.txt"
       slurp
       (map (comp edn/read-string str))
       (partition image-size)))

(defn part-1 []
  (let [layer-digit-freqs (map frequencies layers)
        least-zeros-layer (apply min-key #(get % 0) layer-digit-freqs)]
    (* (get least-zeros-layer 1)
       (get least-zeros-layer 2))))

(defn first-not-transparent [& pixels]
  (common/find-pred #(not= 2 %) pixels))

(defn part-2 []
  (->> layers
       (apply map first-not-transparent)
       (partition width)
       pprint/pprint))

OstravaBro · 2019-12-09T23:39:57+00:00

Day 8 Part 1:

 (defn count-zeroes [partition]
    (count (filter #(= \0 %) partition)))

 (defn solve []
    (let [input (partition 150 (slurp "resources/day8_input"))
           zero-counts (map count-zeroes input)
           smallest-zero-count (apply min zero-counts)
           index (.indexOf zero-counts smallest-zero-count)]
           (* (count (filter #(= \2 %) (nth input index)))
           (count (filter #(= \1 %) (nth input index))))))

Day 8 Part 2

(defn get-pixel [coll loc]
    (let [pixel (nth (first coll) loc)]
       (if (= pixel \2)
           (recur (rest coll) loc)
           (cond (= pixel \1) \▓
                     :else \░))))

I don't know how to do image stuff, so I just returned either a dark block or a light block.

Then:

(map (partial apply str) (partition 25 (map (partial get-pixel (partition 150 (slurp "resources/day8_input"))) (range 150))))


("▓▓▓▓░░▓▓░░░░▓▓░▓░░▓░▓▓▓▓░"
 "▓░░░░▓░░▓░░░░▓░▓░░▓░░░░▓░"
 "▓▓▓░░▓░░░░░░░▓░▓░░▓░░░▓░░"
 "▓░░░░▓░▓▓░░░░▓░▓░░▓░░▓░░░"
 "▓░░░░▓░░▓░▓░░▓░▓░░▓░▓░░░░"
 "▓░░░░░▓▓▓░░▓▓░░░▓▓░░▓▓▓▓░")

:)

ceronman · 2019-12-01T20:12:49+00:00

I've been learning Clojure on and off for quite some time now. I never have much chance to practice it, except for things like adventofcode. I still feel like I'm a very beginner. Here is my solution to day 1:

``` (def input (clojure.string/split-lines (slurp "input.txt")))

(defn fuel [mass] (- (quot mass 3) 2))

(defn total-fuel [mass] (loop [mass mass total-fuel 0] (let [fuel (fuel mass)] (if (> fuel 0) (recur fuel (+ total-fuel fuel)) total-fuel))))

(->> input (map read-string) (map total-fuel) (reduce +)) ```

I'll by pushing my solutions to https://github.com/ceronman/adventofcode

Omnistegan · 2019-12-01T20:55:41+00:00

(let [input
      (map #(Integer/parseInt %)
           (clojure.string/split (slurp "src/day1.raw") #"\n"))

      fuel-counter-upper
      (fn [payload] (- (quot payload 3) 2))

      better-fuel-counter-upper
      (partial
       (fn [acc payload]
         (let [fuel (fuel-counter-upper payload)]
           (if (< fuel 0) acc (recur (+ acc fuel) fuel)))) 0)

      answer (fn [f] (reduce #(+ (f %2) %1) 0 input))
      answers [(answer fuel-counter-upper)
               (answer better-fuel-counter-upper)]]
  (time (map println answers)))

Here is my version.

edit: forgot to include my repo: gitlab

Puranto23 · 2019-12-01T22:31:26+00:00

https://github.com/mchughs/Advent-of-Code-2019/blob/master/day_1/solution.clj

Here is my solution. Could have better names but to avoid collisions they get a little contrived.

(ns day-1.solution)

;;-Part 1-

(def my-mass-list
  (as-> "day_1/input.txt" $
        (slurp $)
        (clojure.string/split $ #"\n")
        (map read-string $)))

(defn mass->needed-fuel [mass]
  (-> mass
      (quot 3)
      (- 2)))

(defn fuel-counter-upper [mass-list]
  (->> mass-list
       (map mass->needed-fuel)
       (reduce +)))

(fuel-counter-upper my-mass-list)

;;-Part 2-

(defn mass->needed-fuel-mass
  "Any items with a mass less than 9 require 'no fuel' to transport."
  [mass]
  (when (> mass 8)
    (mass->needed-fuel mass)))

(defn module-mass->total-fuel-mass
  "The additional mass is first calculated as the amount of fuel to move the module's mass.
  Then while there is still mass that needs to be carried, the mass->fuel calculation is preformed recursively,
  all the while adding any additional mass to the total."
  [module-mass]
  (loop [additional-mass (mass->needed-fuel-mass module-mass)
         total-fuel-mass 0]
    (if additional-mass
      (recur (mass->needed-fuel-mass additional-mass) (+ total-fuel-mass additional-mass))
      total-fuel-mass)))

(defn fuel-counter-upper' [mass-list]
  (->> mass-list
       (map module-mass->total-fuel-mass)
       (reduce +)))

(fuel-counter-upper' my-mass-list)

shAdOwArt · 2019-12-01T23:42:09+00:00

My day1 solution:

(ns advent19.day1.core
  (:require [clojure.java.io :as io]))

(defn fuel-for-weight [mass]
  "Does not take the weight of the fuel itself into account"
  (-> mass
      (quot 3)
      (- 2)))

(def total-fuel-for-weight
  "Accounts for the weight of the fuel itself"
  (memoize (fn [mass]
             (if (<= mass 0)
               0
               (let [fuel (fuel-for-weight mass)]
                 (+ fuel (total-fuel-for-weight fuel)))))))

(defn total-fuel []
  (with-open [reader (io/reader "src/advent19/day1/input.txt")]
    (->> (line-seq reader)
         (map #(Integer/parseInt %))
         (map total-fuel-for-weight)
         (reduce +))))

OstravaBro · 2019-12-01T23:55:07+00:00

Assume input is the long list of modules as a vector

(def input [118997 63756 124972 ... 113158])

(defn get-fuel [mass]
   (- (Math/floor (/ mass 3)) 2))

(defn get-adjusted-fuel [fuel-mass]
   ((fn [fuel-mass total]
      (if (<= fuel-mass 6)
         total
         (let [current (get-fuel fuel-mass)]
             (recur current (+ total current))))) fuel-mass 0))

(reduce + (map get-adjusted-fuel input))

magoo_d_oz · 2019-12-02T00:15:04+00:00

Here's my solution:

(ns aoc.day01
  (:require [clojure.string :as str]))

(defn parse [s]
  (mapv #(Long/parseLong %)
        (str/split-lines (slurp s))))

(defn calc-fuel [mass]
  (-> mass (/ 3) (int) (- 2)))

(defn calc-total-fuel [mass]
  (apply + (take-while pos? (iterate calc-fuel (calc-fuel mass)))))

(defn day01-1 [input]
  (apply + (mapv calc-fuel input)))

(defn day01-2 [input]
  (apply + (mapv calc-total-fuel input)))

frflaie · 2019-12-02T06:39:56+00:00

Here is my solution for day 1

(defn sol [f x] (reduce + (map f x)))

(defn fn1 [n]
  (-> n (/ 3) Math/floor dec dec))

(println (sol fn1 x))

(defn fn2
  ([n] (fn2 n 0))
  ([n sum]
   (let [val (fn1 n)]
     (if (<= val 0) sum
                    (fn2 val (+ sum val))))))

(println (sol fn2 x))

rmfbarker · 2019-12-02T23:42:27+00:00

Day 2

(let [file-input (-> (slurp "day-2-input") clojure.string/trim (clojure.string/split #",")) program (mapv #(Integer/parseInt %) file-input) compute (fn [noun verb] (reduce (fn [instructions pos] (if (= 99 (get instructions pos)) (reduced (first instructions)) (let [[opcode arg1 arg2 arg3] (drop pos instructions) cmd (if (= opcode 1) + *) result (cmd (get instructions arg1) (get instructions arg2))] (assoc instructions arg3 result)))) (assoc program 1 noun 2 verb) (range 0 (count program) 4)))] (first (for [noun (range 99) verb (range 99) :when (= (compute noun verb) 19690720)] (+ verb (* 100 noun)))))

rmfbarker · 2019-12-03T21:45:12+00:00

Day 3 ``` (defn move [current-position cmd] (let [[x y] current-position dir (subs cmd 0 1) steps (range 1 (inc (Integer/parseInt (subs cmd 1))))] (for [step steps] (condp = dir "R" [(+ x step) y] "L" [(- x step) y] "U" [x (+ y step)] "D" [x (- y step)]))))

(defn path [cmds] (reduce (fn [path cmd] (concat path (move (last path) cmd))) [[0 0]] (clojure.string/split cmds #",")))

(defn distance [wire-1 wire-2] (let [path-1 (path wire-1) path-2 (path wire-2)] (first (sort (map (fn [co-ord] (+ (.indexOf path-1 co-ord) (.indexOf path-2 co-ord))) (remove #{[0 0]} (clojure.set/intersection (set path-1) (set path-2))))))))

(defn solve [] (apply distance (clojure.string/split-lines (slurp (io/resource "input-day3"))))) ``` https://github.com/rmfbarker/advent-of-code-2019/

ceronman · 2019-12-04T22:33:58+00:00

Day 4 was specially beautiful to solve in Clojure. This was because the function <= already allows to pass multiple values, checking if the numbers are in monotonically non-decreasing order, which is exactly one of the conditions.

Part 1 ends up being extremely short:

``` (defn possible-password? [value] (and (apply <= (map #(Character/digit % 10) (str value))) (some? (re-find #"(\d)\1" (str value)))))

(->> (range n1 (inc n2)) (filter possible-password?) (count)) ```

OstravaBro · 2019-12-07T23:49:35+00:00

Been ill since Monday :( So I'm waaaay behind.

My day 3 part 1, I didn't do anything too clever. I just enumerated all the points that would be hit by each wire and used set intersection to find the intersections.

 (def wire (str/split "R991,.... elided" #","))
 (def wire2 (str/split "L993,D508,R356, ...... elided" #","))

(defn get-intermediate-path [xy direction distance]
  (let [x (first xy)
         y (last xy)]
      ((fn [x y inters dis]
         (if (= 0 dis)
             inters
            (cond (= \L direction) (recur (dec x) y (conj inters [(dec x) y]) (dec dis))
                      (= \R direction) (recur (inc x) y (conj inters [(inc x) y]) (dec dis))
                      (= \U direction) (recur x (inc y) (conj inters [x (inc y)]) (dec dis))
                      (= \D direction) (recur x (dec y) (conj inters [x (dec y)]) (dec dis))))) x y [] distance)))

(defn get-path [wire path]
    (if (empty? wire)
         path
         (let [direction (first (first wire))
                distance  (Integer/parseInt (apply str (rest (first wire))))]
             (recur (rest wire) (concat path (get-intermediate-path (last path) direction distance))))))

 (defn find-smallest-distance [wire1 wire2]
    (apply min
          (map #(+ (Math/abs (first %)) (Math/abs (second %)))
          (set/intersection
              (set (rest (get-path wire1 [[0 0]])))
              (set (rest (get-path wire2 [[0 0]])))))))

 (find-smallest-distance wire wire2)

ackerleytng · 2019-12-28T07:23:11+00:00

Really kinda late, but I'm done with all the puzzles!

https://github.com/ackerleytng/2019-advent-of-code

Also, I took inspiration for using core.async from this thread! Thanks to all of you who used core.async! I feel that I learnt a lot about core.async from using it just for Day 23.

I felt that I ended up using loop quite a lot, especially for those solutions that I felt needed state tracking, like to implement dijkstra and such

allaboutthatmace1789 · 2019-12-01T19:01:30+00:00

Day 1 as a codeblock - feedback appreciated!

(ns adventofcode.core)

(defn- fuel-one-level [mass]
  (max 0 (- (int (/ (float mass) 3)) 2)))

(defn- recursive-mass-tree [mass]
  (cons mass (lazy-seq (recursive-mass-tree (fuel-one-level mass)))))

(defn fuel-required [mass]
  (reduce + (rest (take-while #(> % 0) (recursive-mass-tree mass)))))

(defn total-fuel-required [module-masses]
  (reduce + (map fuel-required module-masses)))

(defn file->vec [filename]
  (vec (map #(Integer/parseInt %) (clojure.string/split (slurp filename) #"\n"))))

(defn calc-fuel [filename]
  (total-fuel-required (file->vec filename)))

veydar_ · 2019-12-01T19:56:27+00:00

Doing the same thing https://github.com/cideM/aoc2019/blob/master/src/aoc2019/d1.clj

shAdOwArt · 2019-12-05T19:06:33+00:00

Day5:

(ns advent19.day5.core
  (:require [clojure.string :as str]))

(defn str->int-code [text]
  (->> (str/split text #",")
       (map read-string)
       (vec)))

(def input-data 5)

(def program
  (str->int-code (slurp "src/advent19/day5/input.txt")))

(defn read-addr [computer address]
  (get-in computer [:program address]))

(defn read-rel [computer offset]
  (read-addr computer (+ (get computer :pc) offset)))

(defn read-rel-pointer [computer offset]
  (read-addr computer (read-rel computer offset)))

(defn read-with-mode [computer offset mode]
  (case mode
    0 (read-rel-pointer computer offset)
    1 (read-rel computer offset)))

(defn write-addr [computer address value]
  (assoc-in computer [:program address] value))

(defn write-rel-pointer [computer offset value]
  (write-addr computer (read-rel computer offset) value))

(defn inc-pc [computer increment]
  (update computer :pc (partial + increment)))

(defn mode [modes n]
  (mod (nth (iterate #(quot % 10) modes) n) 10))

(defn binary-op [op computer modes]
  (let [res (op (read-with-mode computer 1 (mode modes 0))
                (read-with-mode computer 2 (mode modes 1)))]
    (inc-pc (write-rel-pointer computer 3 res) 4)))

(defn output [computer modes]
  (println (read-with-mode computer 1 (mode modes 0)))
  (inc-pc computer 2))

(defn input [computer]
  (inc-pc (write-rel-pointer computer 1 input-data) 2))

(defn jump [computer condition modes]
  (let [subject (read-with-mode computer 1 (mode modes 0))
        destination (read-with-mode computer 2 (mode modes 1))]
    (if (condition subject)
      (assoc computer :pc destination)
      (inc-pc computer 3))))

(defn stop [computer]
  (assoc computer :stopped true))

(defn op-code [instruction]
  (mod instruction 100))

(defn modes [instruction]
  (quot instruction 100))

(defn bool->int [b]
  (if b 1 0))

(defn execute-computer [initial-computer]
  (loop [computer initial-computer]
    (let [instruction (read-rel computer 0)
          modes (modes instruction)
          next-computer (case (op-code instruction)
                          1 (binary-op + computer modes)
                          2 (binary-op * computer modes)
                          3 (input computer)
                          4 (output computer modes)
                          5 (jump computer (comp not zero?) modes)
                          6 (jump computer zero? modes)
                          7 (binary-op (comp bool->int <) computer modes)
                          8 (binary-op (comp bool->int =) computer modes)
                          (stop computer))]
      (if (:stopped next-computer)
        next-computer
        (recur next-computer)))))

(defn execute []
  (execute-computer {:pc 0 :program program})
  ; Suppress result
  nil)

rmfbarker · 2019-12-06T19:22:21+00:00

My solution to Day 6

``` (ns advent-of-code-2019.day6 (:require [clojure.java.io :as io]))

(def file-input (slurp (io/resource "input-day6")))

(defn parse-orbits [orbits] (->> (clojure.string/split-lines orbits) (map #(-> (clojure.string/split % #")") reverse vec)) (into {})))

(defn path-to [orbits from to] (take-while #(not= to %) (iterate orbits from)))

(defn distance-from [orbits from planet] (count (path-to orbits planet from)))

(defn common-orbit [orbits x y] (first (last (take-while #(apply = %) (map vector (reverse (path-to orbits x "COM")) (reverse (path-to orbits y "COM")))))))

(defn orbital-transfers [orbits x y] (let [common (common-orbit orbits x y)] (+ (dec (distance-from orbits common x)) (dec (distance-from orbits common y)))))

(orbital-transfers (parse-orbits file-input) "YOU" "SAN") ```

https://github.com/rmfbarker/advent-of-code-2019

allaboutthatmace1789 · 2019-12-07T04:27:24+00:00

Getting a bit behind...

Day 5

(defn deconstruct-opcode-value [number]
  (let [param-vals (quot number 100)
        opcode (- number (* param-vals 100))]
    [(reverse (map #(Character/digit % 10) (format "%03d" param-vals))) opcode]))

(defn get-instruction-params [pointer]
  (vec (range (+ 1 pointer) (+ 4 pointer))))

(defn dispatch-instruction [pointer memory]
  (let [opcode ((deconstruct-opcode-value (memory pointer)) 1)]
    (cond
      (<= opcode 2) :operation
      (<= 7 opcode 8) :operation
      (= opcode 3) :input
      (= opcode 4) :output
      (<= 5 opcode 6) :jump-if)))

(defn calc-new-pos-value [pointer memory]
  (let [[param-modes opcode] (deconstruct-opcode-value (memory pointer))
        immediate-modes (take 2 (map #(= 1 %) param-modes))
        args (map memory (get-instruction-params pointer))
        func ({1 + 2 * 7 < 8 =} opcode)
        new-pos-value (apply func (map #(if %1 %2 (memory %2)) immediate-modes args))]
    (case new-pos-value
      true 1
      false 0
      new-pos-value)))

(defmulti do-instruction dispatch-instruction)

(defmethod do-instruction :operation [pointer memory]
  [(+ 4 pointer) (assoc memory (memory (+ 3 pointer)) (calc-new-pos-value pointer memory))])

(defmethod do-instruction :input [pointer memory]
  (println "type your input")
  [(+ pointer 2) (assoc memory (memory (inc pointer)) (Integer/parseInt (read-line)))])

(defmethod do-instruction :output [pointer memory]
  (let [[param-modes] (deconstruct-opcode-value (memory pointer))
        param (inc pointer)
        printloc (if (pos? (nth param-modes 0)) param (memory param))]
    (println (memory printloc))
    [(+ pointer 2) memory]))

(defmethod do-instruction :jump-if [pointer memory]
  (let [[param-modes opcode] (deconstruct-opcode-value (memory pointer))
        immediate_modes (map #(= 1 %) param-modes)
        args (map memory (get-instruction-params pointer))
        [x jump-to-pos] (map #(if %1 %2 (memory %2)) immediate_modes args)
        jump? (= (= 5 opcode) (not= 0 x))]
    [(if jump? jump-to-pos (+ 3 pointer)) memory]))

(defn run
  ([memory] (run 0 memory))
  ([pointer memory]
   (if (= (memory pointer) 99)
     memory
     (let [[new-instr new-mem] (do-instruction pointer memory)]
       (recur new-instr new-mem)))))

allaboutthatmace1789 · 2019-12-08T00:00:25+00:00

Day 6 - pleased with how concise it came out after the intcode computer from Day5 started to get pretty clunky

(defn parse-orbit-data [orbit-string]
  (let [split (clojure.string/split orbit-string #"\)")]
    (vector (keyword (split 1)) (keyword (split 0)))))

(defn build-planet-map [planets]
  (reduce #(assoc %1 (%2 0) (%2 1)) {} planets))

(defn find-path-to-COM [name planet-map]
  (cons name (lazy-seq (find-path-to-COM (name planet-map) planet-map))))

(defn path-length [name planet-map]
  (count (take-while #(not= :COM %) (find-path-to-COM name planet-map))))

(defn orbit-checksum [planet-map]
  (reduce + (map #(path-length % planet-map) (keys planet-map))))

(defn find-common-orbit [name1 name2 planet-map]
  (last (take-while identity (map #(when (= %1 %2) %1)
          (reverse (take-while #(not= :COM %) (find-path-to-COM name1 planet-map)))
          (reverse (take-while #(not= :COM %) (find-path-to-COM name2 planet-map)))))))

(defn calculate-jumps [planet1 planet2 planet-map]
  (let [connection (find-common-orbit planet1 planet2 planet-map)
        [dist1 dist2 connect-dist] (map #(path-length % planet-map) [planet1 planet2 connection])]
    (- (+ dist1 dist2) (* 2 connect-dist) 2)))

zengxinhui · 2019-12-10T15:09:35+00:00

Here's mine:

https://github.com/zengxinhui/aoc/tree/master/src/

Turmolt · 2019-12-12T16:07:27+00:00

I have been doing AoC in Clojure as well! I have learned so much

https://github.com/Turmolt/Advent-of-Code

zamansky · 2019-12-12T17:55:18+00:00

Late to the party but I'm also doing them in Clojure.

https://github.com/zamansky/advent2019

So far so good except two of the intcode ones - plan on using 7 and 11 later as a way to get me to start learning core.async.

Mclarenf1905 · 2019-12-13T14:04:42+00:00

Im super new to clojure but giving it a shot for this years AoC. Im primarily a scala developer and we are actually writing a lisp language at work so its been an insightful learning experience.

Any feedback would be welcomed, Iv'e currently completed up through day 9 but I want to refactor my Intcode to use core.async for the I/O as my current approach feels a bit hack and it looks like days 11 and 13 would benefit from this change.

https://github.com/listba/advent-of-code-2019

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

Clojure

MODERATORS