This page is not created by, affiliated with, or supported by Slack Technologies, Inc.

## 2020-12-10

## Channels

- # adventofcode (174)
- # announcements (5)
- # aws (9)
- # babashka (17)
- # beginners (259)
- # boot-dev (1)
- # calva (6)
- # cider (19)
- # circleci (7)
- # clj-kondo (9)
- # cljfx (51)
- # cljs-dev (4)
- # clojure (83)
- # clojure-australia (2)
- # clojure-dev (9)
- # clojure-europe (78)
- # clojure-nl (3)
- # clojure-spec (4)
- # clojure-switzerland (1)
- # clojure-uk (18)
- # clojurescript (22)
- # conjure (17)
- # cursive (17)
- # data-science (1)
- # datomic (15)
- # defnpodcast (1)
- # events (2)
- # fulcro (39)
- # graalvm (16)
- # graphql (1)
- # kaocha (5)
- # lambdaisland (11)
- # malli (6)
- # meander (1)
- # off-topic (26)
- # pathom (10)
- # re-frame (10)
- # reitit (6)
- # rewrite-clj (7)
- # sci (3)
- # shadow-cljs (28)
- # sql (12)
- # test-check (10)
- # tools-deps (31)

I am sure people will start to be VERY DYNAMIC very soon. … or never (<- hidden joke there)

I had to google "dynamic programming", seems this is basically just divide and conquer algorithms? it's not confusing at all that this has nothing to do with dynamic programming languages or dynamic bindings

It is a "divide and reuse" way of doing. I guess the "dynamic" part is the non-constant cost of calculating things when memoized.

Crap... almost 2 1/2 hours and I can't get a solution for part 2 that takes less than forever...

Spent about an hour on this one, and same deal. The second demo input takes ~25ms for part2, but no end in sight with the real input. Might have to crack out visualvm and do some profiling.

Don’t forget your old friend `memoize`

. That takes the naive approach straight to O(n).

I don't see how my solution benefits from memoize, it's not doing anything multiple times

It's that time of the year where I'm starting to wonder why I'm wasting my time on this...

btw during reclojure I saw someone fire up a nice graph genreated from the profiler output

anyone knows how it can be done? I used to love to generate these graphs with Python and https://github.com/gak/pycallgraph

something like https://github.com/jstepien/flames maybe but I think it was a different one

@andrea.crotti probably this one: https://github.com/clojure-goes-fast/clj-async-profiler

The best solution I’ve seen today. Only one thing I could add to it is simplifying of the part 1 by reverting map’s arguments. [Spoiler inside]

I'm having trouble wrapping my head around this solution for part 2. Anyone care to explain the logic behind it?

@UE8PRHLTY The key here is a *reverse order* of adapters.
We start with a map with just the end adapter, which means there is only one way to reach the end. Then, on each iteration we count ways for the next adapter based on cnts map and previous calculations. And so on, until we reach opposite end of reverse sequence of adapters. At the end, we get a result hold under `0`

key.
Actually, the idea is pretty simple and elegant.

```
p2:
"Elapsed time: 0.39624 msecs"
=> 19208 (test input)
"Elapsed time: 9.720333 msecs"
=> 96717311574016
```

Was trying to come up with some clever solution, but in the end gave up and memoized results.

Side-effect of my accomplishment is code that hurts my eyes.

Is that why I'm looking at completing a backlog of AoC years?

Forgot about aoc this year. Just remembered yesterday. Finally caught up !

I found an odd… pattern? in the results of day 10 part 2 . The results will only have prime factors of 2 and 7… I’ve been trying to figure out why.. and if I could leverage that into a different solution.

Check out https://www.reddit.com/r/adventofcode/comments/ka9pc3/2020_day_10_part_2_suspicious_factorisation/ post in reddit, unless you don't want any spilers

@UGFL22X0Q it’s because a run of 4 ones has 7 combos, a run of 3 ones has 4 combos, and a run of 2 ones has 2 combos.

Yep, it depends upon the length of runs, but I think is not that simple to get the exponents anyway

Kind of, I guess. But in this case there is an O(n) solution, so clearly not the general one

My thinking is, but I'm having trouble implementing it.. **Spoiliers ahead if this works***
Find partitions where smallest number in partition is within 3 of biggest. either the partition will have 4 numbers in it, or the partition will have 3 numbers in it (or less)
Partitions with 4 will have 4 combos.
Partitions with 3 will have 2 combos.
Multiply all theses partitions combo counts together.
It works for the smaller test but not the bigger one. Or my code is guff. 😕
Am I on the right track or should I give up with this line of thinking?

I dunno how to explain it, because I don’t really understand it, but I did make it work by checking the number of consecutive 1 jumps and mapping:

```
{:dual-consecutive-1s 2
:trip-consecutive-1s 4
:quad-consecutive-1s 7}
```

