Wastl, Eric

Data Parsing

The input is an \(R \times C\) grid with # for a wall, S for the start tile, E for the end tile, and . for open spots.

Part One

The reindeer start at S facing East, and can move one tile at a time, increasing their score by 1 point. They can also rotate clockwise or counterclockwise 90 degrees at a time, increasing their score by 1000 points. What is the lowest score a Reindeer could possibly get?

Parsing

########
#..O.O.#
##@.O..#
#...O..#
#.#.O..#
#...O..#
#......#
########

<^^>>>vv<v>>v<<
v^^>>><<v^^>>>^

@ denotes the robot, O denotes a box, and # denotes a wall. <^^>>>vv<v>>v<< describes the sequence of moves that the robot will attempt to make. Ignore the newlines within the move sequence. If there are any boxes in the way, the robot attempts to push them. However, if the action makes the robot or a box move into the wall, nothing moves.

Parsing

The input is a list of all robots’ current positions \(p = (x, y)\) and velocities \(v = (dx, dy)\), one robot per line, e.g.,

p=3,6 v=4,-7
p=9,2 v=-1,-2

\(x\) represents the number of tiles away from the left wall, and similarly for \(y\) from the top wall (when viewed from above). The top-left corner of the space is \((0, 0)\). The velocity is given in tiles per second.

Parsing

The input is a list of machine configurations, where buttons \(A\) and \(B\) move the claw some distance \(X\) and \(Y\), and the location of the prize is specified.

Button A: X+43, Y+68
Button B: X+10, Y+36
Prize: X=4800, Y=6250

Button A: X+63, Y+41
Button B: X+89, Y+18
Prize: X=17648, Y=19276

namespace AoC2024;

using Vector = ClawContraption.Vector;
using Button = ClawContraption.Button;
using MachineConfig = ClawContraption.MachineConfig;
using DirectedEdge = ClawContraption.DirectedEdge;

public partial class ClawContraption
{
    public record struct Vector(long X, long Y);

    public record struct Button(Vector Delta, long TokenCost);

    public record struct MachineConfig(Button A, Button B, Vector Prize);

    public record struct DirectedEdge(Vector From, Vector To, long Cost);
}

public static class ClawContraptionExtensions
{
    public static Vector Move(this Vector vector, Button button) =>
        new(vector.X + button.Delta.X, vector.Y + button.Delta.Y);
    
    public static bool IsBeyondPrizeLocation(this Vector vector, MachineConfig config) =>
        vector.X > config.Prize.X || vector.Y > config.Prize.Y;
    
    public static IEnumerable<DirectedEdge> GetEdges(this Vector from, MachineConfig config)
    {
        var to = from.Move(config.A);
        if (!to.IsBeyondPrizeLocation(config))
            yield return new(from, to, config.A.TokenCost);
        
        to = from.Move(config.B);
        if (!to.IsBeyondPrizeLocation(config))
            yield return new(from, to, config.B.TokenCost);
    }
}

Part One

It costs \(3\) tokens to push the \(A\) button and \(1\) token to push the \(B\) button. What is the fewest tokens you would have to spend to win all possible prizes?

Parsing

Each garden plot grows only a single type of plant indicated by a single letter. This \(4 \times 4\) arrangement includes garden plots growing 5 different types of plants (labelled A, B, C, D, E).

AAAA
BBCD
BBCC
EEEC

The area of a region is the number of garden plots the region contains. The perimeter of a region is the number of sides of garden plots in the region that do not touch another garden plot in the same region. For example, the C plants are in a region with area \(4\) and perimeter \(8\).

Parsing

The stones are in a line, with each stone having a number engraved on it.

namespace AoC2024;

public static partial class PlutonianPebbles
{
    public static IEnumerable<ulong> ReadStones(string filePath)
    {
        var line = File.ReadAllText(filePath).Trim();
        return line.Split().Select(ulong.Parse);
    }
}

The snippet below contains a subtle bug. The using statement disposes the StreamReader at the end of the scope . This happens before the IEnumerable<ulong> is consumed. However, because ReadLine eagerly reads the content, there is no exception thrown.

