Clojurians Log v2

Did you manage to upload this to github pages yet?

no, I lost the motivation after a few hours of custom domains BS. But I'll look at again tonight. Want to get days 3 and 4 out of the way first.

in JS I had a horrible hack for day 1

(->> @data
     str/split-lines
     (map (fn [s]
       (let [n (js/parseInt s)]
        (when-not (js/isNaN n) n))))
     (partition-by nil?)
     (keep #(reduce + %)))

but this works perfectly

(->> @data
     str/split-lines
     (map edn/read-string)
     (partition-by nil?)
     (keep #(reduce + %)))

Thanks for the tip!!

This reminds me of one of my favorite clojure tricks - write data into edn from another program, then just edn/read-string it into clojure's happy place

Yeah I love in general how easy it is to get data in

I split the lines and map read-string over them.

I know, I use it a lot daily, but didnt want to manipulatr the source data first 🤣 just lazy, thanks for the tip tho.

@piotr.kaznowski I found the problem that caused this. You should be able to remove the workaround with the current master build:

bash <(curl ) --dev-build --dir /tmp

The issue was that the directory wasn't created before untar-ring

@borkdude Cool! Will have a look.

cc @borkdude @tsulej

Awesome, feel free to send a PR to advent-of-babashka under my github name and add the link to "external resources"

I'm new to pods -- tried to run bb badges and am getting

Message:  Cannot run program "/home/piotr/.local/share/.babashka/pods/repository/retrogradeorbit/bootleg/0.1.9/linux/x86_64/bootleg": error=2, No such file or directory

Downloading pod retrogradeorbit/bootleg (0.1.9)
Successfully installed pod retrogradeorbit/bootleg (0.1.9)

@piotr.kaznowski Which OS is this?

and what architecture?

@borkdude Arch Linux, x86_64

ldd /home/piotr/.local/share/.babashka/pods/repository/retrogradeorbit/bootleg/0.1.9/linux/x86_64/bootleg

cc @retrogradeorbit - might be good to provide a fully static musl compiled binary for bootleg

$ ldd /home/piotr/.local/share/.babashka/pods/repository/retrogradeorbit/bootleg/0.1.9/linux/x86_64/bootleg
ldd: /home/piotr/.local/share/.babashka/pods/repository/retrogradeorbit/bootleg/0.1.9/linux/x86_64/bootleg: No such file or directory

aha, so the file doesn't exist at all?

Yes, as I said above: > Threre's no bootleg executable at the location, only manifest.edn file. Before it crashes, it prints:

then it's not the issue I suspected it to be

This is what I'm seeing:

$ bb -e "(require '[babashka.pods :as pods]) (pods/load-pod 'retrogradeorbit/bootleg \"0.1.9\")"
Downloading pod retrogradeorbit/bootleg (0.1.9)
Successfully installed pod retrogradeorbit/bootleg (0.1.9)
#:pod{:id "pod.retrogradeorbit.bootleg.glob"}

I'll also try on ubuntu...

can you maybe try the above with:

BABASHKA_PODS_DIR=/tmp bb -e "(require '[babashka.pods :as pods]) (pods/load-pod 'retrogradeorbit/bootleg \"0.1.9\")"

Hmm, that worked with /tmp!

On ubuntu it also worked fine for me. Perhaps you could try to wipe the pods directory and try again

It reproduces the erratic behavior.

could it be a file system permission thing?

you could try to debug locally with https://github.com/babashka/pods - the load call should also work on the JVM

OK, will try, thanks.

(Meanwhile I can hack it with BABASHKA_PODS_DIR : I have my bb script for AoC, wanted to play with the badges -- thanks @borkdude & @tws)

https://github.com/caseneuve/aoc2022

And the starter template project is a bit updated as well: https://github.com/PEZ/joyride-aoc-2022

(ns aoc2022.day4
  (:require [ :refer [resource]]
            [clojure.string :as str]
            [clojure.set :refer [intersection]]))

(defn data []
  (->> (resource "inputs/day4.txt")
       (slurp)
       (str/split-lines)))

(defn complete-overlap? [[s1 e1 s2 e2]]
  (or (and (<= s1 s2) (>= e1 e2))
      (and (<= s2 s1) (>= e2 e1))))

(defn partial-overlap? [[s1 e1 s2 e2]]
  (not (or (< e1 s2) (> s1 e2))))

(defn solution [overlap?]
  (->> (data)
       (map #(str/split % #","))
       (map (partial map #(str/split % #"-")))
       (map (fn [[[s1 e1] [s2 e2]]]
              (map #(Integer/parseInt %) [s1 e1 s2 e2])))
       (filter overlap?)
       (count)))

(def part1 (partial solution complete-overlap?))
(def part2 (partial solution partial-overlap?))

Oh, filter true? is totally redundant here!

I guess there are two types of solutions. 1. comparing numbers of start and end ranges 2. using sets I will always use sets for these types of problems. Feels more flexible and better describable.

https://github.com/genmeblog/advent-of-code/blob/master/src/advent_of_code_2022/day04.clj

https://github.com/benjamin-asdf/advent-of-code/blob/master/src/Y2022/day4.clj

https://github.com/pwojnowski/advent-of-code/blob/master/src/aoc/aoc2022.clj#L77

I'm not an algo expert, but the solution with sets is much less optimal, because it... generates sets (time proportional to the sizes of the ranges and space proportional to the set size). This is contrary to the golden rule of algos: Don't compute what is not needed.

Of cause I’m not talking about performance. I was talking about what kind of approach comes more naturally.

hmm, another 'comparing ranges' answer: https://github.com/CarnunMP/Advent-of-Code/blob/master/src/y2022/d4.clj obvious in hindsight that parsing things into [[a1 b1] [a2 b2]] pairs made things less neat!

(ooh, weird how the preview renders <= and >= as = 🙃)

https://github.com/LouDnl/advent-of-code-2022/blob/master/src/clj/advent_of_code_2022/days/day_four.clj

same solution as above. Only thing interesting was my helper from previous years: (def input (f/read-ranges "2022/d04.txt")) https://github.com/tschady/advent-of-code/blob/main/src/aoc/2022/d04.clj

(defn parse-assignment [a]
  (->> (string/split a #"-|,")
       (map #(Integer/parseInt %))
       (partition 2)
       (map (fn [[a b]] (range a (inc b))))
       (map set)))

(defn subset? [[a b]]
  (or (clojure.set/subset? a b)
      (clojure.set/subset? b a)))

(defn intersection? [[a b]]
  (not (empty? (clojure.set/intersection a b))))

(defn day4 []
  (let [in (slurp "input/day-4-input-1.txt")
        assignments (map parse-assignment (string/split-lines in))
        count-assignments #(count (filter true? %))]
    {:part1 (count-assignments (map subset? assignments))
     :part2 (count-assignments (map intersection? assignments))}))

Nice, very short and clean

seq instead of not empty

Or not-empty https://clojuredocs.org/clojure.core/not-empty

@thierry572 not-empty would return nil for empty sets. I would have to change my (filter true?) to something else. What's the shortest way of achieving your suggestion?

Not at computer atm, what about (filter some? %)

I would have to change my subset? function to return nil. It would be change for change. I don't see an immediate benefit.

Good point. Doesnt seq yield the same result? Maybe (some? (not-empty

More then one way to reach Rome with Clojure (or any other language for that matter) 🤣

https://github.com/zamansky/advent2022/blob/main/src/day04.clj

This is one of those days that I'm going to now look at how other people did the overlap and contains and realise my solution is dumb... https://github.com/stuartstein777/clj-advent-of-code/blob/master/src/stuartstein777/2022/day4.clj

I too considered sets, that does feel more natural to me, but then thought it was wasteful to generate all thsoe numbers

This was one of the best solutions i've seen. I always forget that these functions can take more than 2 arities.

(defn fully? [[A B X Y]]
  (or (<= A X Y B) (<= X A B Y)))

(defn partially? [[A B X Y]]
  (or (<= X A Y) (<= A X B)))

@luis559 Using not=

(defn intersection? [[a b]]
  (not= #{} (set/intersection a b)))

@qmstuart I started out with sets aswell but ended up using a for loop on the sets with data/diff

A lot of good stuff here.

https://github.com/mducharm/advent_of_code_2022/blob/main/src/advent_of_code/day_04.clj

I was rereading the solution of a coworker of mine, and I can see now that our overlaps? or partially-overlaps? function can actually be simplified to only compare two terms.

(defn overlaps? [[a b c d]]
  (and (<= a d) (<= c b)))

seems like that would also return true for partial overlaps, e.g. (overlaps? [1 3 2 4]) ?

https://github.com/bhauman/advent-of-code-2022/blob/main/src/adv2022/day4/sol.clj

https://github.com/wevre/advent-of-code/blob/master/src/advent_of_code/2022/day_04_cleanup.clj

https://github.com/Ramblurr/advent-of-code-2022/blob/main/src/aoc/day04.clj#L6-L45 Not very memory efficient, but using range and sets made this day's quite fun

the advent of transducers continues:

(defn count-filtered [data pred]
  (count
   (sequence
    (comp (map #(str/split % #","))
          cat
          (map #(str/split % #"-"))
          cat
          (map parse-long)
          (partition-all 4)
          (filter pred))
    data)))

(def input (-> "adventofcode2022/day4.txt"
               io/resource
               slurp
               str/split-lines))

(comment
  ;; part 1
  (count-filtered input (fn [[a b c d]]
                          (or (<= a c d b)
                              (<= c a b d))))

  ;; part 2
  (count-filtered input (fn [[a b c d]]
                          (or (<= a c b)
                              (<= a d b)
                              (<= c a d)
                              (<= c b d)))))

Here is mine: https://github.clerk.garden/formsandlines/aoc2022-clojure/commit/c55225cae5766f5c77a35a0002021c0cb5ca2024/src/advent_of_clerk/day_04.html I made an explorative chart at the end to see if there are any interesting patterns in the intersection data (not really 😕).

https://github.com/grierson/katas/blob/master/advent-of-code/src/aoc2022/04.clj

https://github.com/nooga/aoc2022/blob/master/day4.lg

(ns day4)

(defn parse [line]
  (map #(map parse-long (split % "-")) (split line ",")))

(def data (->> "input/day4.txt" slurp lines (map parse)))

(defn contain? [[a b] [c d]]
  (or (and (>= c a) (<= d b)) (and (>= a c) (<= b d))))

(defn in? [a b c] (and (>= b a) (<= b c)))

(defn overlap? [[a b] [c d]]
  (or (in? a c b) (in? a d b) (in? c a d) (in? c b d)))

(defn solve [f]
  (->> data (map (partial apply f)) (filter identity) count))

(println "1:" (solve contain?))
(println "2:" (solve overlap?))

(my >= and =< only take 2 args 😫)

https://gitlab.com/maximoburrito/advent2022/-/blob/main/src/day04/main.clj

https://github.com/tylerw/advent-of-code-2022/blob/master/src/aoc2022/day04.cljc

https://github.com/alexalemi/advent/blob/main/2022/clojure/p04.clj

;; 202204
(let [d (->> (slurp "src/y2022/input202204")
             (re-seq #"\d+")
             (map parse-long)
             (partition 4))
      f (fn [[a1 a2 b1 b2]]
          (or (<= a1 b1 b2 a2)
              (<= b1 a1 a2 b2)))
      g (fn [[a1 a2 b1 b2]]
          (or (<= a1 b2 a2)
              (<= b1 a2 b2)))]
  (map #(count (filter % d)) [f g]))
;; (464 770)

https://github.com/zelark/AoC-2022/blob/master/src/zelark/aoc_2022/day_04.clj

https://casselc.github.io/aoc22/src/advent_of_code/day_04.html

(def input
  (->> (util/load-lines "resources/day04.data")
       (map #(re-seq #"\d+" %))
       (map util/parse-ints)))

;; Part 1
(defn fully-contains? [[a b c d]]
  (or (<= a c d b)
      (<= c a b d)))

(count (filter fully-contains? input)) ;; 487

;; Part 2
(defn overlap? [[a b c d]] (and (<= a d) (<= c b)))
(count (filter overlap? input)) ;; 849

https://coyotesqrl.github.io/advent-of-code/2022/src/coyotesqrl/2022/day04.html

https://github.com/abyala/advent-2022-clojure/blob/main/src/advent_2022_clojure/day04.clj looks similar to most of yours, but as usual I wrote a https://github.com/abyala/advent-2022-clojure/blob/main/docs/day04.md to explain it for the newbies!

https://github.com/rap1ds/advent-of-code-2022/blob/main/src/day4.clj

https://github.com/jantorestolsvik/advent-of-code-2022/blob/main/src/day04.clj

After the initial impl, I tried to write a fast non-allocating one, but got a measly 8.1x speedup for a trememdous readability-cost:

;; 988.65µs (+- 54.56µs)
(defn day4 [fs]
  (let [xs (->> (re-seq #"(?:(\d+)-(\d+),(\d+)-(\d+)\n)" fs)
             (mapv #(mapv parse-long (rest %))))
        count-by #(transduce
                    (comp (filter %) (map (constantly 1)))
                    + xs)]
    [(count-by (fn [[a b x y]] (or (<= x a b y) (<= a x y b))))
     (count-by (fn [[a b x y]] (and (>= y a) (<= x b))))]))

;; 121.68µs (+- 7.01µs)
(defn day4b [^String fs]
  (let [add (fn [^long x ^Character c]
              (+ (- (int c) 48) (* 10 x)))
        n (count fs)]
    (loop [i 0, state 0, p1 0, p2 0
           a 0, b 0, x 0, y 0]
      (if (= i n) [p1 p2]
        (let [c (.charAt fs i)]
          (case c
            \newline
            (recur (inc i) 0
              (if (or (<= x a b y) (<= a x y b))
                (inc p1) p1)
              (if (and (>= y a) (<= x b))
                (inc p2) p2)
              0 0 0 0)
            (\- \,)
            (recur (inc i) (inc state) p1 p2 a b x y)
            (case state
              0 (recur (inc i) state p1 p2 (long (add a c))      b                x             y)
              1 (recur (inc i) state p1 p2       a         (long (add b c))       x             y)
              2 (recur (inc i) state p1 p2       a               b         (long (add x c))     y)
                (recur (inc i) state p1 p2       a               b                x      (long (add y c))))))))))

(defn parse [line]
  (->> line (re-seq #"\d+") (map parse-long)))

(defn fully? [[A B X Y]]
  (or (<= A X Y B) (<= X A B Y)))

(defn partially? [[A B X Y]]
  (or (<= X A Y) (<= A X B)))

(defn -main [day]
  (let [input (map parse (file->lines day))
        overlaps (fn [f] (count (filter true? (map f input))))]
    {:part1 (overlaps fully?)
     :part2 (overlaps partially?)}))

Day 5: https://github.com/dogenpunk/advent-of-code/blob/main/src/aoc22/day04.cljc

(ns day-04
  (:require [clojure.set :refer [subset?]]))

(defn input []
  (for [line (re-seq #".+" (slurp "../day_04.data"))
        :let [[a b c d] (map parse-long (re-seq #"\d+" line))]]
    [(set (range a (inc b))) (set (range c (inc d)))]))

(defn count-matching [f]
  (count (filter #(apply f %) (input))))

(defn solution-1 []
  (count-matching #(or (subset? %1 %2) (subset? %2 %1))))

(defn solution-2 []
  (count-matching #(or (some %1 %2) (some %2 %1))))

I wonder how it is possible to submit the solution in 16s...

Seems almost impossible to do this in 16 seconds, it takes longer to read the questions

Too bad the answer time is counted from release of the questions and not from when you actually start with them. I am still asleep at 6am.

That's not what I'm seeing.

@luis559 thats for both stars. OP is about part 1

But still, 16 seconds?

Assuming that getting input-data and submitting is automated to a keybinding, a question-comprehesion time of 10s and typing the solution in 6s seems possible to me. Possible, but extremely impressive of course.

With that little time though, there's no way one can read the whole text. But, here are the example-data and the bold (and glowing) question:

2-4,6-8
2-3,4-5
5-7,7-9
2-8,3-7
6-6,4-6
2-6,4-8

In how many assignment pairs does one range fully contain the other?

Ruby has a cover? method on Ranges which makes it trivial, but I think for these speeds it’s AI: https://clojurians.slack.com/archives/C0GLTDB2T/p1670047249199679

I checked previous years and there were similar speeds for the 2 rounds.

> it doesn't seem too outrageous this way It seems too outrageous to me still. 😃

Indeed @tws, the leader's GitHub https://github.com/max-sixty/aoc-gpt.

Exactly. HN: https://news.ycombinator.com/item?id=33850999

There are some nice writeups from past years from folks who placed highly in the leaderboard

• https://gist.github.com/mcpower/87427528b9ba5cac6f0c679370789661 • https://kevinyap.ca/2019/12/going-fast-in-advent-of-code/ • https://blog.vero.site/post/advent-leaderboard

Mine were 5m6s and 6m21s for the two stars resp. It took me ~2m just to read the question xDD.

That's cool. It's great having the puzzle text right in line, too. It's certainly making me tempted to explore it as an option.

I am using it this year but until now there was no benefit from it compared to just using the repl. It just took up more screen real estate. I hope some more visual problems will come soon.

Yep. It's not terrible, but seeing the metadata is less noisy to me than seeing the var definitions. I could apply the metadata to the whole namespace and then change on a per-form basis as needed as well. I might do that on some days.

It'll be more useful/interesting if there are any puzzles that lend themselves to interesting accompanying visuals, assuming I can solve them and want to put in the extra effort to create visualizations.