Clojurians Log v2

Did anyone else use reduce/`reduced`? It feels dirty but I can’t figure out how to get the same efficiency without it. My other solution was to use some but created the whole set of inputs before hand.

(defn find-ints-summing-to-target [coll]
  (reduce (fn [seen-set n]
            (let [diff (- target-sum n)]
              (if (seen-set diff)
                (reduced #{n diff})
                (conj seen-set n))))
          #{}
          coll))

it also returns the whole set if a pair isn’t found which is a terrible result in the negative find case

ah looks like skykanin did something similar above in a cleaner fashion

Today I just threw core.logic with finite domain at it, which worked out quite nice: https://github.com/IamDrowsy/aoc-2020/blob/master/clojure/src/advent_of_code/d01.clj

reduced is totally fine and normal. You use it in exactly this sort of situation: You want to short-circuit evaluation because you’re done.

Day 2, not bad, most of the work was processing the input into usable form. E.g.

{:lb 1, :ub 3, :ch \a, :pw "abcde"}

(defn pwgood? [{:keys [lb ub ch pw]}]
  (<= lb (get (frequencies pw) ch 0) ub))

(defn pwgood2? [{:keys [lb ub ch pw]}]
  (= 1 (count (filter #(= ch %)
     [(nth pw (dec lb)) (nth pw (dec ub))]))))

I am curious what did you you use to parse data for Day 2. Have you used regexp or some nice parser combinator library?

My solution for day 2 https://youtu.be/rghUu4z5MdM

always forget about slurp and barf, I like how some edits are more fluent with them

https://github.com/transducer/adventofcode/blob/master/src/adventofcode/2020/day2.clj

Nice 🙂

Has someone figured out a way to slurp the input data directly from the site? I’m lazy, so if someone has this solved in a nice module, I’d love to have it. 😃 I’m also not lazy, so if this is not done by someone, I might try to do it, if someone here does not tell me it is probably very hard. And I’m the sharing type. Haha.

There is some Python program somewhere

That is beautiful!

https://github.com/wimglenn/advent-of-code-data

aocd > input.txt  # saves today's data
aocd 13 2018 > day13.txt  # save some other day's data

Mine:

(defn checks? [{:keys [p1 p2 ch pwd]}]
  (as-> pwd $
    (filter #(= ch %) $)
    (count $)
    (<= p1 $ p2)))

(defn checks2? [{:keys [p1 p2 ch pwd]}]
  (let [p1 (dec p1)
        p2 (dec p2)]
    (as-> pwd $
      (seq $)
      (vec $)
      (not= (= ($ p1) ch) (= ($ p2) ch)))))

Neither did you, I now realize. Haha.

If I end up rolling this, I’ll have use for that to see what is involved.

Was attempting to do so yesterday, then I realised authentication is required

lazy way I think would be doing it first from the browser, "copy as cURL" so that it has your cookie headers in there, then you can adjust that curl line to download the other ones as long as your session remains valid

In the Python aocd tool you can add the value of the session cookie in the AOC_SESSION env var or ~/.config/aocd/token file

Wow as always it’s fascinating to watch Clojurians solution in this channel. This year I’m using ReasonML(family of OCaml) since my company has chosen it. https://github.com/namenu/advent-of-reason/blob/master/src/Year2020/Year2020_Day01.res Yes, it’s typed, I miss Clojure so badly.

Maybe a program can login via the GitHub SSH key so that you don’t need the session

If you use GitHub to login

Not sure if that’s possible

I remember a talk from Clojure Vienna 2016 on ReasonML’s Unikernels and also transforming Clojure to ReasonML: https://youtu.be/tB705w4w6H0

Wow thats... cursed

haha

Was pretty interesting stuff. Booting up a unikernel faster than the time it takes to do a TCP handshake

Not sure what the status is of it now

@pez https://github.com/lambdaisland/aoc_2020/blob/main/bin/fetch_input

just need to find the session id with devtools and put a export AOC_SESSION=... in your shell profile

And in the same way, it's also pretty easy to get the input via clojure (I just store the session in a file) https://github.com/IamDrowsy/aoc-2020/blob/581097350d2dc7865304ffc9eddaf6a479406ca1/clojure/src/advent_of_code/util.clj#L9:L13

@mroerni my definition of functional programming is “pure functions (that always return same output with same input) and no use of mutable variables”. By that definition the solution was already functional. Perhaps you mean something different, like using higher order functions with well known names (see below)? @juniusfree indeed map and filter are implemented using recursion. I think it’s instructive to look at and they have similar patterns to your solution, the gist of it (clojure.core one also uses lazy-seq to delay evaluation of recursive call making them lazy, and chunked sequences to increase performance):

(defn map* [f coll]
  (when (seq coll)
    (cons (f (first coll)) (map* f (rest coll)))))

(map* inc [1 2 3])
;; => (2 3 4)

My day 2 part 1 was pretty similar to yours

(defn parse-line [s]
  (let [splits (rest (re-find #"(\d+)-(\d+)\s(.):\s(.+)" s))]
      {:range [(Integer/parseInt (first splits)) (Integer/parseInt (second splits))]
       :char (first (nth splits 2))
       :password (last splits)}))

;; check valid for part 1
(defn valid-password? [{:keys [range char password]}]
  (let [[min max] range
        freq       (frequencies password)
        char-count (freq char 0)]
    (<= min char-count max)))

;; check valid for part 1
(defn valid-password? [{:keys [range char password]}]
  (let [p1 (nth password (dec (first range)) \_)
        p2 (nth password (dec (second range)) \_)]
    (or (and (= char p1) (not= char p2))
        (and (not= char p1) (= char p2)))))

(->> (slurp "input.txt")
     (str/split-lines)
     (map parse-line)
     (filter valid-password?)
     (count))

I like your solution for part2!

🙂 i did same as yours initially but then realized clojure had no xor

Curious: why use set membership rather than `(= 2020 ...)

A small regex. I simply split each line with #(str/split % #“[- :]“) and then converted the strings to numbers and chars as appropriate.

Hey are you going to be doing a video series this year for AoC? @potetm

Decided to go the easy path that @plexus pointed out. Copy as cURL from the problem page when I start reading it-> Grab the session cookie there -> (set-fetch-cookie! "<cookie>") -> Hack away until I need the input -> (util/fetch-input <day>)

(ns pez.aoc2020.util
  (:require [clj-http.client :as client]))

(def ^:dynamic *fetch-cookie* "")

(defn set-fetch-cookie! [cookie]
  (alter-var-root #'*fetch-cookie* (constantly cookie)))

(defn fetch-input [day]
  (if (seq *fetch-cookie*)
    (try
      (:body (client/get
              (str "<https://adventofcode.com/2020/day/>" day "/input")
              {:cookies {"session" {:value *fetch-cookie*}}}))
      (catch Exception e
        (println "Ho, ho, ho! Did you forget to `set-fetch-cookie!`?")
        (throw e)))
    (throw (Exception. "Ho, ho, ho! You forgot to `set-fetch-cookie!` first."))))

(comment
  (def input
    "1-3 a: abcde
1-3 b: cdefg
2-9 c: ccccccccc")
  (util/set-fetch-cookie! "retracted")
  (def input (util/fetch-input 2))
  (->> input
       (parse)
       (filter checks2?)
       (map :pwd)
       (count)))

Neat! Found this a bit late, but I did exactly that. 😃

Last year the session never changed.

nothing fancy but my day 02 solution https://github.com/listba/advent-of-code-2020/blob/master/clojure/src/aoc_2020/days/02.clj

I've just checked that cookie expiration is set for 10 years 😁

Even I should be able to solve the puzzles in that time!

I am stuck in 2016 somewhere, not sure 10 years will cut it for me 😉

my also not fancy day 2… I like how declarative it came out looking https://gist.github.com/KennyMonster/eb6ea22eaba1a1a1201820ef1bddc1cf

ugh I made the mistake of trying it in rust this year

no one wants to see that 😄

I put my input-slurper into a gist: https://gist.github.com/PEZ/bcd23b9bc099b8b21a41c8c9de78a0f4

hi there. Here is my day 1 "theorically fast" solution https://github.com/green-coder/advent-of-code-2020/blob/801ebdeb9afa3904c1a5e31aeb9386e30e950c78/src/aoc/day_1.clj#L34

I liked how you broke down the problem in the videos regardless of language used. If you do decide to make them, I would take a look

this is probably more a #beginners question, but figured I’d ask here since it’s related to the Advent of Code stuff I’m trying why isn’t this working? I copied problem 1's input file to a file called input in resources (in a Leinengen app template project)

(slurp (io/resource "input"))

@erwinrooijakkers Correct. There are a lot of built-in functions in Clojure that I still have to explore!

I don't use the exec plugin, but looks like it has -p flag that runs the script in project CLASSPATH, wich is required to resolve the resources

https://github.com/kumarshantanu/lein-exec

-p  indicates the script should be evaluated in project (with classpath)

thank you! that was it

ha, funny seeing you here @jeffrey.wayne.evans

trying to get my day1 and day2 solutions finished and pushed

I am learning clojure too, trying to do AOC with it

sweet! let’s keep each other accountable

Ive got my solutions here, finished day 1 and 2! https://github.com/kwpav/advent-of-code-2020

nice! I’m a bit behind, only got day 1 done so far: https://github.com/jeff303/advent-of-code-2020

gonna try to finish day 2 before I look at yours

day 2 was fun

yeah, almost seems easier, especially with Clojure. though I’m sure part 2 will throw some kind of wrench into it