Clojurians Log v2

I may drop from the contest today - life became busy and the AoC is very time consuming when you do it seriously.

Day 15 answers thread - Post your answers here

Today's part1 worked without changes for part2, in stark contrast with day 13. Which makes my first solution just brute force. I'll spend some time thinking about the smart way, but there's less incentive when you've got the solution already.

(loop [vals (into {} (map-indexed (fn [i n] [n (list i i)]) data))
           last (last data)
           n    (count data)]
      (let [prev (take 2 (get vals last))
            i-diff (apply - prev)]
        #_(println n last prev)
        (if (< n 30000000)
          (recur
           (update vals i-diff
                   (fn [idxs]
                     (if (seq idxs)
                       (conj idxs n)
                       (list n n))))
           i-diff (inc n))
          last)))

Yes, 13 sec for Part 2 https://github.com/zelark/AoC-2020/blob/master/src/zelark/aoc_2020/day_15.clj

. "Elapsed time: 19815.950142 msecs" :d: "Elapsed time: 13638.142432 msecs" with transient map

Mine takes 70 seconds instead: https://github.com/transducer/adventofcode/blob/master/src/adventofcode/2020/day15.clj

Keeping all the indexes is probably bit slower

Maybe cleanup after work 🙂

(defn f [input n]
  (loop [turn  (count input)
         hist  (zipmap input (range 1 ##Inf))
         prev  (peek input)]
    (if (= n turn)
      prev
      (recur
        (inc turn)
        (assoc hist prev turn)
        (if-let [last (get hist prev)]
          (- turn last)
          0)))))

(defn f [input n]
  (loop [turn  (count input)
         !hist (transient (zipmap input (range 1 ##Inf)))
         prev  (peek input)]
    (if (= n turn)
      prev
      (let [prev* (if-let [last (get !hist prev)]
                    (- turn last)
                    0)
            !hist (assoc! !hist prev turn)]
        (recur (inc turn) !hist prev*)))))

My part 2 took about 37-40s to run, using the same brute-force approach as I used for part 1. Can't wait to see what clever math-trick I completely overlooked... https://github.com/rjray/advent-2020-clojure/blob/master/src/advent_of_code/day15.clj

if anyone wants to have a stab at numerology and series:

p2 answer here is 6428 idx num

65373 0
65374 5
65375 26
65376 275
65377 300
65378 4185
65379 2757
65380 1109
65381 6428
65382 42157
65383 0

71782 0
71783 7
71784 12
71785 45
71786 1111
71787 1927
71788 6428
71789 6407
71790 35727
71791 0

81793 0
81794 4
81795 4
81796 1
81797 19
81798 561
81799 6428
81800 10011
81801 0

137474 0
137475 6
137476 34
137477 6
137478 2
137479 215
137480 331
137481 6428
137482 55682
137483 0

205147 0
205148 7
205149 7
205150 1
205151 31
205152 707
205153 6428
205154 67672
205155 0

236727 0
236728 6
236729 32
236730 200
236731 3313
236732 6428
236733 31579
236734 0

I just had an idea of a new format for typing less during the AoC, in case you need:

;; Fast to type
  (red [acc acc-init
        elm coll]
       (conj acc elm))

  ;; The `red` macro expands to the regular reduce below.
  (reduce (fn [acc elm]
            (conj acc elm))
          acc-init
          coll)

Sounds like into 🙂 https://github.com/clojure/clojure/blob/master/src/clj/clojure/core.clj#L6902

It's a reduce, don't get misdirected by my simple example.

Ah, I dig it!

What would be syntax for reduce without acc-init ?

(red [acc elm coll] expr)

That was an easy question. What is the part2? 😉

The idea of red is to follow the chronology of thoughts.

It's like my comp-> macro

I’m hoping your next macro is called blue for the simplest of reasons.

How about green?

I’d totally be on board with that as well 😂

There is a trade off here between readability and how fast it can be typed 🙂 I usually tend to be careful with syntactic sugar. It has to be worth the cost of learning it.

keystroke count aside, I think this format is way easier to read and understand after the fact

I guess the only downside is you would have to wrap it in another function to use in a ->> macro

Congrats @pez on the sponsorship

My “efficient” solution to 15-2 is dog slow. Good enough to pass my tests and get mah ⭐ but terrible. About 25 seconds.

I just started reading day 15, I wonder if it has to do with http://oeis.org/A181391

Yes, it is, someone said about it today.

Hey, thanks! I’m still pinching my arm here.