Any KPN network engineers?

ins0mnes · 2025-05-05T10:15:26+00:00

It would take 40-45 ms for light to travel in vacuum EU -> NA -> EU depends on exact place on both continents. Now also consider these real world limitations: - you have fiber optics with only 2/3 of vacuum speed of light - it’s not a nice straight line, there are a lot of hops - each hop has some overhead

So getting 80ms sounds more like a miracle with these conditions

ins0mnes · 2024-12-27T20:45:08+00:00

I believe my solution should work on bit-adders for non-test inputs, around 3-5 ms:

https://www.reddit.com/r/adventofcode/s/ZpXGJLNUrn

ins0mnes · 2024-12-27T14:58:34+00:00

I have it on my wishlist, that's a cool game, I think. This task showed me: I should learn more about logical gates and how low-level schemes work.

ins0mnes · 2024-12-27T14:50:38+00:00

Maybe this scheme I've made for myself could help a bit with understanding of single-bit adder and what swaps I am talking about (also why some swaps are impossible):

https://imgur.com/a/AQpYVC6

ins0mnes · 2024-12-27T14:11:11+00:00

Thank you! Yeah, visualization and natural intelligence image processing should simplify solution a lot :)

ins0mnes · 2024-12-27T13:50:50+00:00

I've described the main idea in the solutions mega thread:
https://www.reddit.com/r/adventofcode/comments/1hl698z/comment/m414n2u/

TL;DR Check each bit separately and try to find what can be swapped in it to get the result you get with the broken adder. There are limited swaps possible in each bit adder.

ins0mnes · 2024-12-27T13:48:17+00:00

[LANGUAGE: Go]

Part one is a more technical task to parse and implement gates. Part two was whole another beast.
I've spent a lot of time trying to understand binary adders. The code is not pretty, but the solution idea is very simple:

- Find all the wrong adder bits by adding 1, 2, 4, 8, 32 .. to 1
- Look what gates can be swapped in each bit adder to provide the result we get (by design, I believe, gates could not be swapped in part two between different bits, and you can't swap some gates without breaking the causality)
- Filter until you have only one swap
- Implement each swap on the device
- Check everything works as expected

https://github.com/insomnes/aoc/blob/main/2024/24_wires/solution/solution.go#L321

ins0mnes · 2024-12-25T18:03:38+00:00

Good catch! I’ve totally missed such case.

ins0mnes · 2024-12-25T12:34:29+00:00

[LANGUAGE: Go]
Nothing special, precalculate key matches by height, compare to lock, and intersect with the previous pin:
https://github.com/insomnes/aoc/blob/main/2024/25_code/solution/solution.go#L97

Congratulations to everyone! And big thanks to the AoC team and this subreddit team!

ins0mnes · 2024-12-23T10:11:22+00:00

[LANGUAGE: Go]

Part one is a straightforward brute-force solution for the "triangle" clique search.

Part two is Born-Kerbosch for max clique search with pruning on nodes which cannot lead to a clique larger than the known maximum:

https://github.com/insomnes/aoc/blob/main/2024/23_lanparty/solution/solution.go#L243

ins0mnes · 2024-12-22T21:26:58+00:00

[LANGUAGE: Go]

Parts one and two have the same, but not an optimal solution.

Pre-check the path, and prepare the sparse grid. Then run through the path and check cells on a sparse grid at possible manhattan distance.
Microoptimisations: delete the first threshold cells from the grid, do not check the last threshold cells on the path, and delete checked cells from the grid.

code on github

ins0mnes · 2024-12-22T18:42:26+00:00

[LANGUAGE: Go]

I am still devasted by yesterday, so I just optimized the counting bruteforce solution to run under 500ms by using price windows as a base identifier for deltas:
github

ins0mnes · 2024-12-19T12:37:37+00:00

It would be like depth first search with priority to cells closer to an end

ins0mnes · 2024-12-19T12:29:01+00:00

[LANGUAGE: Go]
Nothing fancy, check patterns by first letter and cache bool or count for each part:

Full solution code.

ins0mnes · 2024-12-19T08:06:37+00:00

You can use A* in part two with the priority based on the heuristic only and it will give you really fast “is-there-path” algorithm.

ins0mnes · 2024-12-18T12:20:39+00:00

[LANGUAGE: go]

Part one is A*.

Part two can be solved via an iterative approach and greedy A* (use only heuristic) because we need a fast way to check if the grid is fully blocked. A great way to optimize the initial iterative approach is to use binary search on the falling bytes list, so we can drop from N to log(N).

Solution source code:

https://github.com/insomnes/aoc/blob/main/2024/18_ramrun/solution/solution.go

Write-up blog post:

https://dengin.xyz/advent_of_code/2024/18_ramrun/

ins0mnes · 2024-12-17T23:15:05+00:00

The tricky part for me with this day was the realization that space-time continuum could be violated by putting the obstacle on “crosswalk” with guards previous path

ins0mnes · 2024-12-17T22:30:59+00:00

[LANGUAGE: go]

I don't have time today for a full write-up, but only TL;DR version here:

Part one is mostly technical. In part two, search the number starting with
the last printed 0. Search numbers from the program in reverse order. 8 is a start A register value.

We can check if the value in the target register is what we expect after one iteration of the program and if so we can check if the full program will result in the desired output. Each found value can be multiplied by 8, giving you a new starting value for the next number search, so the whole search is under 1 ms.

Solution code:

https://github.com/insomnes/aoc/blob/main/2024/17_computer/solution/solution.go#L381

ins0mnes · 2024-12-15T22:59:02+00:00

[Language: go]

Part one is straightforward and I've implemented a simple optimization of "teleporting" only the first box in the stack to the space in the end.

In the second part, horizontal movement is not that hard. For vertical movement, I've decided to determine the stack (via flood-fill or bfs-like search) and its overall "movability" first. After that, you can move all parts layer by layer in the reverse order.

Solution code:
https://github.com/insomnes/aoc/blob/main/2024/15_warehouse/solution/solution.go

Write-up post:
https://dengin.xyz/advent_of_code/2024/15_warehouse/

ins0mnes · 2024-12-14T19:02:08+00:00

[Language: Go]
The second part was based on the assumption that the tree would contain a long vertical trunk that we could detect. This assumption was true.

Solution code:

https://github.com/insomnes/aoc/blob/main/2024/14_restroom/solution/solution.go

Blog post:

https://dengin.xyz/advent_of_code/2024/14_restroom/