public static IEnumerable<ulong> ReadStones(string filePath)
{
    using StreamReader inputReader = new(filePath);
    return inputReader.ReadLine()?.Split().Select(ulong.Parse) ?? [];
}

Setup

Every time you blink, the stones each simultaneously change based on the first applicable rule in this list:

Parsing

Each antenna in the map is tuned to a frequency indicated by a single lowercase letter, uppercase letter, or digit.

Two antennas with the same frequency create two collinear antinodes on either side where one of the antennas is twice as far away as the other, e.g.

Antinodes can occur at locations that contain other antennas.

Part One requires computing locations of antinodes. Given antennas with frequency \(f\), I need to pairwise match them and compute their antinodes. Being able to group all such antennas is useful for this puzzle.

Parsing

Each line represents a single equation, e.g., 292: 11 6 16 20.

Part One needs to make a decision based on each line independently. Parsing each line into a data structure and yielding that should suffice.

using System.Collections.Immutable;
using System.Text.RegularExpressions;

namespace AoC2024;

public partial class BridgeRepair
{
    public static IEnumerable<CalibrationEquation> Parse(string filePath)
    {
        using var inputReader = new StreamReader(filePath);

        string? line;
        while ((line = inputReader.ReadLine()) != null)
        {
            var numbers = InputLineRegex.Matches(line)
                .Select(match => long.Parse(match.Value));
            yield return new(numbers.First(), numbers.Skip(1).ToImmutableList());
        }
    }

    public readonly record struct CalibrationEquation(
        long Result, ImmutableList<long> Operands);

    private static Regex InputLineRegex = NumbersRegex();

    [GeneratedRegex(@"\d+")]
    static private partial Regex NumbersRegex();
}

Part One

Using only add and multiply, evaluated left-to-right (not according to math precedence rules), determine which equations could possibly be true. For example, \(292 = ((11 + 6) \times 16) + 20\). Of the equations that could possibly be true, what is the sum of their results?

Parsing

The map shows the current position of the guard with ^ (to indicate the guard is facing up from the perspective of the map). Any obstructions - crates, desks, alchemical reactors, etc., are shown as #.

using System.Collections.Immutable;

namespace AoC2024;

public partial class GuardGallivant
{
    public enum Orientation { Up, Right, Down, Left }
    public readonly record struct Coordinate(int R, int C);
    public readonly record struct Visit(Coordinate Coordinate, Orientation Orientation);
    
    public readonly (int RowCount, int ColCount, HashSet<Coordinate> Obstacles) AreaMap;
    public readonly Visit StartingPosition;

    public GuardGallivant(string filePath)
    {
        using StreamReader inputReader = new(filePath);
    
        HashSet<Coordinate> obstacles = [];
        Visit? maybeStartingPosition = null;

        string? line;
        int r = 0;
        int colsCount = 0;
        while((line = inputReader.ReadLine()) is not null)
        {
            var cols = line.ToCharArray().Index().ToList();
            cols
                .ForEach(pair => {
                    Coordinate coordinate = new(r, pair.Index);
                    if (IsObstacle(pair.Item))
                    {
                        obstacles.Add(coordinate);
                        return;
                    }

                    if (ToOrientation(pair.Item) is not Orientation orientation)
                        return;
                    
                    if (maybeStartingPosition is not null)
                        throw new ArgumentException(
                            $"Multiple starting positions detected at {maybeStartingPosition} and {(r, pair.Index, orientation)}");
                    
                    maybeStartingPosition = new Visit(coordinate, orientation);
                });
            
            if (colsCount != 0 && cols.Count != colsCount)
                throw new ArgumentException($"Illegal grid. Found differing column counts: {colsCount} vs. {cols.Count}");
            
            colsCount = cols.Count;
            r++;
        }

        if (maybeStartingPosition is not Visit startingPosition)
            throw new ArgumentException("No starting position found");

        StartingPosition = startingPosition;
        AreaMap = new(r, colsCount, obstacles);
    }

    private static bool IsObstacle(char c) => c == '#';

