Clojurians Log v2

(defn decode [lo hi s]
  (if-let [c (first s)]
    (case c
      (\F \L) (recur lo (+ lo (quot (- hi lo) 2)) (next s))
      (\B \R) (recur (+ lo (inc (quot (- hi lo) 2))) hi (next s)))
    lo))

full solution https://github.com/zelark/AoC-2020/blob/3cc64ff25278f82d262c4c32c2eec4268c0997a5/src/zelark/aoc_2020/day_05.clj

refactored one https://github.com/zelark/AoC-2020/blob/master/src/zelark/aoc_2020/day_05.clj

And my final decode

(defn decode [code]
  (-> (str/escape code {\F 0 \L 0 \B 1 \R 1})
      (Long/parseLong 2)))

Cool! escape another function I've learned today

Ooh that's a good one! Sequestering it for my toolbox :) 🧰

I did it even more literally. 😃 I figured while doing it that there must be another way, but the thing with gold stars is that they give me fever and make me indifferent to what happens to gnomes and kittens.

My cat started screaming right at that time, making it very difficult to focus on the problem. 📝 memo: take the cat away for tomorrow’s puzzle.

i prefer (Integer/parseInt s 2) to read-string tricks, but that might be personality.

Me too, but the better way to do that is to use Long/parseLong . Ultimately, all the numbers in Clojure represented as Longs.

@nbardiuk Just realized from your solution, that splitting at row and col and then some math are not needed at all.

I should carefully look at the input data.

Yeah I thought I was pretty smart by spotting it was just binary, but now I feel silly for not realizing that row+col are just a single number, no need to split them up :)

* 8 was the clue. Why 8?

It’s a power of 2. 2 2 2 = 8. Multiplying by 2 means the same thing you do with shift-left. For example

(= (bit-shift-left 1 3)
   (* 1 8))

and then just bit-or it’s binary addition, so you get the same result just by decoding a whole string.

That’s it yes

Missed it 🙂

Jonathan did same: https://www.youtube.com/watch?v=wa0VcQugEsI

how brilliant!

row and col are just a single number?

because of adding?

ah

wow

So 🙂 For example “BFFFBBFRRR” is in binary 1000110 111, so:

(+ (* 8 (Integer/parseInt "1000110" 2))
   (Integer/parseInt "111" 2))
;; => 567

(Integer/parseInt "1000110111" 2) ;; => 567 

I feel dumb. I created a range from 0 to 127 and recursively either drop / take half of it.

seat number is just a binary with 0 and 1 replaced with L|F and R|B

another trick is how to parse it … there is a clojure function for that

Very nice

@vincent.cantin cannot find anything suitable, I am very intrigued 😮

@nbardiuk https://github.com/green-coder/advent-of-code-2020/blob/master/src/aoc/day_5.clj#L20-L21

oh cool! learn something new with every puzzle 😆

I guess I'm the only one who actually bothered to use bit-shift/bit-or 🙂

edn/read-string is a good parser

@plexus I like your approach for part2

the (partition coll n 1) trick has saved me more than once

Me too 45 minutes of fighting with off-by-one errors and nullpointerexceptions 🙂

I didn't know about step argument in partition-all . Literally yesterday had to implement the pairs function manually

Nice! @plexus any info about your env setup? Is that vim plus what?

https://github.com/plexus/corgi

Planning to get that to a shippable state during the christmas/new years holidays