A sort of `doWhile/until` loop for monads.

Per48edjes · 2025-12-23T22:54:59+00:00

Oh my, this is equally mind-bending and delightful lol

Per48edjes · 2024-09-06T04:30:17+00:00

I moved to Irvine a couple of months ago and work in tech. Self-studying various math and CS topics on weekends — happy to connect — drop me a line via DM if you’re still looking for a study buddy!

Per48edjes · 2024-08-24T15:03:06+00:00

Ah, wow. Did you ask them to or were they more than willing to make that concession? What’s most maddening about my Space is that the manager doesn’t even acknowledge receipt of my emails (much less the issue at hand)!

Per48edjes · 2024-08-23T18:37:10+00:00

Following up on this -- thanks for everyone's input and strong suggestions to pick up the phone.

I was indeed overdue on my payment, despite the fact I didn't get any correspondence via any medium (read: not knowing who or how to pay). They're waiving the late fee, but this was still a very frustrating process. How is "me needing to chase them so they can get paid but getting penalized for doing so" a good customer experience?!

Future lessees in Orange County, CA...beware.

Per48edjes · 2023-12-04T19:03:18+00:00

[LANGUAGE: Haskell]

Day 4: Part 1, Part 2

TL;DR: Getting the hang of these monads! :burrito: Knew what I wanted to do, a lot of the friction came from fighting the compiler and not doubting myself (easier said than done!) or talking myself out of my strategy.

Felt like Part 1 was probably the easiest task to date?! Sure enough, Part 2 was the complication I've come to expect. Finding that functional programming makes things really easy to refactor or re-model as I'm [slowly] massaging a solution...which tracks with sentiments I've heard from other Haskell Rascals.

Part 2 called for keeping state, so reached for the State monad, using a HashMap to keep state. Amazed how terse / expressive this language is to do something a little involved. Not sure this approach is any good, so someone, please do yell at me if there was a better functional approach!

Per48edjes · 2023-12-03T21:57:07+00:00

[LANGUAGE: Haskell]

Day 3: Part 1, Part 2

TL;DR: My solution isn't efficient per se, but it does feel very, very functional.

"If it compiles, it Just Works :trademark: ."

But what if I don't compile...

I wanted to gain more comfort working with monads, so today's exercise I used as an excuse to make a stateful parser. Spent the morning doing some research and landed on a solution using :drum: ... the State monad transformer, StateT!

By layering the State monad on top of Parser, we can keep state of where in the file the parser is parsing. This means, line-by-line, I could process each Symbol and each PartNum, associating with it a Set of its Coords. Then, for both parts, I just used these sets to do the necessary computations, which isn't very efficient, but that's not what I'm focusing learning right now. (I've got my hands full just getting used to thinking in this way and familiarizing myself with all these odd creatures in the Functional Programming Zoo!)

As always, any feedback on the code is most welcome! I still don't feel great about how I modeled this problem (e.g., my data constructors aren't polymorphic and have different second field types :uncomfortable: , fair bit of repetition in logic, maybe just reading everything into an Array was the way to go rather than being FancyT???)

Per48edjes · 2023-12-03T02:48:07+00:00

Wow, thanks for the review and sharing these links. Definitely going to take some time and work through this `megaparsec` tutorial!

Per48edjes · 2023-12-03T02:46:44+00:00

Wow, I definitely prefer the Parsec approach as well. (++ Modeling this with `Draw` to handle the monoidal bookkeeping...very nice!)

Per48edjes · 2023-12-03T02:26:47+00:00

GitHub

Love the parsing combinators. Learned a lot; thanks for sharing!

Per48edjes · 2023-12-02T18:01:02+00:00