    private static Orientation? ToOrientation(char c) => c switch
    {
        '^' => Orientation.Up,
        '<' => Orientation.Left,
        '>' => Orientation.Right,
        'v' => Orientation.Down,
        _ => null,
    };

    private char ToCharVisualization(Coordinate coordinate)
    {
        if (AreaMap.Obstacles.Contains(coordinate))
            return '#';
        
        if (coordinate == StartingPosition.Coordinate)
        {
            return StartingPosition.Orientation switch {
                Orientation.Up => '^',
                Orientation.Left => '<',
                Orientation.Right => '>',
                Orientation.Down => 'v',
                _ => throw new ArgumentException(
                    $"Unrecognized orientation {StartingPosition.Orientation}")
            };
        }

        return '.';
    }

    private void VisualizeMapWithGuardMovement(HashSet<Visit> visits)
    {
        HashSet<Coordinate> visitedCoordinates = [.. visits.Select(v => v.Coordinate)];
        for (int r = 0; r < AreaMap.RowCount; r++)
        {
            for (int c = 0; c < AreaMap.ColCount; c++)
            {
                Coordinate coordinate = new(r, c);
                char representation = visitedCoordinates.Contains(coordinate)
                    ? 'X'
                    : ToCharVisualization(coordinate);
                Console.Write(representation);
            }
            Console.WriteLine();
        }
    }
}

Part One

The guard follows a strict patrol protocol which involves repeatedly following these steps:

Parsing

The notation X|Y means that if both page number X and page number Y are to be produced as part of an update, page number X must be printed at some point before page number Y.

The input contains page ordering rules (pairs of X|Y) and print queues (e.g., 75, 47, 61, 53, 29).

using System.Collections.Immutable;
using System.Text.RegularExpressions;

namespace AoC2024;

public partial class PrintQueue
{
    public readonly Dictionary<int, HashSet<int>> orderingRules = [];
    public readonly ImmutableList<ImmutableList<int>> printJobs = [];

    public PrintQueue(string filePath)
    {
        using StreamReader inputReader = new(filePath);
        string? line;

        while ((line = inputReader.ReadLine()) != null)
        {
            var match = OrderingRuleRegex().Match(line);
            if (match is null || !match.Success)
                break;
            
            var p1 = int.Parse(match.Groups["p1"].Value);
            var p2 = int.Parse(match.Groups["p2"].Value);

            var existed = orderingRules.TryGetValue(p1, out var p1Rules);
            p1Rules ??= [];
            p1Rules.Add(p2);

            if (!existed)
                orderingRules.Add(p1, p1Rules);
        }

        var printJobsBuilder = printJobs.ToBuilder();
        while ((line = inputReader.ReadLine()) != null)
        {
            printJobsBuilder.Add(
                line.Split(",").Select(int.Parse).ToImmutableList());
        }
        printJobs = printJobsBuilder.ToImmutable();
    }

    [GeneratedRegex(@"(?<p1>\d+)\|(?<p2>\d+)")]
    private static partial Regex OrderingRuleRegex();
}

Part One

Determine which updates are already in the correct order. What do you get if you add up the middle page number from those correctly-ordered updates?

Problem

This word search allows words to be horizontal, vertical, diagonal, written backwards, or even overlapping other words. Here are a few ways XMAS might appear, where irrelevant characters have been replaced with .:

..X...
.SAMX.
.A..A.
XMAS.S
.X....

The actual word search will be full of letters instead. For example:

MMMSXXMASM
MSAMXMSMSA
AMXSXMAAMM
MSAMASMSMX
XMASAMXAMM
XXAMMXXAMA
SMSMSASXSS
SAXAMASAAA
MAMMMXMMMM
MXMXAXMASX

Parsing

namespace AoC2024;

public partial class CeresSearch
{
    private readonly char[,] grid;

    public CeresSearch(string filePath)
    {
        using StreamReader inputReader = new(filePath);
        List<char[]> rows = [];
        string? line;
        while((line = inputReader.ReadLine()) != null)
            rows.Add(line.ToCharArray());

        int rowCount = rows.Count;
        int colCount = rows.First().Length;

        grid = new char[rowCount, colCount];
        for (int r = 0; r < rowCount; r++)
            for (int c = 0; c < colCount; c++)
                grid[r, c] = rows[r][c];
    }
}

