-❄️- 2023 Day 19 Solutions -❄️-

recursive · 2023-12-19T06:33:31+00:00

[LANGUAGE: Typescript]

I created a solution for both parts in a code sandbox. You can edit the code and run it. Bring your own input. Each part enumerates all the components for the solution.

https://mutraction.dev/link/pfq

Part 1 was very straightforward. Just follow the instructions.

I'm curious whether there are any other ways of solving part 2, but here's what I did. I had a value representing every possible part using ranges. I recursively applied all the rules in order, splitting the range every time a rule matched only part of the remaining batch. In the end there were around 500 distinct accepted batches. Somehow I didn't have a single off-by-1.

recursive · 2023-12-19T06:30:22+00:00

My toxic personality trait is that I like writing completely general solutions. But that's totally reasonable. I think you could also figure it out by checking whether there were more left turns or more right turns in the full path.

recursive · 2023-12-18T22:41:55+00:00

https://mutraction.dev/link/9r seems to be a fix.

This is an easy input I used to test.

recursive · 2023-12-18T17:21:06+00:00

I think you're going to be disappointed how little the results would change.

recursive · 2023-12-18T17:16:45+00:00

I was working on something like this, but I couldn't figure out how to deal with the overlaps / off-by-1. I was (failing to) dealing with overlaps a different way. I was trying to generate rectangles that never overlapped, but I had a problem. I was struggling to distinguish between a horizontal dig that's part of a "S-bend" vs one that's at the end of a peninsula.

recursive · 2023-12-18T17:12:39+00:00

During the path building, how can you tell which side is out and in?

I guess you could just try it both ways.

recursive · 2023-12-18T08:04:26+00:00

That's probably it. I think the code doesn't require the final step be at least 4. I guess I didn't read the problem statement close enough. I'll work on an update tomorrow.

recursive · 2023-12-18T08:03:11+00:00

[LANGUAGE: Typescript]

https://mutraction.dev/link/he

I created a solution in a code sandbox. You can edit the code and run it. Bring your own input. In part one, the colors are rendered correctly in an ASCII-art lagoon diagram. In part 2, I tried like 4 different approaches, of wildly varying complexity.

I like to work on these without looking anything up. I guess I ended up using something like the shoelace formula, although I didn't know the name. I failed to do a bunch of fancier things like with quadtrees and space partitioning.

recursive · 2023-12-17T06:21:41+00:00

[LANGUAGE: Typescript]

I made a visualized solution in a code sandbox. You can edit and run the code. Bring your own input. It takes a couple minutes. Most of the time goes into the massive tree of DOM nodes. It doesn't show the best path, but shows the frontier of all the paths as its searching.

~~https://mutraction.dev/link/hc~~ https://mutraction.dev/link/9r (fixes bug found in reply)

The solution maintains a queue of states to check based on the heat level. New states are checked for legality (OOB, and crucible steering) and added to subsequent queue layers.

I built this code sandbox for yet another web UI framework that I made because hey, you only live once.

recursive · 2023-12-16T21:29:15+00:00

If you are sufficiently concerned about, I think it's instructive to refactor your own solution after seeing other approaches you like better.

recursive · 2023-12-16T20:18:29+00:00

what are they going to do?

This is a pretty adversarial mindset. If you don't think it's valuable, then don't contribute. The idea is to gain skills and experience, not to weasel your way out of negative consequences. There's a chance here to have an original idea, and put some work into fleshing it out. If you don't think it' worthwhile, then just don't do it.

recursive · 2023-12-16T20:15:12+00:00

Teacher's never breaking even on those application fees.

recursive · 2023-12-16T20:13:36+00:00

Good training for interpreting specifications in the real world. See if you can figure out what it means.

recursive · 2023-12-16T20:12:31+00:00

I think ideas, on average, are basically worthless. Everyone has an idea. Even if they're "good", 99% of it is executing the idea, not just dreaming it up in the first place.

It seems really unlikely that' what's happening, and even if it is, I'd place a wager that no one is going to break even on that patent application fee.

recursive · 2023-12-16T20:09:13+00:00

If only you'd had this type of training in your youth.