and so in the beginning if you omit the 0 to 1 jump you’re missing a consecutive 1 from the beginning. I suppose the 3 jump at the end can be ignored

spoiler, but my solution goes along these lines: https://github.com/tschady/advent-of-code/blob/master/src/aoc/2020/d10.clj

relevant bit:

```
(defn permuted-partition-count
"Returns the number of different ways a sequence can be carved up
into segments of length 1,2, or 3"
[xs]
(->> (combo/partitions xs :min 1 :max 3)
(map (comp count combo/permutations))
(reduce +)))
```

Ah, I discovered the powers of 7, 4 and 2 pattern independently and used it for my part 2: Runs in “Elapsed time: 0.5174 msecs”

```
;; part 2
(defn adapter-combos [inp]
(->> (sort (concat inp [0 (+ 3 (apply max inp))]))
(partition 3 1)
(map (fn [[a _ c]] (- c a)))
(partition-by identity)
(keep {'(2 2 2) 7 '(2 2) 4 '(2) 2})
(reduce *)))
(adapter-combos input)
;; => 5289227976704
```

here is my (probably not too Clojurey) version, but hopefully with clear enough comments to explain the logic. https://github.com/jeff303/advent-of-code-2020/blob/master/src/advent_of_code/day10.clj#L41-L73

jeez it's getting hard even to understand the assignment

depends what you mean by easily

if you have never done clojure it might take a while but the algoriths to use are quite simple

There is a couple guys who recorded videos. You can learn from them a lot.

yeah but you should try by yourself first maybe

I like his man : https://www.reddit.com/r/Clojure/comments/k9cg8l/a_teacher_looks_at_advent_of_code_2020_days_07/

A lot of the very early problems rely on using things like regular expressions, generating sequences using for and range, map and filter or sequences. Having a handle on things like that will take you past several problems.

(slurp filename), or (line-seq (reader filename)) is fairly suitable. The first gets the whole content into a string, the second generates a sequence of lines (using reader from the http://clojure.java.io namespace).

`(map #(Long/parseLong %) (line-seq (reader filename)))`

would be a common way of getting a sequence of integers out of lines of integers in a file.

> I see , I think first learn more and get more familiar with clojure Doing AoC was for me, a good way to learn a language (in my case was Prolog)

part 2… it’s definitely not easy, I’d guess because the puzzle doesn’t hint at the solution so directly?

I saw part 2 and was like.. oh that’s easy, i’ll just generate permutations for everything +3 from current, drop the count of that from the remaining sequence, and concat all the results to what i’ve found so far and recurse

then I thought.. oh that’s easy, I’ll just do a depth first search and track the paths.

I also tried working out all the paths, and went to buy bread (I do these in the morning). When I got back, it (obviously) had not finished, and just then I came up with the good one 🙂

I guess my first indication should have been when using the second test input took like 5 seconds to count the valid paths

My clue was the word "trillions".

hmm actually, if you assume an upper bound for the branching factor of 3 (can be 1, 2, or 3 higher), then wouldn’t the possible paths be count of input ^ 3?

Wouldn't it be 3^input?

3^100 is a big number..

even being generous and assuming a branching factor of 2, that’s 2.1 billion paths for the second test input

Is there any goo way to work a clojure file without creating a whole project? This year I'm doing days in different languages. And I don't want to create a whole project for single days

also, as far as I know, you can just create a `.clj`

file, im not aware of any need to create a whole project for it

Yup you can. But working with it gets kind of awkward. For example, I work with emacs-cider, and refuses to `cider-jack-in`

(run the repl) correctly

ah yeah, in that case try with a `deps.edn`

file, i have a project with that and `cider-jack-in`

seems to work fine

Anything special in `deps.edn`

? Mine still fails

```
touch hw.clj
echo "(println \"Hello world\")" > hw.clj
clj hw.clj
WARNING: When invoking clojure.main, use -M
Hello world
```

I think you might just need `{:deps}`

? heres the documentation https://clojure.org/guides/deps_and_cli

at least you have to have {:paths [“src”]}, that’s enough to start

I (like a lot of people, I imagine) have a project for all the days, and one file per day with a different namespace ( `(ns aoc2020.day01)`

for example)

Part 2 feels like it requires some knowledge of mathematics which I do not have. Presumably some aspect of combinatorics.

@rob156 It might seem like that. And it helped me gather my shiny gold stars thinking it did. But I’ve just learnt (the thread above your post) that I had the math wrong. Haha.

is there a typo on day 10, part 2, the longer sample input? here: https://adventofcode.com/2020/day/10
“In this larger example, in a chain that uses all of the adapters, there are `22` differences of 1 jolt and `10` differences of 3 jolts.”
I think there are actually `9`

differences of 3 jolts. I counted by hand (and also my code came up with that, which of course may not be bug free)

Maybe you are not counting the max element + 3 you must add