diff --git a/01/Trebuchet.Tests/GlobalUsings.cs b/01/Trebuchet.Tests/GlobalUsings.cs index 7fef4b0..2d5b473 100644 --- a/01/Trebuchet.Tests/GlobalUsings.cs +++ b/01/Trebuchet.Tests/GlobalUsings.cs @@ -1,2 +1,3 @@ +global using FluentAssertions; + global using Xunit; -global using FluentAssertions; \ No newline at end of file diff --git a/01/Trebuchet.Tests/PartTwoPuzzleSolverTests.cs b/01/Trebuchet.Tests/PartTwoPuzzleSolverTests.cs index 3854d4f..3e7cd26 100644 --- a/01/Trebuchet.Tests/PartTwoPuzzleSolverTests.cs +++ b/01/Trebuchet.Tests/PartTwoPuzzleSolverTests.cs @@ -36,6 +36,6 @@ public class PartTwoPuzzleSolverTests { var input = await File.ReadAllLinesAsync("INPUT.txt"); var result = _sut.SumCalibrationValues(input); - result.Should().BeLessThan(54249); + result.Should().Be(54249); } } \ No newline at end of file diff --git a/02/CubeConundrum.Tests/CubeConundrum.Tests.csproj b/02/CubeConundrum.Tests/CubeConundrum.Tests.csproj new file mode 100644 index 0000000..26a27fd --- /dev/null +++ b/02/CubeConundrum.Tests/CubeConundrum.Tests.csproj @@ -0,0 +1,36 @@ + + + + net8.0 + enable + enable + + false + true + + + + + + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + + + + + + + + + + PreserveNewest + + + + diff --git a/02/CubeConundrum.Tests/GameTests.cs b/02/CubeConundrum.Tests/GameTests.cs new file mode 100644 index 0000000..a3f8843 --- /dev/null +++ b/02/CubeConundrum.Tests/GameTests.cs @@ -0,0 +1,52 @@ +namespace CubeConundrum.Tests; + +public class GameTests +{ + [Theory, MemberData(nameof(TestData.Games), MemberType = typeof(TestData))] + public void PowerOfMinimumCubesNeeded_GivenAGame_ItShouldReturnTheSumOfTheMinimumCubesNeededForEachResult(Game game, int expected) + { + game.PowerOfMinimumCubesNeeded.Should().Be(expected); + } + + public static class TestData + { + public static readonly IEnumerable Games = new List + { + new object[] + { + new Game + { + Id = 1, + Results = + { + new() + { + Cubes = + { + new() { Count = 3, Color = CubeColor.Blue }, + new() { Count = 4, Color = CubeColor.Red } + } + }, + new() + { + Cubes = + { + new() { Count = 1, Color = CubeColor.Red }, + new() { Count = 2, Color = CubeColor.Green }, + new() { Count = 6, Color = CubeColor.Blue } + } + }, + new() + { + Cubes = + { + new() { Count = 2, Color = CubeColor.Green }, + } + } + } + }, + 48 + } + }; + } +} \ No newline at end of file diff --git a/02/CubeConundrum.Tests/GlobalUsings.cs b/02/CubeConundrum.Tests/GlobalUsings.cs new file mode 100644 index 0000000..2d5b473 --- /dev/null +++ b/02/CubeConundrum.Tests/GlobalUsings.cs @@ -0,0 +1,3 @@ +global using FluentAssertions; + +global using Xunit; diff --git a/02/CubeConundrum.Tests/ProgramTests.cs b/02/CubeConundrum.Tests/ProgramTests.cs new file mode 100644 index 0000000..09476f8 --- /dev/null +++ b/02/CubeConundrum.Tests/ProgramTests.cs @@ -0,0 +1,18 @@ +namespace CubeConundrum.Tests; + +public class ProgramTests +{ + [Fact] + public async Task Main_GivenInput_ItShouldReturnExpectedSum() + { + var result = await Program.Main(["INPUT.txt"]); + result.Should().Be(2879); + } + + [Fact] + public async Task Main_GivenInputAndPart2_ItShouldReturnExpectedSum() + { + var result = await Program.Main(["INPUT.txt", "part2"]); + result.Should().Be(65122); + } +} \ No newline at end of file diff --git a/02/CubeConundrum.Tests/PuzzelSolverTests.cs b/02/CubeConundrum.Tests/PuzzelSolverTests.cs new file mode 100644 index 0000000..e8ed0ba --- /dev/null +++ b/02/CubeConundrum.Tests/PuzzelSolverTests.cs @@ -0,0 +1,159 @@ +namespace CubeConundrum.Tests; + +public class PuzzleSolverTests +{ + private readonly PuzzleSolver _sut = new(); + + [Theory, MemberData(nameof(TestData.Results), MemberType = typeof(TestData))] + public void IsResultPossible_GivenAResult_ItShouldReturnExpectedOutcome(Result givenResult, bool expected) + { + var result = _sut.IsResultPossible(givenResult); + result.Should().Be(expected); + } + + [Theory, MemberData(nameof(TestData.Games), MemberType = typeof(TestData))] + public void IsGamePossible_GivenAGame_ItShouldReturnExpectedOutcome(Game givenGame, bool expected) + { + var result = _sut.IsGamePossible(givenGame); + result.Should().Be(expected); + } + + [Fact] + public void SumPossibleGameIds_GivenAGameCollection_ItShouldReturnTheSumOfTheIdsOfAllPossibleGames() + { + var games = TestData.Games.Select(o => (Game)o[0]); + var result = _sut.SumPossibleGameIds(games); + result.Should().Be(1); + } + + public static class TestData + { + public static readonly IEnumerable Games = new List + { + new object[] + { + new Game + { + Id = 1, + Results = + { + new() + { + Cubes = + { + new() { Count = 3, Color = CubeColor.Blue }, + new() { Count = 4, Color = CubeColor.Red } + } + }, + new() + { + Cubes = + { + new() { Count = 1, Color = CubeColor.Red }, + new() { Count = 2, Color = CubeColor.Green }, + new() { Count = 6, Color = CubeColor.Blue } + } + }, + new() + { + Cubes = + { + new() { Count = 2, Color = CubeColor.Green } + } + } + } + }, + true + }, + new object[] + { + new Game + { + Id = 2, + Results = + { + new() + { + Cubes = + { + new() { Count = 3, Color = CubeColor.Blue }, + new() { Count = 4, Color = CubeColor.Red } + } + }, + new() + { + Cubes = + { + new() { Count = 1, Color = CubeColor.Red }, + new() { Count = 2, Color = CubeColor.Green }, + new() { Count = 6, Color = CubeColor.Blue } + } + }, + new() + { + Cubes = + { + new() { Count = 40, Color = CubeColor.Green } + } + }, + } + }, + false + }, + }; + + public static readonly IEnumerable Results = new List + { + new object[] + { + new Result + { + Cubes = + { + new() { Count = 4, Color = CubeColor.Red }, + new() { Count = 1, Color = CubeColor.Green }, + new() { Count = 2, Color = CubeColor.Blue } + } + }, + true + }, + new object[] + { + new Result + { + Cubes = + { + new() { Count = 13, Color = CubeColor.Red }, + new() { Count = 14, Color = CubeColor.Green }, + new() { Count = 14, Color = CubeColor.Blue }, + } + }, + false + }, + new object[] + { + new Result + { + Cubes = + { + new() { Count = 13, Color = CubeColor.Red }, + new() { Count = 5, Color = CubeColor.Green }, + new() { Count = 5, Color = CubeColor.Blue }, + } + }, + false + }, + new object[] + { + new Result + { + Cubes = + { + new() { Count = 40, Color = CubeColor.Red }, + } + }, + false + } + }; + } +} \ No newline at end of file diff --git a/02/CubeConundrum.Tests/PuzzleParserTests.cs b/02/CubeConundrum.Tests/PuzzleParserTests.cs new file mode 100644 index 0000000..23d4066 --- /dev/null +++ b/02/CubeConundrum.Tests/PuzzleParserTests.cs @@ -0,0 +1,93 @@ +namespace CubeConundrum.Tests; + +public class PuzzleParserTests +{ + private readonly PuzzleParser _sut = new(); + + [Theory, MemberData(nameof(TestData.CubeStrings), MemberType = typeof(TestData))] + public void ParseCube_GivenAStringThatRepresentsACube_ItShouldReturnTheEquivalentCubeModel(string input, CubeCollection expected) + { + var result = _sut.ParseCube(input); + result.Should().BeEquivalentTo(expected); + } + + [Theory, MemberData(nameof(TestData.ResultStrings), MemberType = typeof(TestData))] + public void ParseResult_GivenAStringThatRepresentsAResult_ItShouldReturnTheEquivalentResultModel(string input, Result expected) + { + var result = _sut.ParseResult(input); + result.Should().BeEquivalentTo(expected); + } + + [Theory, MemberData(nameof(TestData.GameStrings), MemberType = typeof(TestData))] + public void ParseGame_GivenAStringThatRepresentsAGame_ItShouldReturnTheEquivalentGameModel(string input, Game expected) + { + var result = _sut.ParseGame(input); + result.Should().BeEquivalentTo(expected); + } + + public static class TestData + { + public static readonly IEnumerable CubeStrings = new List + { + new object[] { "4 red", new CubeCollection { Count = 4, Color = CubeColor.Red } }, + new object[] { "1 green", new CubeCollection { Count = 1, Color = CubeColor.Green } }, + new object[] { "2 blue", new CubeCollection { Count = 2, Color = CubeColor.Blue } } + }; + + public static readonly IEnumerable ResultStrings = new List + { + new object[] + { + "4 red, 1 green, 2 blue", + new Result + { + Cubes = + [ + new (){ Count = 4, Color = CubeColor.Red }, + new (){ Count = 1, Color = CubeColor.Green }, + new() { Count = 2, Color = CubeColor.Blue } + ] + } + } + }; + + public static readonly IEnumerable GameStrings = new List + { + new object[] + { + "Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green", + new Game + { + Id = 1, + Results = + [ + new() + { + Cubes = + [ + new() { Count = 3, Color = CubeColor.Blue }, + new() { Count = 4, Color = CubeColor.Red } + ] + }, + new Result + { + Cubes = + [ + new() { Count = 1, Color = CubeColor.Red }, + new() { Count = 2, Color = CubeColor.Green }, + new() { Count = 6, Color = CubeColor.Blue } + ] + }, + new Result + { + Cubes = + [ + new(){ Count = 2, Color = CubeColor.Green } + ] + } + ] + } + } + }; + } +} \ No newline at end of file diff --git a/02/CubeConundrum.Tests/ResultTests.cs b/02/CubeConundrum.Tests/ResultTests.cs new file mode 100644 index 0000000..4aad52b --- /dev/null +++ b/02/CubeConundrum.Tests/ResultTests.cs @@ -0,0 +1,23 @@ +namespace CubeConundrum.Tests; + +public class ResultTests +{ + [Fact] + public void CountProperties_GivenAResult_ItShouldReturnTheCorrectCount() + { + var result = new Result + { + Cubes = + { + new() { Count = 4, Color = CubeColor.Red }, + new() { Count = 1, Color = CubeColor.Green }, + new() { Count = 2, Color = CubeColor.Blue } + } + }; + + result.TotalCubeCount.Should().Be(7); + result.RedCubeCount.Should().Be(4); + result.GreenCubeCount.Should().Be(1); + result.BlueCubeCount.Should().Be(2); + } +} \ No newline at end of file diff --git a/02/CubeConundrum/CubeConundrum.csproj b/02/CubeConundrum/CubeConundrum.csproj new file mode 100644 index 0000000..2150e37 --- /dev/null +++ b/02/CubeConundrum/CubeConundrum.csproj @@ -0,0 +1,10 @@ +ο»Ώ + + + Exe + net8.0 + enable + enable + + + diff --git a/02/CubeConundrum/Program.cs b/02/CubeConundrum/Program.cs new file mode 100644 index 0000000..c9558a4 --- /dev/null +++ b/02/CubeConundrum/Program.cs @@ -0,0 +1,252 @@ +ο»Ώnamespace CubeConundrum; + +public class Program +{ + public async static Task Main(string[] args) + { + if (args.Length is 0) + { + Console.WriteLine("Please provide a path to the input file."); + return -1; + } + + if (File.Exists(args[0]) is false) + { + Console.WriteLine("The provided file does not exist."); + return -2; + } + + var puzzleParser = new PuzzleParser(); + var puzzleSolver = new PuzzleSolver(); + + var input = await File.ReadAllLinesAsync(args[0]); + var games = input.Select(puzzleParser.ParseGame); + + var result = args.Length > 1 && args[1] == "part2" + ? puzzleSolver.SumGameMinimumPowers(games) + : puzzleSolver.SumPossibleGameIds(games); + + Console.WriteLine($"The sum of all possible game ids is {result}."); + + return result; + } +} + +/// +/// Puzzle solver. +/// +public class PuzzleSolver +{ + /// + /// The maximum number of cubes that can be used in a game. + /// + private readonly int _maxCubeCount = 39; + + /// + /// The maximum number of red cubes that can be used in a game. + /// + private readonly int _maxRedCubeCount = 12; + + /// + /// The maximum number of green cubes that can be used in a game. + /// + private readonly int _maxGreenCubeCount = 13; + + /// + /// The maximum number of blue cubes that can be used in a game. + /// + private readonly int _maxBlueCubeCount = 14; + + /// + /// Determines whether a result is possible. + /// + /// The result to check. + /// True if the result is possible, otherwise false. + public bool IsResultPossible(Result result) => result.TotalCubeCount <= _maxCubeCount + && result.RedCubeCount <= _maxRedCubeCount + && result.GreenCubeCount <= _maxGreenCubeCount + && result.BlueCubeCount <= _maxBlueCubeCount; + + /// + /// Determines whether a game is possible. + /// + /// The game to check. + /// True if the game is possible, otherwise false. + public bool IsGamePossible(Game game) => game.Results.All(IsResultPossible); + + /// + /// Sums all possible game ids. + /// + /// The games to sum. + /// The sum of all possible game ids. + public int SumPossibleGameIds(IEnumerable games) => games + .Where(IsGamePossible) + .Sum(g => g.Id); + + /// + /// Sums the minimum powers of all games. + /// + /// The games to sum. + /// The sum of the minimum powers of all games. + public int SumGameMinimumPowers(IEnumerable games) => games + .Select(g => g.PowerOfMinimumCubesNeeded) + .Sum(); +} + +/// +/// Puzzle parser responsible for parsing puzzle input. +/// +public class PuzzleParser +{ + /// + /// Parses a cube from a string. + /// + /// The string to parse. + /// An instance of . + public CubeCollection ParseCube(string cubeString) + { + var parts = cubeString.Split(' '); + var count = int.Parse(parts[0]); + var color = Enum.Parse(parts[1], true); + + return new() + { + Count = count, + Color = color + }; + } + + /// + /// Parses a result from a string. + /// + /// The string to parse. + /// An instance of . + public Result ParseResult(string resultString) + { + var cubes = resultString + .Split(',') + .Select(s => s.Trim()) + .Select(ParseCube) + .ToList(); + + return new() + { + Cubes = cubes + }; + } + + /// + /// Parses a game from a string. + /// + /// The string to parse. + /// An instance of . + public Game ParseGame(string gameString) + { + var parts = gameString.Split(':'); + var gameId = int.Parse(parts[0].Split(' ')[1]); + var results = parts[1] + .Split(';') + .Select(s => s.Trim()) + .Select(ParseResult) + .ToList(); + + return new() + { + Id = gameId, + Results = results + }; + } +} + +/// +/// Represents a game. +/// +public class Game +{ + /// + /// The id of the game. + /// + public int Id { get; set; } + + /// + /// The results of the game. + /// + public List Results { get; set; } = []; + + private int MinimumRedCubesNeeded => Results.Max(r => r.RedCubeCount); + private int MinimumGreenCubesNeeded => Results.Max(r => r.GreenCubeCount); + private int MinimumBlueCubesNeeded => Results.Max(r => r.BlueCubeCount); + + /// + /// The power of the minimum number of each cube type needed to play the game. + /// + public int PowerOfMinimumCubesNeeded => MinimumRedCubesNeeded * MinimumGreenCubesNeeded * MinimumBlueCubesNeeded; +} + +/// +/// Represents a result. +/// +public class Result +{ + /// + /// The cubes in the result. + /// + public List Cubes { get; set; } = []; + + /// + /// The total number of cubes in the result. + /// + public int TotalCubeCount => Cubes.Sum(c => c.Count); + + /// + /// The number of red cubes in the result. + /// + public int RedCubeCount => Cubes.Where(c => c.Color == CubeColor.Red).Sum(c => c.Count); + + /// + /// The number of green cubes in the result. + /// + public int GreenCubeCount => Cubes.Where(c => c.Color == CubeColor.Green).Sum(c => c.Count); + + /// + /// The number of blue cubes in the result. + /// + public int BlueCubeCount => Cubes.Where(c => c.Color == CubeColor.Blue).Sum(c => c.Count); +} + +/// +/// Represents cubes of a given color. +/// +public class CubeCollection +{ + /// + /// The number of cubes. + /// + public int Count { get; set; } + + /// + /// The color of the cubes. + /// + public CubeColor Color { get; set; } +} + +/// +/// Represents a cube color. +/// +public enum CubeColor +{ + /// + /// The red cube color. + /// + Red, + + /// + /// The green cube color. + /// + Green, + + /// + /// The blue cube color. + /// + Blue +} \ No newline at end of file diff --git a/02/SCRATCH.md b/02/SCRATCH.md new file mode 100644 index 0000000..8a7389e --- /dev/null +++ b/02/SCRATCH.md @@ -0,0 +1,75 @@ +# Notes + +## Constraints + +### Total number of cubes: 39 + +The elf can't show me more than 39 dice at a time. + +### Total number of each cube type: 12 red, 13 green, 14 blue + +The elf can't show me more than 12 red cubes at a time. +The elf can't show me more than 13 green cubes at a time. +The elf can't show me more than 14 blue cubes at a time. + +### Types of cubes: red, green, blue + +The elf can only show me red, green, or blue cubes. +The elf though can show me any combination of red, green, or blue cubes including none of a particular color or all of a particular color. + +## Structure + +Each game is a line of text. +Each game is delimited by "Game N: " where N is the game id. +Each game consists of a semi-colon delimited list of sets of cubes. +Each set of cubes is a comma delimited list of the number of cubes and the color of the cubes. + +```text +Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green +``` + +❓ How would I model this? + +```csharp +class Game +{ + public int Id { get; set; } + public List Results { get; set; } +} + +class Results +{ + public List Cubes { get; set; } +} + +class Cube +{ + public int Count { get; set; } + public CubeColor Color { get; set; } +} + +enum CubeColor +{ + Red, + Green, + Blue +} +``` + +## Problems + +### Problem 1 + +πŸ”΄ Need to determine which results are possible given the known # of cubes and known # of cubes for each color. + +### Problem 2 + +πŸ”΄ Need to determine if all the results for a given game are possible + +### Problem 3 + +πŸ”΄ Need to determine the sum of the game ids for all the possible games + +### Problem 4 + +πŸ”΄ Need to determine the sum of the game ids for all the possible games diff --git a/AdventOfCode2023.sln b/AdventOfCode2023.sln index f97fe91..f685422 100644 --- a/AdventOfCode2023.sln +++ b/AdventOfCode2023.sln @@ -9,6 +9,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Trebuchet", "01\Trebuchet\T EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Trebuchet.Tests", "01\Trebuchet.Tests\Trebuchet.Tests.csproj", "{4A5226E4-5B90-4D6C-9224-EBE3F04470ED}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "02", "02", "{4FD81B09-302F-4C76-BECB-B4559DF3984F}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CubeConundrum", "02\CubeConundrum\CubeConundrum.csproj", "{95D6522F-4893-4A66-9B39-7F0268E290B8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CubeConundrum.Tests", "02\CubeConundrum.Tests\CubeConundrum.Tests.csproj", "{4825CE42-4717-4DA6-944F-9BD9A825932B}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -26,9 +32,19 @@ Global {4A5226E4-5B90-4D6C-9224-EBE3F04470ED}.Debug|Any CPU.Build.0 = Debug|Any CPU {4A5226E4-5B90-4D6C-9224-EBE3F04470ED}.Release|Any CPU.ActiveCfg = Release|Any CPU {4A5226E4-5B90-4D6C-9224-EBE3F04470ED}.Release|Any CPU.Build.0 = Release|Any CPU + {95D6522F-4893-4A66-9B39-7F0268E290B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {95D6522F-4893-4A66-9B39-7F0268E290B8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {95D6522F-4893-4A66-9B39-7F0268E290B8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {95D6522F-4893-4A66-9B39-7F0268E290B8}.Release|Any CPU.Build.0 = Release|Any CPU + {4825CE42-4717-4DA6-944F-9BD9A825932B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4825CE42-4717-4DA6-944F-9BD9A825932B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4825CE42-4717-4DA6-944F-9BD9A825932B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4825CE42-4717-4DA6-944F-9BD9A825932B}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(NestedProjects) = preSolution {3F8EAC09-4BC7-43AA-B72B-48DDD2710F6D} = {8C29858C-623A-461A-BF0B-254E151CD9C2} {4A5226E4-5B90-4D6C-9224-EBE3F04470ED} = {8C29858C-623A-461A-BF0B-254E151CD9C2} + {95D6522F-4893-4A66-9B39-7F0268E290B8} = {4FD81B09-302F-4C76-BECB-B4559DF3984F} + {4825CE42-4717-4DA6-944F-9BD9A825932B} = {4FD81B09-302F-4C76-BECB-B4559DF3984F} EndGlobalSection EndGlobal diff --git a/README.md b/README.md index d66662c..c5f76b3 100644 --- a/README.md +++ b/README.md @@ -4,30 +4,30 @@ This repository contains my solutions for the [Advent of Code 2023](https://adve ## Challenges -| Day | Problem | Solution | Status | Notes | -| --- | -------------------------- | :-----------------------------------: | :----------------------: | ------------------------------------------------------------------- | -| 01 | [Problem](./01/PROBLEM.md) | [Solution](./01/Trebuchet/Program.cs) | :white_check_mark: | The trickiest part here was accounting for overlapping digit words. | -| 02 | [Problem](./02/PROBLEM.md) | [Solution](./02/) | :hourglass_flowing_sand: | -| 03 | [Problem](./03/PROBLEM.md) | [Solution](./03/) | :hourglass_flowing_sand: | -| 04 | [Problem](./04/PROBLEM.md) | [Solution](./04/) | :hourglass_flowing_sand: | -| 05 | [Problem](./05/PROBLEM.md) | [Solution](./05/) | :hourglass_flowing_sand: | -| 06 | [Problem](./06/PROBLEM.md) | [Solution](./06/) | :hourglass_flowing_sand: | -| 07 | [Problem](./07/PROBLEM.md) | [Solution](./07/) | :hourglass_flowing_sand: | -| 08 | [Problem](./08/PROBLEM.md) | [Solution](./08/) | :hourglass_flowing_sand: | -| 09 | [Problem](./09/PROBLEM.md) | [Solution](./09/) | :hourglass_flowing_sand: | -| 10 | [Problem](./10/PROBLEM.md) | [Solution](./10/) | :hourglass_flowing_sand: | -| 11 | [Problem](./11/PROBLEM.md) | [Solution](./11/) | :hourglass_flowing_sand: | -| 12 | [Problem](./12/PROBLEM.md) | [Solution](./12/) | :hourglass_flowing_sand: | -| 13 | [Problem](./13/PROBLEM.md) | [Solution](./13/) | :hourglass_flowing_sand: | -| 14 | [Problem](./14/PROBLEM.md) | [Solution](./14/) | :hourglass_flowing_sand: | -| 15 | [Problem](./15/PROBLEM.md) | [Solution](./15/) | :hourglass_flowing_sand: | -| 16 | [Problem](./16/PROBLEM.md) | [Solution](./16/) | :hourglass_flowing_sand: | -| 17 | [Problem](./17/PROBLEM.md) | [Solution](./17/) | :hourglass_flowing_sand: | -| 18 | [Problem](./18/PROBLEM.md) | [Solution](./18/) | :hourglass_flowing_sand: | -| 19 | [Problem](./19/PROBLEM.md) | [Solution](./19/) | :hourglass_flowing_sand: | -| 20 | [Problem](./20/PROBLEM.md) | [Solution](./20/) | :hourglass_flowing_sand: | -| 21 | [Problem](./21/PROBLEM.md) | [Solution](./21/) | :hourglass_flowing_sand: | -| 22 | [Problem](./22/PROBLEM.md) | [Solution](./22/) | :hourglass_flowing_sand: | -| 23 | [Problem](./23/PROBLEM.md) | [Solution](./23/) | :hourglass_flowing_sand: | -| 24 | [Problem](./24/PROBLEM.md) | [Solution](./24/) | :hourglass_flowing_sand: | -| 25 | [Problem](./25/PROBLEM.md) | [Solution](./25/) | :hourglass_flowing_sand: | +| Day | Problem | Solution | Status | Notes | +| --- | -------------------------- | :---------------------------------------: | :----: | ------------------------------------------------------------------- | +| 01 | [Problem](./01/PROBLEM.md) | [Solution](./01/Trebuchet/Program.cs) | βœ… | The trickiest part here was accounting for overlapping digit words. | +| 02 | [Problem](./02/PROBLEM.md) | [Solution](./02/CubeConundrum/Program.cs) | βœ… | The key to me here was to parse the input into a useful model. | +| 03 | [Problem](./03/PROBLEM.md) | [Solution](./03/) | βŒ› | +| 04 | [Problem](./04/PROBLEM.md) | [Solution](./04/) | βŒ› | +| 05 | [Problem](./05/PROBLEM.md) | [Solution](./05/) | βŒ› | +| 06 | [Problem](./06/PROBLEM.md) | [Solution](./06/) | βŒ› | +| 07 | [Problem](./07/PROBLEM.md) | [Solution](./07/) | βŒ› | +| 08 | [Problem](./08/PROBLEM.md) | [Solution](./08/) | βŒ› | +| 09 | [Problem](./09/PROBLEM.md) | [Solution](./09/) | βŒ› | +| 10 | [Problem](./10/PROBLEM.md) | [Solution](./10/) | βŒ› | +| 11 | [Problem](./11/PROBLEM.md) | [Solution](./11/) | βŒ› | +| 12 | [Problem](./12/PROBLEM.md) | [Solution](./12/) | βŒ› | +| 13 | [Problem](./13/PROBLEM.md) | [Solution](./13/) | βŒ› | +| 14 | [Problem](./14/PROBLEM.md) | [Solution](./14/) | βŒ› | +| 15 | [Problem](./15/PROBLEM.md) | [Solution](./15/) | βŒ› | +| 16 | [Problem](./16/PROBLEM.md) | [Solution](./16/) | βŒ› | +| 17 | [Problem](./17/PROBLEM.md) | [Solution](./17/) | βŒ› | +| 18 | [Problem](./18/PROBLEM.md) | [Solution](./18/) | βŒ› | +| 19 | [Problem](./19/PROBLEM.md) | [Solution](./19/) | βŒ› | +| 20 | [Problem](./20/PROBLEM.md) | [Solution](./20/) | βŒ› | +| 21 | [Problem](./21/PROBLEM.md) | [Solution](./21/) | βŒ› | +| 22 | [Problem](./22/PROBLEM.md) | [Solution](./22/) | βŒ› | +| 23 | [Problem](./23/PROBLEM.md) | [Solution](./23/) | βŒ› | +| 24 | [Problem](./24/PROBLEM.md) | [Solution](./24/) | βŒ› | +| 25 | [Problem](./25/PROBLEM.md) | [Solution](./25/) | βŒ› |