Sidebar
Advent of Code
Advent of Code 2023 recap blog post [https://dan-schreiber.com/blog/2024/1/8/advent-of-code-2023-recap](https://dan-schreiber.com/blog/2024/1/8/advent-of-code-2023-recap). Thanks to Eric Wastl and [@adventofcode](https://lemmy.world/c/adventofcode) for another great year. [#adventofcode](https://mastodon.social/tags/adventofcode) [#adventofcode2023](https://mastodon.social/tags/adventofcode2023) [#aoc](https://mastodon.social/tags/aoc)
If you add tickets with the point multiplier the code is just off by one, and I spotted the problem immediately.
Hey, I've got a few solutions written in Kotlin. - [Day 1](https://gist.github.com/eingruenesbeb/dd9fb02bf1911421689de5c1e5c4f219) - [Day 2](https://gist.github.com/eingruenesbeb/135911e5fd1896817c8f94743f314fd0) What do you think? I feel like I cheated a bit on the solution for the first day using built-in functions to search the line-string, but if it works, don't fix it I guess...
How was day one for everyone? I was surprised at how tricky it was to get the right answer for part two. Not the usual easy start I've seen in the past. I'd be interested to see any solutions here.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/25) was the final challenge for the year, and as usual was quite simple and had only one part. This involved parsing and process numbers written in what I learned was called "[balanced base](https://en.wikipedia.org/wiki/Balanced_ternary) five" notation. Thanks for following along, now we just need to wait a few days to see what this year holds!
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/24) had us running round a maze with moving obstacles. Treating time as a dimension allowed me to build a graph and find the shortest path. Part 2 just required doing this three times. This took me closer than I like to a full second runtime, but not close enough to make me re-think my solution.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/23) was a kinda variant of Conway's Game of Life: we had to move elves around according to a set of rules while avoiding collisions and observe the size of the bounding box after 10 rounds. Part 2 asked us to run until the pattern stagnated. Nothing clever in my solution as most of the challenge seemed to be in understanding the rules correctly :-)
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/22) started quite easily: build a map and then follow some directions to navigate around it. Part 2? The map is now wrapped around a cube. Oof. I dealt with it by setting up logic for an "ideal" cube layout, and then mapping the provided definition onto that. Oddly, my solution for part2 seems to run faster than part1 despite all the added complexity...
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/21) was again quite an easy one, requiring us to build up a tree of values and operations on those values. Part 1 had us evaluate the root value, and part 2 required us to change the value of a specific node to ensure that both branches below the root node evaluated to the same value. The linear nature of the operations allowed me to just try two different values and then interpolate the correct answer.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/20) came as a welcome relief after two tricky days! We had to jumble a file according to some simple rules. The biggest challenge was interpreting the instructions correctly; the solution itself took only a few lines. Part two just added a key and increased the number of iterations. My original approach still ran in under a second (0.7s) so I didn't bother looking into it any further, and just enjoyed the free time :-)
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/19) was a sudden increase in difficulty (for me anyway). We had to find the best route for opening a system of valves to maximise the total flow through the network. Part two repeated the exercise, but with the addition of a friendly elephant to help with the work. I was able to simplify the network enough to solve part 1 in a reasonable time, but had to hack my solution for part 2 terribly to get it under a second. Reading some other solutions, I missed out on some key approaches including pre-calculating minimum paths between all pairs of valves (e.g. using the [Floyd–Warshall algorithm](https://en.wikipedia.org/wiki/Floyd–Warshall_algorithm)), aggressive caching of intermediate states, and separating out my movements from the elephant's movements. Go and read [@hal9001@lemmy.world](https://lemmy.world/u/hal9001)'s [Clojure solution](https://github.com/jjcomer/advent-2022/blob/main/src/y2022/d19.clj) for a much more thoughtful approach :smile:
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/18) had us finding the surface area of a cluster of cubes, first in total, then excluding any internal voids. Nice and easy compared to the last couple of days!
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today's challenge](https://adventofcode.com/2022/day/17) had us building a simple Tetris clone with the additional twist that a regular sequence of jets of air blow the falling pieces sideways. Part two asked us to model this for a bazillion cycles, so we needed to keep an eye on the pattern of landed blocks and look for the same pattern to repeat.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/16) we had to monitor and manage flow through a network of valves. The second part added a friendly elephant to help. So for me it was about building a weighted graph and then milling around it looking for good solutions. Despite my chaotic approach and somewhat ugly code, my solution ended up being impressively fast.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/15) we were given the output of a set of sensors recording the locations of their nearest beacons, and were asked to derive more information about those beacons. This was made much simpler due to the odd way these beacons' signal propagated, involving tracking diagonal lines rather than doing any trig. Part 2 required a bit of lateral thinking to avoid an overly-slow solution.
The 2023 event starts in december, I'll try it in Rust. What are the posts about Nadvent of code and where can I find the tasks?
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/14) we had to build a set of buckets from the given spec, and observe the behaviour of sand grains as they fell into them. I found this a really satisfying challenge, and enjoyed the visualisations that many people wrote for their solutions.
Does anyone have any goals they are hoping to achieve this year? I'm planning to try and learn Raku but probably not use it as my primary solution language. I always prefer to do a secondary implementation in the new language so I'm not stuck on syntax and how to solve the problem. As always my goal is to finish all the stars ✨🌟✨
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today](https://adventofcode.com/2022/day/13) we had to build and compare tree structures. I used Petitparser to parse the input and build the tree, and some questionable logic for the comparison, but it gave the right answer and quickly enough, so ship it!
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. Continuing the ramp up in difficulty, [today's challenge](https://adventofcode.com/2022/day/12) asked us to do some literal (virtual) hill-climbing, but with the added constraint of not allowing too large a step. I was able to re-use an existing Graph class I had built along with an implementation of Dijkstra search.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. Proving that the jump in difficulty yesterday wasn't a fluke, [today's challenge](https://adventofcode.com/2022/day/11) required careful interpretation of the instructions, as well as parsing a complicated input describing how a bunch of monkeys update and pass values between them. I had originally (ab)used the incredible [Petitparser](https://pub.dev/packages/petitparser) package for this, and was surprised to see this is supported in DartPad so no rewrite was needed. Part two increased the number of rounds dramatically, so using the Least Common Multiple kept numbers under control without moving to BigInts.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. [Today's challenge](https://adventofcode.com/2022/day/10) felt like a massive jump in the complexity of the problem statement. Fortunately this resolved into a reasonably simple solution. The one fly in the ointment was that part 2 required you to 'read' what letters were displayed on the 'screen'. As there seems to be one puzzle each year that requires this, I had a simple OCR solution available from a previous year.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. Today we had to drag a segmented worm's head around a grid according to a given set of directions and count how many cells the tail visited. For part 2, the worm got longer. Solving this felt much easier than yesterday's challenge. That must mean tomorrow will be tricky...
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. I remember really enjoying this challenge. We were asked to determine visibility across a grid of variable height trees, first looking in, then looking out. What was easy to describe turned out to be quite tricky to implement (for me at least!). As so many AOC problems involve navigating around grids, I had a handy Grid class availalble to help me. Perhaps a bit OTT for this use, but when you have a hammer...
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. Quite a jump in difficulty today, requiring us to reconstruct and query a notional filesystem based on the results of a series of `cd` and `ls` commands. Building a simple graph revealed the required information.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. Another simple challenge today, requiring us to look for (and avoid) repeating characters in a given run of characters. I suspect the authors hoped we would write clever code that noted the locations of any repeated characters and then skipped forward to avoid them, but the source text and key lengths were so small that none of that was necessary. Just mashing every successive run of test candidates into a Set to test for uniqueness ran all tests and the full solution in 65ms.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. After a few days of gentle introductory challenges, things ramped up a little today. Not due to the difficulty of the puzzle itself, but the unhelpful way in which the input data was formatted :-). Given that increase in difficulty, I think a lot of people were expecting part 2 to be a Towers of Hanoi challenge, but no, it was just a simple change to part 1.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. This challenge required us to identify overlapping ranges. One of my first programming jobs many years ago involved writing a maintenance scheduling system, and I still remember the 'Aha!' moment when I realised how much simpler the checks could be than the convoluted rules that were my first attempt. Anyway, this time round I just re-used a class from a previous year to model the ranges. Much easier :-)
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to [last year's challenges](https://adventofcode.com/2022). You can read, run and edit today's solution by following the post link. This challenge was about rucksack packing but, rather than the classic computer science problem, it only required finding the common character between different strings. I chose to simply drop the strings into Sets and find the intersection.
As a warmup for this year's Advent of Code, I'm re-reading and posting my solutions to last year's challenges. You can read or run today's solution by following the link above. Day 2 involved playing Rock Paper Scissors following a strategy guide. I solved part one by building a simple look-up table encoding the provided score values. Solving part two just required building a second lookup table to key into that first table.
As 2023 Advent of Code is approaching fast, I thought I'd revisit my 2022 entries, and I realised a good focus would be to post one a day during November. No guarantees as to the quality of the algorithms used, but hopefully people will find the code readable and interesting. If anyone has questions or ideas for improvement, I'd love to hear them. They were all written in Dart, and I will modify each one to allow it to run online in the browser. Some of the code may look a little odd as I had to inline the functionality from some libraries that I used as DartPad doesn't support them all. Anyway, here's the core of my response to Day 1. The full code can be read and run by following the link above. ``` int part1(String lines) => totalCalories(lines).first; int part2(String lines) => totalCalories(lines).take(3).sum; Iterable totalCalories(String lines) => lines .split('\n\n') .map((e) => e.split('\n').map(int.parse).sum) .sorted(descending); ```
Time to start practicing and catching up on prior missed stars. ☃️