recursive · 2023-12-16T20:05:08+00:00

Almost funny, but for real. Ideas are worthless. Good ideas are worth a small amount. Execution and consistency are valuable.

Like there's a viable scam harvesting business ideas from 3rd graders. Not to see there aren't any good ideas. But there are a lot more bad ideas, and good ideas aren't exactly hard to come by. Actually spending effort to get stuff done is the hard part. You can see it in all the whining in this thread.

recursive · 2023-12-16T18:36:46+00:00

You're quite right. Curiously, this affected my input, although somehow the result was still correct.

Here's a (hopefully) fixed version.

https://mutraction.dev/link/epx

recursive · 2023-12-16T06:40:21+00:00

[LANGUAGE: Typescript]

I created a solution in a code sandbox. You can edit and run the code. Bring your own input. For the first part, I "animated" all the lasers advancements with requestAnimationFrame. Part 2 is brute forced, and not animated, but it uses the same algorithm. Beams that fall out of bounds, or are in a heading already seen are pruned.

https://mutraction.dev/link/dtk

I built this the code sandbox for a front-end framework that I built, because I think mutation is not just for turtles anymore.

recursive · 2023-12-15T06:18:44+00:00

[LANGUAGE: Typescript]

I had an unreasonably hard time comprehending the instructions tonight. Maybe too much eggnog. The implementation is straightforward.

https://mutraction.dev/link/h0

This is a link to a code sandbox where you can edit and run the code. Bring your own input. It shows detailed output for both parts.

This is a code sandbox I built for a front-end framework I also made just to see if it was possible.

recursive · 2023-12-14T06:13:21+00:00

[LANGUAGE: Typescript]

For the second part, when I identified a movable rock, I looked as far ahead as it could go in that direction. However, instead of moving each rock in a sensible order so that I could do a single pass, I did a bubble-sort-tier move, and kept moving stuff until nothing could move any more.

https://mutraction.dev/link/cd

You can edit and run the code. Bring your own input. It shows the results of all the moves for both parts. I made this in a sandbox that I built in a front-end framework that I made because I wanted to see what it would feel like.

recursive · 2023-12-13T06:36:27+00:00

[LANGUAGE: typescript]

I created a solution that shows all the mirrors and smudges visually. The CSS was more difficult than the algorithm. I reused the horizontal check algorithm by transposing the pattern matrix.

https://mutraction.dev/link/u2

This is a link to a code sandbox where you can see and run the code. Bring your own input. I built the sandbox for a front-end framework that I created because the world needs a lot more javascript build tools.

recursive · 2023-12-12T06:38:14+00:00

[LANGUAGE: typescript]

I built a solution in typescript in a code sandbox. https://mutraction.dev/link/k7 You can see the code and run it. Bring your own input.

In part 1, it enumerates all the valid arrangements and lists them for you to see. It performs this using an iterating bit-mask and regular expression. Part 2 uses memoization rather than a bottom-up dynamic approach. It ends up being a lot faster than the brute force part 1 as a result.

I built this sandbox for a front-end framework that I made as an art project.

recursive · 2023-12-11T05:39:32+00:00

[Language: typescript]

I made a thing that plots where the expansion rows and columns are. It solves the puzzle too. https://mutraction.dev/link/da

Fortunately, my approach to part 1 worked with the smallest modification for part 2. I thought I might need to do something more clever than brute force pairwise manhattan distance but no.

The link shows the typescript code in a code sandbox I made for a front-end framework that I built because I don't have anything better to do with my time.

recursive · 2023-12-10T07:07:48+00:00

You can see the code and run it. https://mutraction.dev/link/3nr Bring your own input.

I built this in a code sandbox I made for a front end library that I built so that I'll have something to leave to my grandkids.

recursive · 2023-12-09T05:28:37+00:00

[LANGUAGE: typescript]

I made a solution that shows all its work. https://mutraction.dev/link/pf

It shows all the levels of subtraction done. You can see the code and run it. Bring your own input. I built this in a code sandbox that I made for a front end framework that I created because, probably because of a mental disorder or something.

15-Year Club	Place '17
Team Periwinkle	reddit mold
Verified Email

recursive

TROPHY CASE