For \(M \times N\) grids, C# has multi-dimensional arrays. These differ from jagged arrays, whose elements are arrays with possibly different sizes. In memory, multi-dimensional arrays are laid out as 1D arrays. When processing array data, cache locality impacts performance. If the computation needs to access multiple rows (e.g., image convolution, this problem), then multi-dimensional arrays offer an advantage. If processing row-by-row, then jagged arrays will also have cache locality. However, if the array is larger than 85Kb, then it ends in the large object heap, which is slower.

Day 1 - Advent of Code 2024: Historian Hysteria. Eric Wastl. adventofcode.com . Accessed Jun 25, 2025.

Data

There’s just one problem: by holding the two lists up side by side, it quickly becomes clear that the lists aren’t very similar. Maybe you can help The Historians reconcile their lists?

For example:

3 4
4 3
2 5
1 3
3 9
3 3

To parse the input:

Day 10 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Apr 12, 2022.

Part I

You ask the submarine to determine the best route out of the deep-sea cave, but it only replies:

Syntax error in navigation subsystem on line: all of them

The navigation subsystem is made of several lines containing chunks. There are one or more chunks on each line, and chunks contain zero or more other chunks. Adjacent chunks are not separated by any delimiter; if one chunk stops, the next chunk (if any) can immediately start. Every chunk must open and close with one of four legal pairs of matching characters:

Day 8 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Mar 7, 2022.

Part I Description

You barely reach the safety of the cave when the whale smashes into the cave mouth, collapsing it. Sensors indicate another exit to this cave at a much greater depth, so you have no choice but to press on.

As your submarine slowly makes its way through the cave system, you notice that the four-digit seven-segment displays in your submarine are malfunctioning; they must have been damaged during the escape. You’ll be in a lot of trouble without them, so you’d better figure out what’s wrong.

Day 7 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Mar 5, 2022.

Part I Description

A giant whale has decided that your submarine is its next meal, and it’s much faster than you are. There’s nowhere to run!

Suddenly, a swarm of crabs (each in its own tiny submarine - it’s too deep for them otherwise) zooms in to rescue you! They seem to be preparing to blast a hole in the ocean floor; sensors indicate a massive underground cave system just beyond where they’re aiming!

Day 6 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Mar 2, 2022.

Part I Description

The sea floor is getting steeper. Maybe the sleigh keys got carried this way?

A massive school of glowing lanternfish swims past. They must spawn quickly to reach such large numbers - maybe exponentially quickly? You should model their growth to be sure.

Day 4 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Feb 25, 2022.

Part One

You’re already almost 1.5km (almost a mile) below the surface of the ocean, already so deep that you can’t see any sunlight. What you can see, however, is a giant squid that has attached itself to the outside of your submarine.

Day 3 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Feb 23, 2022.

Problem Description

Part One

The submarine has been making some odd creaking noises, so you ask it to produce a diagnostic report just in case.

The diagnostic report (your puzzle input) consists of a list of binary numbers which, when decoded properly, can tell you many useful things about the conditions of the submarine. The first parameter to check is the power consumption.

Day 2 - Advent of Code 2021. Eric Wastl. adventofcode.com . Accessed Feb 19, 2022.

Problem Statement

Part One

Now, you need to figure out how to pilot this thing.

It seems like the submarine can take a series of commands like forward 1, down 2, or up 3:

• forward X increases the horizontal position by X units.
• down X increases the depth by X units.
• up X decreases the depth by X units.

Day 1 - Advent of Code 2021: Sonar Sweep. Eric Wastl. adventofcode.com . Accessed Feb 18, 2022.

Part One

As the submarine drops below the surface of the ocean, it automatically performs a sonar sweep of the nearby sea floor. On a small screen, the sonar weep report (your puzzle input) appears: each line is a measurement of the sea floor depth as the sweep looks further and further away from the submarine.