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)
- # clj-new (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)
- # 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.

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 😕

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 😞