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

## 2020-12-20

## Channels

- # adventofcode (72)
- # aleph (8)
- # announcements (21)
- # beginners (43)
- # calva (10)
- # cider (2)
- # cljdoc (12)
- # cljsrn (3)
- # clojure (9)
- # clojure-android (1)
- # clojure-europe (38)
- # clojure-norway (2)
- # clojure-romania (1)
- # clojure-uk (2)
- # clojurescript (58)
- # cursive (8)
- # datomic (29)
- # deps-new (2)
- # depstar (2)
- # fulcro (3)
- # java (20)
- # leiningen (11)
- # luminus (2)
- # off-topic (13)
- # sci (1)
- # shadow-cljs (3)

I think I will take the slow path and use insta-image, to learn a few new things.

I've managed part 1, but also used a math shortcut and now have to start over for part 2.

Day 20 answers thread - Post your answers here

https://github.com/green-coder/advent-of-code-2020/blob/master/src/aoc/day_20.clj

It seems like every border can have at most 1 possible partner. I guess that simplifies the problem to 'find the match to this edge' from 'find all possible matches for this edge, then find the only possible solution considering all possible combinations'

Please share ~ it’s fine

I need to clean it up first.

All the images have either 2, 3 or 4 matching sides. Part 1: Corners are the ones with only 2 matching sides. Part 2: Couldn't find any tricks beside the fact there is only one possible solution. Surprised that the result came out really quickly though.

https://github.com/euccastro/advent-of-code-2020/blob/master/src/advent/day20.clj

runs in 91 msecs, could probably get it much lower since at some point I stopped bothering with optimizations

https://github.com/peterhhchan/aoc2020/blob/main/src/aoc2020/day20.clj under 400ms. could probably speed up the solution by considering only edges and solving inwards, but thats too much work

tip: in https://github.com/peterhhchan/aoc2020/blob/main/src/aoc2020/day20.clj#L123 you don't need to `(remove nil)`

if you use `:when`

in the for bindings instead of `when`

in the body

slow and long https://github.com/nbardiuk/adventofcode/blob/master/2020/src/day20.clj

With some magic numbers, hope I will refactor it later https://github.com/zelark/AoC-2020/blob/master/src/zelark/aoc_2020/day_20.clj

I have cleaned up my solution significantly and added comments, if anyone is interested. after doing that I'm actually quite satisfied with it, despite the biggish function at the end

One ugly but practical way to solve it is by counting the heads visible in your input, get the images (without borders) to count total number of `#`

and do:

```
(def char-count-sea-monster
15)
(def sea-monster-count-guess
23)
(- total-hashes (* char-count-sea-monster sea-monster-count-guess))
;; => 1576
```

Finally got part 2 done. Damn. https://github.com/rjray/advent-2020-clojure/blob/master/src/advent_of_code/day20.clj

Took a few days off — quite a ways into part one of day 20.. Itching to use some datalog..

If you can do it using Datalog, I will definitely learn something new.

I don’t see a lot of activity and I wonder if people are still trying to solve the puzzle or if they took a break.

In my particular case I'm a bit far behind, and I'm saving a few to warm up for upcoming interviews

I've managed to do only part 1 in the morning, will try to finish second part in the evening

Part 1 was """easy""". But when the part 2 seems having 3 parts, it's a bit terrific.

found monsters in both the demo and real input, and my dash calculation works for the demo input, but somehow is too high for the real input 😕

I'll do the rest of the puzzles on the holidays since I can't afford to spend this much time on workdays

Tomorrow's problem could also be short - we don't know yet.

could be... but puzzles get revealed at 6AM my time, and I need to catch up on sleep too 🙂

my `solution2`

function is really monstrous, keeping with the challenge theme, but https://github.com/Saikyun/miracle.save made it relatively easy to debug. It lets you work as if the definitions in the local `let`

were module-level (so you can just evaluate forms inside the function).
https://github.com/vvvvalvalval/scope-capture is a more powerful alternative, but I find it harder to remember how to use it

@vincent.cantin why do you have only 4+4 card variants? are you flipping only vertically? I got 16:

```
(defn flip [s] (-> s reverse str/join))
(defn flip-hor [[t r b l]] [(flip t) l (flip b) r])
(defn flip-ver [[t r b l]] [b (flip r) t (flip l)])
(defn turn-lef [[t r b l]] [r b l t])
(defn turn-rig [[t r b l]] [l t r b])
(def mops
(->>
[flip-hor flip-ver turn-lef turn-rig]
(map memoize)
(apply juxt)))
(defn transformations [edges]
(->> #{edges}
(iterate (fn [variants]
(->> variants
(map mops)
(reduce into variants))))
(partition 2)
(drop-while #(apply not= %))
(ffirst)))
```

