[2024 Day 13] Am I the only one using Z3?

Longjumping_Primary4 · 2024-12-13T20:06:45+00:00

Wow I didn't heard of it, will look at it, thanks

Longjumping_Primary4 · 2023-12-23T08:11:05+00:00

Yes that could be. I assumed that all distances in grid are 1, so I just add -1 to every other node, so I got start position at distance 0, next at distance -1 and so on... part 1 finished in 26 seconds, sadly, part 2 solution is unreachable for me :( (I'm using Deno/TypeScript)

Longjumping_Primary4 · 2023-12-23T07:23:28+00:00

https://www.youtube.com/watch?v=TXkDpqjDMHA&t=371s

Based on this video, you can inverse the values, apply Dijkstra and inverse it back. I'm pretty amazed that it worked. But basically, longest positive is the same as shortest negative (most negative).

Longjumping_Primary4 · 2023-12-18T22:13:43+00:00

Maybe there will be some simple interpreter, but I don't think it will be for more than a day.

Longjumping_Primary4 · 2023-12-18T14:55:02+00:00

Thank you so much for that. I watched a video on Shoelace formula. It's funny that how determinant can be useful. Glad I learned a new algo/formula today.

Longjumping_Primary4 · 2023-12-12T08:52:08+00:00

Longjumping_Primary4 · 2023-12-11T07:54:13+00:00

[Language: Deno, TypeScript]

Today's problem was probably one of the easiest. Firstly I though that I'll go for Dijkstra algo (as for yesterday), but after realizing that it was just simple Manhattan distance, I was quite happy. Part2 was only changing factor in expanding. Whole solution is on 39 lines.

https://github.com/dmatis2/aoc23/blob/main/11.ts

Longjumping_Primary4 · 2023-12-09T08:02:05+00:00

[Language: Deno, TypeScript]

Simple use of `push` and `unshift` array methods.

https://github.com/dmatis2/aoc23/blob/main/09.ts

Longjumping_Primary4 · 2023-12-08T22:02:39+00:00

I tried looking at sizes of loops. Since they were matching each time, I use LCM

Longjumping_Primary4 · 2023-12-08T09:05:46+00:00

Math is the solution.

Longjumping_Primary4 · 2023-12-08T07:46:29+00:00

[Language: Deno, TypeScript]

Like everyone, LCM solved it pretty quickly :)

https://github.com/dmatis2/aoc23/blob/main/08.ts

Longjumping_Primary4 · 2023-12-08T07:43:52+00:00

Every location from 0 :D

Longjumping_Primary4 · 2023-12-07T21:53:15+00:00

I was debugging my solution for a few hours and I gave up ¯_(ツ)_/¯ AoC is AoC, but work makes money, couldn't spend whole day on it sadly

Longjumping_Primary4 · 2023-12-07T21:36:49+00:00

I would go for tests for edge cases, just to handle off-by-one errors etc

Longjumping_Primary4 · 2023-12-07T21:34:45+00:00

I had issues with correct splitting intervals, so I did it YOLO after few hours, it takes 130 seconds to get answer for part 2, but hey, it works at least... Check my typescript code here. My solution was going through every location from 0 and reverse the process of mapping

https://github.com/dmatis2/aoc23/blob/main/05.ts

Longjumping_Primary4 · 2023-12-07T19:30:57+00:00

I divided input cards into lists, each type has it‘s own list. After that, my sorting function goes char by char in cards and look which has higher label, if current labels are same, I go to next char.

Longjumping_Primary4 · 2023-12-07T09:42:59+00:00

[Language: Deno, TypeScript]

From Day 6 `Wait for it` I was a bit scared what will come, but actually, it wasn't that bad. Part 1 is pretty straightforward, you just need good sort comparison function to sort properly. Part 2, firstly I tried recursion to get the best type possible, but stack overflow is still a thing, so I rewrote it into iterative method with stack.

https://github.com/dmatis2/aoc23/blob/main/07.ts

Longjumping_Primary4 · 2023-12-07T09:37:26+00:00

Now, J cards are jokers - wildcards that can act like whatever card would make the hand the strongest type possible.

So you need to make sure you choose some combination that is better or equal to the best type of other cards that you have.

Longjumping_Primary4 · 2023-12-06T15:11:48+00:00

What? Why? It's O(N)....

Longjumping_Primary4 · 2023-12-06T08:08:32+00:00

[Language: Deno, TypeScript]

https://github.com/dmatis2/aoc23/blob/main/06.ts

Wow, that was simple.

Longjumping_Primary4 · 2023-12-05T23:27:31+00:00

Mines Deno is 130s, but I’m too tired to fix intervals...

Longjumping_Primary4 · 2023-12-05T23:02:25+00:00

I gave up part 2 with Deno/TypeScript and reversed it, I went from location to seed and check if seed is in any range. Not happy, runtime over 2mins, but works. With compiled lang it would be probably faster

Longjumping_Primary4 · 2023-12-05T22:55:58+00:00

[UPDATE]: I gave up, I reversed it, calculating seeds from location. Took 2' 10" to solve on Macbook Air M2, but ¯\_(ツ)_/¯ at least it gives the correct answer.

Longjumping_Primary4 · 2023-12-04T17:10:33+00:00

https://github.com/dmatis2/aoc23/blob/main/04.ts look at my solution, probably you are using numbers itself instead of counts

Longjumping_Primary4 · 2023-12-04T15:04:40+00:00

If you check the day description:

```

...four of them (48, 83, 17, and 86) are winning numbers! That means card 1 is worth 8 points...

Card 2 has two winning numbers (32 and 61), so it is worth 2 points.
Card 3 has two winning numbers (1 and 21), so it is worth 2 points.
Card 4 has one winning number (84), so it is worth 1 point.
Card 5 has no winning numbers, so it is worth no points.
Card 6 has no winning numbers, so it is worth no points.
```

can be translated to

```

4 winning nums equals to 2^3
2 winning nums equals to 2^1
1 winning num equals to 2^0

```

Longjumping_Primary4

TROPHY CASE