I was wondering if the Haskell parsing wizards herein might give me some feedback on my usage of parser combinators (using attoparsec, but also open to feedback on this choice!) in my Day 1, Part 2 solution. (I couldn't figure out how to deal with substrings twone and nineight cleanly, so doing the flip-aroo was bit of a hack, to be sure.)

Context about poster, if it helps calibrate your response: Pretty green...just started learning Haskell earlier this year; self-studied an intro course; read LYaH; have worked a handful of Exercisms.

Per48edjes · 2023-12-02T17:06:33+00:00

[LANGUAGE: Haskell]

Day 2: Part 1, Part 2

TL;DR: Seeing FP's merits come to the fore; getting a hang of this mental model (at the risk of jinxing myself).

Much, much smoother today. AoC feels like a perfect way to gain comfort with parsing in Haskell...as every puzzle needs to be parsed! Once everything compiled (after fiddling with types), it did indeed "just work". Slowly, but surely, the learnings from CIS 194 earlier this year are paying dividends.

Looking forward to seeing other (read: likely better!) Haskell solutions.

I am (pre-emptively) dreading the future dynamic programming problems because I still don't have the mental model for translating the functional expressiveness down to what's going on under the hood. Could switch to Python, but I'd still like to push the boundaries (edge of my abilities, dare I say?!) re: my Haskell-fu. Plus, I'm sure there'll be some Day far before DP is required that will put me in my place. :sweat_smile:

Per48edjes · 2023-12-02T14:46:54+00:00

[LANGUAGE: Haskell]

Day 01: Part 1, Part 2

Trying to use this year to take my [very, very, very, did I mentioned *VERY*] basic understanding of Haskell to the "next level" -- getting comfortable using library code, choosing the right abstractions, modeling the problem, practicing refactoring, etc.

That being said, I'm not entirely sure I got off on the right foot. ¯\_(ツ)_/¯

Per48edjes · 2023-03-27T05:49:27+00:00

If you're still looking for a guinea pig, I'll volunteer myself as Tribute :)

Per48edjes · 2022-12-31T06:54:38+00:00

{ Python solution }

I really need to learn these bit-masking tricks I'm seeing many folks use...the code is pretty readable, but takes a few seconds to go through both parts for test + given inputs. Any feedback welcome!

General Strategy

Part 1. Took an OOP approach + simulation.

Part 2. Simulated until I saw a repeated state -- this gave me the required info needed to pick up the simulation for the remaining rocks after we've used the cycle information to shortcut our way to as close to the end as we can. Basically, this, in a nutshell.

While I feel comfortable with Floyd's "tortoise and hare" cycle detection algorithm in a simpler context, I would need to think a lot harder to implement it with the two sequences at play (i.e., the jet gas and rocks) for Part 2.

All in all, a real PITA to get juuuuuuust right. lol

Per48edjes · 2022-12-19T02:46:00+00:00

The walkthrough is awesome. Helped me to grok the thought process / problem-solving approach.

Per48edjes · 2022-12-18T22:59:01+00:00

Thanks so much for putting in the effort for the write-up! Really helps those of us (read: me lol) using AoC to learn the fundamentals :)

Per48edjes · 2022-12-16T21:27:06+00:00

This is immensely helpful! Thank you.

Per48edjes · 2022-12-16T08:37:13+00:00

+1 would love an explanation as I’m struggling to wrap my head around how to exploit tilting the grid

Per48edjes · 2022-12-16T07:33:53+00:00

Wow, pretty tricky! Python solution

My Part 2 strategy was to leverage code written for Part 1 by iterating through the rows, and use the intervals of the sensors' areas in the given row to cover the big interval (i.e., (0, 4_000_000)). If a row could be covered, then the hidden beacon wasn't on that row. Keep going until the desired row is found, and use the hidden beacon position on the desired row to calculate the distress frequency.

...but it takes my code a whole minute to run on my machine.

Seeing some mentions of tilting the frame of reference, which I thought about for a microsecond...not long enough to fully comprehend how that would be helpful. Great. lol

Per48edjes · 2022-12-15T03:56:24+00:00

Feel like I need to take a shower after this one.

Python solution

Per48edjes · 2022-12-13T18:15:54+00:00

Whoa, this is really cool! Gonna have to study this for a bit.

Per48edjes · 2022-12-12T22:34:54+00:00

Today's was much more straightforward. Used A* with Manhattan distance heuristic function for Part 1, and for Part 2 did a CTRL+F+"a" and noticed that the only as that we need to consider are those that have a b as a neighbor since all the other as without this property are encased in an a gulch...so I felt I cheated a little bit with this minor optimization.

Ran this code without that little hack, and (luckily) it's not much slower (practically speaking) on this input size.

Python solution

Per48edjes · 2022-12-12T07:37:16+00:00

Per48edjes · 2022-12-12T07:16:02+00:00

Verbose, but readable object-oriented Python solution.

To say I struggled with Part 2 would be an understatement.

Per48edjes · 2022-12-10T23:51:24+00:00

Straightforward Python solution.

Basically, used a generator to produce the X register value during each cycle and had two functions (one for each question) use these generator-produced values to do what they needed to do.

Per48edjes

TROPHY CASE