Clojurians Log v2

I did not realize that I could use the multi-arity of = .. thanks !

Hey I like your typeface! The ligature looks so amazing. What’s the typeface you’re using?

it looks like firacode

Yeah, it’s FiraCode by @tonsky https://github.com/tonsky/FiraCode

Thanks!

Can you copy the code, wondering what it does 🙂

hard coded vector of [-1, 0 1]

At compile time?

Depending on the n?

(defmacro adjacent [n]
  (let [ds (repeatedly n #(gensym "d"))
        bindings (mapcat #(-> [% [-1 0 1]]) ds)]
    `(for [~@bindings :when (not= 0 ~@ds)] [~@ds])))

(defn neighbours [adjacent loc]
  (map #(mapv + loc %) adjacent))

(partial neighbours (adjacent 3))

it calculates adjacent locations for n-dimension space.

You can use it like

(def neighbours-3d (partial neighbours (adjacent 3)))

(neighbours-3d [0 0 0])

Yeah, the for could be replaced by the list of literal of relative neighbor positions at compile time.

@vincent.cantin can you show how to to do that?

I am still at work, I will try to do that after.

I came up with this

(defmacro adjacent [n]
  (let [ds (repeatedly n #(gensym "d"))
        bindings (mapcat #(-> [% [-1 0 1]]) ds)]
    (eval `(vec (for [~@bindings :when (not= 0 ~@ds)] [~@ds])))))

you don’t need the eval, just evaluate the sequence (and put it in a vector) outside of the backtick.

oh .. I see, if you want to use for you can’t have a dynamic n , you will have to use map with recursion … or even better, comp/cartesian-product

well .. it works with eval so why not.

@zelark you can use this to generate the neighbors:

(defn adjacents [dimension]
  (-> (iterate (fn [coords]
                 (mapcat (fn [coord]
                           (map (fn [x]
                                  (conj coord x))
                                [-1 0 1]))
                         coords))
               [[]])
      (nth dimension)
      (->> (remove (fn [coord]
                     (every? #{0} coord))))
      vec))

#_(adjacents 2)

(defmacro neighbors [& coords]
  (let [adj (adjacents (count coords))]
    `(->> ~adj
          (mapv (partial mapv + ~(vec coords))))))

#_(macroexpand-1 '(neighbors x y))
#_(neighbors 5 10)

Yeah, it’s also a good option, I saw it in @nbardiuk’s solution. However, I’m happy with two different functions I have. The macro is just for fun.

btw, I found (defn ~name ~@pre-args ~args ~(apply (eval (list fn args expr)) args))` in clojure.core.

yeah, eval is ok during compile time

also, simple approach like this

(defn neighbours-4d [[x y z w]]
  (for [dx [-1 0 1] dy [-1 0 1] dz [-1 0 1] dw [-1 0 1] :when (not= 0 dx dy dz dw)]
    [(+ x dx) (+ y dy) (+ z dz) (+ w dw)]))

(defn neighbours [adjacent loc]
  (map #(mapv + loc %) adjacent))

I made another version, for fun:

(defmacro neighbors [& coords]
  (let [dimension (count coords)
        adj (adjacents dimension)
        coord-vars (repeatedly dimension #(gensym "coord"))
        local-vars (repeatedly dimension #(gensym "local"))]
    `(let [~@(interleave coord-vars coords)]
       (mapv (fn [[~@local-vars]]
               [~@(map (fn [lv cv]
                         `(+ ~lv ~cv))
                       local-vars
                       coord-vars)])
             ~adj))))

(neighbors 5 10)

Indeed!

That’s me !!!

I never really follow sample inputs, just use them to check if my algo gives the correct output for them

to get *second gold star

yes, the colors are not consistent, one receives two gold stars per day. But there are silver and gold stars on stats page https://adventofcode.com/2020/stats

To get the gold star for day 25 you don't have new puzzle, it is a bonus star for solving all puzzles of the year

Yes, but I prefer literals whenever it’s possible. Usually they are easier to read and catch.

you misread ... that's sarcasm

Ohh :)))

😁 less characters and less off by one errors

hahaha

i did the same

(juxt dec identity inc)? 😛

Yes

(take 3 (map dec (range)))

No

juxt: full version 😂 ((juxt dec identity inc) (count []))

hehe, I was thinking of using that instead of adding deltas to get neighbours (I do use dec and inc in my solution), so I was actually half serious 😉

i.e., (untested)

(defn cell-neighbors [cell]
  (remove #{cell}
          (apply combo/cartesian-product
                 (map (juxt dec identity inc) cell))))

Mensa dictionary entry 8: > Sarchasm : The gulf between the author of sarcastic wit and the person   >  who doesn’t get it.