```
(def edges ["...#.#.#.#" "#..#......" ".#....####" "#.##...##."])
(->> edges transformations)
=>
#{["#.#.#.#..." "......#..#" "####....#." ".##...##.#"]
[".#....####" "#.##...##." "...#.#.#.#" "#..#......"]
["#.#.#.#..." "#.##...##." "####....#." "#..#......"]
["......#..#" "...#.#.#.#" ".##...##.#" ".#....####"]
["#.##...##." "...#.#.#.#" "#..#......" ".#....####"]
["####....#." "#..#......" "#.#.#.#..." "#.##...##."]
["####....#." ".##...##.#" "#.#.#.#..." "......#..#"]
["...#.#.#.#" ".##...##.#" ".#....####" "......#..#"]
[".#....####" "......#..#" "...#.#.#.#" ".##...##.#"]
["#..#......" ".#....####" "#.##...##." "...#.#.#.#"]
["......#..#" "####....#." ".##...##.#" "#.#.#.#..."]
["...#.#.#.#" "#..#......" ".#....####" "#.##...##."]
["#.##...##." "####....#." "#..#......" "#.#.#.#..."]
["#..#......" "#.#.#.#..." "#.##...##." "####....#."]
[".##...##.#" ".#....####" "......#..#" "...#.#.#.#"]
[".##...##.#" "#.#.#.#..." "......#..#" "####....#."]}
```

that’s enough to check

First you rotate a piece (4 times), it’s not matched, you flip it and do rotation again (+ 4). That’s all possible combinations.

Doesn’t matter how you flip it vertically or horizontally.

unless `rotated and flipped to a random orientation.`

means "rotated once then flipped once", and not "rotated, flipped, rotated again, flipped again.. etc"

```
(def tile [[1 2 3]
[3 4 5]
[6 7 9]])
(take 4 (iterate rotate tile))
([[1 2 3]
[3 4 5]
[6 7 9]]
[[6 3 1]
[7 4 2]
[9 5 3]]
[[9 7 6]
[5 4 3]
[3 2 1]]
[[3 5 9]
[2 4 7]
[1 3 6]])
(take 4 (iterate rotate (flip tile)))
([[6 7 9]
[3 4 5]
[1 2 3]]
[[1 3 6]
[2 4 7]
[3 5 9]]
[[3 2 1]
[5 4 3]
[9 7 6]]
[[9 5 3]
[7 4 2]
[6 3 1]])
```

Even better you can pick up a real puzzle piece

I also had doubts, but then called a `set`

an all flips and rotations and it was just 8

@misha unlikely it’s your problem, but I also had 16 at first… I was adding back the original, unmodified grid at the end, and forgot to wrap it in `[]`

when concatting with the list of rotation/flips, which added each individual row (rookie mistake I know)

also, I think taking the set of rotations/flips will result in a variable number, since sometimes there is symmetry in the input. For example flipping:
`[["*" " " " "]`

`["*" "*" "*"]`

`["*" " " " "]]`

the top-bottom rotations will be the same.

If you have the 8 basic symmetries of a square (4x rotational, 4x reflection), then any combination of these of the operations can be simplified to any of the basic 8.

found it:

```
(defn flip-hor [[t r b l]] [(flip t) l (flip b) r])
(defn flip-ver [[t r b l]] [b (flip r) t (flip l)])
(defn turn-lef [[t r b l]] [r b l t])
(defn turn-rig [[t r b l]] [l t r b])
```

->>
```
(defn flip-hor [[t r b l]] [(flip t) l (flip b) r])
(defn flip-ver [[t r b l]] [b (flip r) t (flip l)])
(defn turn-lef [[t r b l]] [r (flip b) l (flip t)])
(defn turn-rig [[t r b l]] [(flip l) t (flip r) b])
```

here I was trying to convince myself that I could do with just flips and transposes (i.e., no need for explicit rotations). I was silly/underslept enough to clutter the drawing with arrows in both directions even though all basic ops are their own inverses

@U5P5Z5J23 there is no symmetry in the puzzle tiles; all borders are unique, even allowing for reversals

Yeah after much banging my head against the wall I came to the same conclusion.. and now I’m stuck

Wow, I think I hit the wall on this one. End of the AOC adventure for me this year 😞

today was really work for 2 different days. Assembling jigsaw puzzle and pattern matching are different problems. I wrote 2x code compared to the longest previous day