Clojurians Log v2

yeah, pleasant surprise! https://github.com/FelipeCortez/advent-of-code/blob/master/2021/10.clj

https://github.com/nbardiuk/adventofcode/blob/master/2021/src/day10.clj

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

Day 10 Part 1

(def scores {\} 1197
           \) 3
           \] 57
           \> 25137})

(defn parser [line]
  (map identity line))

(defn find-syntax-error [opens [f & r]]
  (if (empty? r)
    nil
    (cond (#{\{ \( \[ \<} f)
          (recur (conj opens f) r)

          (#{\} \) \] \>} f)   ;
          (if (= f (matching (peek opens)))
            (recur (pop opens) r)
            f))))

(->> (f/read-all-lines-and-parse "puzzle-inputs/2021/day10" parser)
     (map (partial find-syntax-error []))
     (remove nil?)
     (map scores)
     (reduce +))

This day is confusing calvas syntax highlighting!

I like your substitutions! Need to introduce some in emacs.

I noticed i'm using remove a lot

switching to transients is pretty easy 👌

hooray for reduced https://github.com/callum-oakley/advent-of-code/blob/main/src/aoc/2021/10.clj

Fun puzzle! https://github.com/RedPenguin101/aoc2021/blob/main/day10.md, and https://github.com/RedPenguin101/aoc2021/blob/main/clojure/src/aoc2021/day10.clj

This worked well for me:

(defn parse [l]
 (loop [line l]
   (let [new (-> line
                 (str/replace #"\[\]" "")
                 (str/replace #"\{\}" "")
                 (str/replace #"\<\>" "")
                 (str/replace #"\(\)" ""))]
     (if (= (count new) (count line))
       line
       (recur new)))))

Same stack based approach. I didn’t flag the results, just used the fact that if a coll is returned, it’s the unbalanced stack, if it’s a single char it’s the bad one. https://github.com/tschady/advent-of-code/blob/main/src/aoc/2021/d10.clj

I wonder if he threw the <, > in there just so you couldn’t use the clojure reader somehow

this is my regex approach

(defn fixed-point [f a]
  (let [r (f a)]
    (if (= r a)
      a
      (recur f r))))

(defn validate [line]
  (let [fp (fixed-point #(string/replace % #"\(\)|\[\]|\{\}|\<\>" "") line)
        invalid (re-find #"\)|\]|\}|\>" fp)]
    [invalid (map open->close (string/reverse fp))]))

https://samadams.dev/2021/12/10/advent-of-code-day-10.html

Lol => https://clojuredocs.org/clojure.core/pop#example-5a7e1ab7e4b0316c0f44f8b4

Well, that was a bit embarrasing how long it took to find the bug in (find-middle-score)😖 Part 2

(def scores {\} 3
           \) 1
           \] 2
           \> 4})

(def matcher {\{ \}
            \[ \]
            \< \>
            \( \)})

(defn get-remaining [open [c & r]]
  (if (nil? c)
    open
    (cond (#{\{ \[ \< \(} c)
          (recur (conj open c) r)

          (#{\} \] \> \)} c)
          (if (= c (matcher (peek open)))
            (recur (pop open) r)
            nil))))

(defn score [auto-completes]
  (reduce (fn [acc i] 
            (+ (* acc 5) (scores i))) 0 auto-completes))

(defn auto-complete [line]
  (map matcher line))

(defn get-middle-score [scores]
  (let [sorted-scores (sort scores)]
       (nth sorted-scores (dec (Math/ceil (/ (count scores) 2.0))))))

(->> (f/read-all-lines-and-parse "puzzle-inputs/2021/day10" parser)
     (map (partial get-remaining []))
     (remove nil?)
     (map auto-complete)
     (map reverse)
     (map score)
     (get-middle-score))

I found very surprising that this works just fine (nth [1 2 3] (/ 3 2))

i think because this casts it to int: https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/RT.java#L894

pretty cool!

Late to the party today.

https://github.com/kfirmanty/advent-of-code-2021 found day10 to be much easier than few last ones. Will check other people solution but I guess most used list as stack to keep track of opened parens

My day 10: https://gist.github.com/borkdude/b5cf0e9d2d8ab7c678d88e27a3357b33#file-aoc21_d10-clj

https://github.com/tjefferson08/advent-of-code/blob/main/2021/10/core.clj

Tweaked mine a little, both solutions run in about 1ms in babashka

today's puzzle seemed relatively mundane, and so does my solution: https://github.com/euccastro/advent-of-code-2021/blob/main/day10.clj

https://gitlab.com/maximoburrito/advent2021/-/blob/main/src/day10/main.clj

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

https://github.com/kconner/advent-of-code/blob/master/2021/10a.clj, https://github.com/kconner/advent-of-code/blob/master/2021/10b.clj. Feels good to me :)

part 1 (inspired by @peterc)

Can somebody compare the performance of it to stack based implementation?