Advent of Code 2024 - C#

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);
    }
}

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);
    }
}

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();
}

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();
        }
    }
}

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();
}

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];
    }
}

namespace AoC2024;

public static partial class RedNosedReports
{
    private static IEnumerable<IEnumerable<int>> GetReports(string filePath)
    {
        using StreamReader inputReader = new(filePath);
        string? line;
        while ((line = inputReader.ReadLine()) != null)
        {
            yield return line.Split().Select(int.Parse);
        }
    }
}