Clojurians Log v2

https://gitlab.com/maximoburrito/advent2021/-/blob/main/src/day14/main.clj so ugly. I hope my eyes don't bleed when I try to read this in the morning

https://github.com/skazhy/advent/blob/master/src/advent/2021/day14.clj

Btw,

(->> foo
     ((juxt #(apply max (vals %)) #(apply min (vals %)))))

(->> (vals foo)
     (apply (juxt max min))

https://github.com/axelarge/advent-of-code/blob/master/src/advent_of_code/y2021/day14.clj

That’s a super clean and short solution @karlis

https://github.com/zelark/AoC-2021/blob/main/src/zelark/aoc_2021/day_14.clj

I had a LOT of issues with this one! Thanks to the people on here who helped, love you guys!

(ns stuartstein777.2021.day14
  (:require [clojure.string :as str]))

(defn parser [line]
  {(subs line 0 2) [(str (subs line 0 1) (subs line 6))
                    (str (subs line 6) (subs line 1 2))]})

(defn solve [a b m]
  (->
   (reduce-kv (fn [acc [k1 k2] v]
                (as-> acc o
                  (merge-with + o {k1 v})
                  (merge-with + o {k2 v}))) {} m)
   (update a inc)
   (update b inc)))

(defn react [reactions m]
  (reduce (fn [acc [k v]]
            (let [[r1 r2] (reactions k)]
              (-> acc
                  (update r1 (fnil + 0) v)
                  (update r2 (fnil + 0) v)))) {} m))


(let [input            (->> (slurp "puzzle-inputs/2021/day14")
                            (str/split-lines))
      polymer-template (first input)
      reactions        (->> input
                            (drop 2)
                            (map parser)
                            (apply merge))
      reactors         (->> (partial react reactions)
                            (repeat 40)
                            (apply comp))
      final-pairs      (->> (partition 2 1 polymer-template)
                            (map (partial apply str))
                            (frequencies)
                            (reactors))
      final-vals       (->> final-pairs
                            (solve (first polymer-template) (last polymer-template))
                            (vals)
                            (map #(/ % 2)))
      max-c            (apply max final-vals)
      min-c            (apply min final-vals)]
  (- max-c min-c))

I've spend too much time figuring out what to memoize https://github.com/nbardiuk/adventofcode/blob/master/2021/src/day14.clj

1ms / 4ms. Similar to others. Writeup: https://github.com/tschady/advent-of-code/blob/main/doc/2021.adoc#aoc2021d14 code: https://github.com/tschady/advent-of-code/blob/main/src/aoc/2021/d14.clj

More fun with matrices, so my part 2 is fast for once: Edit: Relatively fast 😓 https://github.com/RedPenguin101/aoc2021/blob/main/clojure/src/aoc2021/day14.clj https://github.com/RedPenguin101/aoc2021/blob/main/day14.md

and me: https://github.com/genmeblog/advent-of-code/blob/master/src/advent_of_code_2021/day14.clj

https://github.com/kconner/advent-of-code/blob/master/2021/14a.clj, https://github.com/kconner/advent-of-code/blob/master/2021/14b.clj. Big computations over a narrow domain are ideal for memoization!

on the verbose side: https://samadams.dev/2021/12/14/advent-of-code-day-14.html

Looking at @karlis and @zelark solutions — why don’t you need to bump the count for (first template) in addition to (last template)?

Oh but in this case, I could have done one order better by using a multiply instead of memoization's many adds. I didn't use the fact that counting squashes a dimension to its fullest advantage

@sam.h.adams a good question, bc we get only the first letter from the pairs. By doing it you miss only the last letter in the the last pair. I’ll give you an example of it. Original template: NNCB. After split into pairs it looks like

NN 1
NC 1
CB 1

NC 1
CN 1
NB 1
BC 1
HB 1

I have a solution

But I don't understand why it works :D

I just noticed that I was getting roughly double the answer

Ah I got it now!

Double counting all letters except the ones at the beginning or the end

@zelark I see now, thanks for the explanation 🙂

https://github.com/euccastro/advent-of-code-2021/blob/main/day14.clj

same idea as many of yours, just with some uglier ends 🙂

I went too far with threading :D

in the end I made my life harder creating the new pairs beforehand

https://github.com/kfirmanty/advent-of-code-2021/blob/main/src/day14.clj must admit - took me longer than it should have. the first part was a breeze but the second one not so much 😄 I should have remembered a lesson from day6 to calculate final solution as I go through iterations instead of trying to reduce it at the end. At the beginning though that there might be some formula to growth or maybe substrings repeat but nope, just wasted time 😄

for a lot of these, the hint is “OK, the final answer only wants counts, not the whole string, so what don’t we need to track?”

nicely done!

got my first clojure monkeypatch in there too:

(in-ns 'marginalia.parser)
(defn strip-docstring [_ raw] raw)
(in-ns 'blogify)

clojure is powerful!