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'

You’d better not see my code today :)))

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

no core.logic solutions yet?

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

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

some of my breakthroughs happened during those interruptions, so I can't complain

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 🙂

(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.

all possible are shown above: 16, no?

(admittedly, those are after multiple manipulations)

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]])

You can pick up a piece of paper and see there are only 8 orientations

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

my set has 16

anyway, it seems like 1 flip + 1 rotation

@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])

madness dot png

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

every square unique, every perimeter unique, every convolved perimeter unique.. .ugh

and 8^144 choices 😕

Did one also, except I solved this one with Kotlin 😄

For me, assembling the puzzle alone was work for 2 days. once that was done, scanning for monsters felt relatively straightforward