Advent-of-code VS AdventOfCodeHaskell

https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/Day10.hs Today is very verbose, but I wanted to use Lenses and State again. Went pretty ok all in all. The only thing I got wrong in the beginning was the ticking, this probably lead to some repeated code that I could have avoided if I understood the assignment right away.

Technically today should have been fun, but I just didn't see that signum will solve everything... then my snake was one point to short and I didn't notice... All in all pretty messy but I was able to clean it up: https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/Day09.hs Finally used State though!

https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/Day08.hs I parsed the grid as Map (V2 Int) Int and padded the grid with values of -1. I then used unfoldr with Map.lookup to get all 4 ways for a specific tree. In part A I simply filtered all trees out where the given predicate wasn't fulfilled. In part B I used a modified takeWhile function to take all trees which are smaller + one more than the current tree. I also had to get rid of the -1.

I should have planned more in the beginning, but it turned out fine. I abused Parsecs internal state to give every file the full name: https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/Day07.hs

Today was simple, for part a I initially used `zipWith4` and sets but that wasn't an option for part b, so I rewrote how the sets were created. https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/Day06.hs

After last years bingo I thought this is going to be tougher...: My solution

https://github.com/0xmycf/Advent-of-code/blob/main/2022/aoc22/src/Days/DayOne.hsI learned Haskell with last years AoC and it was quite a mess... This year is up to a much much better start. Lets see how this year will go :)

Haskell. I love balanced base systems! Was just telling my less-math inclined partner about them a bit ago :)

Haskell. Implementing nested lists is fun! The parser was surprisingly straightforward (except for an issue where it was expecting an extra newline at the end of my input), and the bulk of the problem was handled by implementing Ord instances for my data types.

Haskell. Recursive BFS in the State monad! Visited positions are marked with a '|' character, since this is 'z' + 2. My part 1 code didn't need too much modification for part 2, I only needed to account for the fact that adjacent 'a's can visit each other on the first step.

Code. Recursive BFS using the State monad to update grid positions

Haskell. Both parts are one liners, I add a no op before every addx to avoid skipping cycles, and using a 2D point data type (that I custom implemented based on Linear.V2 for named fields) makes handling the data a breeze!

346 for me. would've loved this as a part 3, since my solution adapts to it really well!

Something that really helped me out was finding a Tree Zipper library! This one doesn't have the best documentation but it was the only one that wanted to compile in my project lol. It does a lot of the heavy lifting of traversing the tree for you, once you figure out how to use it of course. Here's my not very cleaned up code if you wanna see what I did

Haskell. My idea for part 1 was basically "Find all the places the head goes, then follow it with the tail" which ended up working basically for free in part 2, and I chose the lazy implementation of "just compose these functions together manually, its what the language was built for". Definitely going to refactor that part in the morning lol

Pretty happy with my code, which amounts to a bunch of composed scanls, my part 1 solution gave me part 2 for free! Code

Code for the day, with parsing and extra utilities located in src/Util/