Add Day 05 solution

AoC_2025.Runner/Program.cs

@@ -27,3 +27,9 @@ string day04Path =  @$"{rootPath}\AoC-PuzzleInputs\2025\Prod\day04.txt";
 Console.WriteLine(day04.SolvePart1(day04Path));
 Console.WriteLine(day04.SolvePart2(day04Path));
 Console.WriteLine();
+
+var day05 = new Day05();
+string day05Path =  @$"{rootPath}\AoC-PuzzleInputs\2025\Prod\day05.txt";
+Console.WriteLine(day05.SolvePart1(day05Path));
+Console.WriteLine(day05.SolvePart2(day05Path));
+Console.WriteLine();

AoC_2025.Tests/Day05Test.cs

@@ -0,0 +1,47 @@
+using AdvenOfCode.Contracts;
+
+namespace AoC_2025.Tests;
+
+public class Day05Test
+{
+    private readonly IPuzzleSolver<long> _sut;
+    private static readonly string rootPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+    private readonly string TestInputPath = @$"{rootPath}\AoC-PuzzleInputs\2025\Test\day05.txt";
+    private readonly string ProdInputPath = @$"{rootPath}\AoC-PuzzleInputs\2025\Prod\day05.txt";
+    
+    public Day05Test()
+    {
+        _sut = new Day05();
+    }
+    [Fact]
+    public void Part01_Test_equals_3()
+    {
+        var actual = _sut.SolvePart1(TestInputPath);
+        
+        Assert.Equal(3, actual);
+    }
+    
+    [Fact]
+    public void Part01_Prod_equals_635()
+    {
+        var actual = _sut.SolvePart1(ProdInputPath);
+        
+        Assert.Equal(635, actual);
+    }
+    
+    [Fact]
+    public void Part02_Test_equals_14()
+    {
+        var actual = _sut.SolvePart2(TestInputPath);
+        
+        Assert.Equal(14, actual);
+    }
+    
+    [Fact]
+    public void Part02_Prod_equals_369761800782619()
+    {
+        var actual = _sut.SolvePart2(ProdInputPath);
+        
+        Assert.Equal(369761800782619, actual);
+    }
+}

AoC_2025/Day04.cs

@@ -95,8 +95,8 @@ public class Day04 : IPuzzleSolver<long>
         int lessThan)
     {
         var coordinatesWithLess = coordinatesWithNeighbours
-            .Where(entry => entry.neighbours.Count() < lessThan)
-            .Select(entry => entry.coordinate);
+            .Where(roll => roll.neighbours.Length < lessThan)
+            .Select(roll => roll.coordinate);
         return coordinatesWithLess;
     }
 }

AoC_2025/Day05.cs

@@ -0,0 +1,91 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using AdvenOfCode.Contracts;
+using Range = (long from, long to);
+
+namespace AoC_2025;
+
+public class Day05 : IPuzzleSolver<long>
+{
+    private (List<string> freshIdRanges, List<string> ids) ParsePuzzleInput(string path)
+    {
+        var puzzleInput = File.ReadAllLines(path)
+            .Select(line => line.Trim())
+            .ToList();
+        var middle = puzzleInput.IndexOf("");
+        var freshIdRanges = puzzleInput[..middle];
+        var ids = puzzleInput[(middle + 1)..];
+        return (freshIdRanges, ids);
+    }
+
+    public long SolvePart1(string pathToPuzzleInput)
+    {
+        var database = ParsePuzzleInput(pathToPuzzleInput);
+        var freshIdRanges = ParseRanges(database.freshIdRanges);
+        var ids = ParseIds(database.ids);
+        var freshIds = FilterFreshIds(ids, freshIdRanges);
+        return freshIds.Count();
+    }
+    
+    public long SolvePart2(string pathToPuzzleInput)
+    {
+        var database = ParsePuzzleInput(pathToPuzzleInput);
+        var freshIdRanges = ParseRanges(database.freshIdRanges);
+        var sumIds = SumIdsInRanges(freshIdRanges);
+        return sumIds;
+    }
+
+    private IEnumerable<long> FilterFreshIds(IEnumerable<long> ids, Range[] freshIdRanges)
+    {
+        var freshIds = ids.Where(id => IsIdInRanges(id, freshIdRanges));
+        return freshIds;
+    }
+
+    private IEnumerable<long> ParseIds(List<string> ids)
+    {
+        var parsedIds = ids.Select(id => long.Parse(id));
+        return parsedIds;
+    }
+
+    private Range[] ParseRanges(IEnumerable<string> ranges)
+    {
+        return ranges.Select(range =>
+        {
+            var split = range.Split('-', StringSplitOptions.RemoveEmptyEntries);
+            return (long.Parse(split[0]), long.Parse(split[1]));
+        })
+        .OrderBy(range => range.Item1)
+        .ThenBy(range => range.Item2)
+        .ToArray();
+    }
+
+    private bool IsIdInRanges(long id, IEnumerable<Range> ranges)
+    {
+        return ranges.Any(range => IsIdInRange(id, range));
+    }
+    
+    private bool IsIdInRange(long id, Range range)
+    {
+        return range.from <= id && range.to >= id;
+    }
+    
+    private long CountIdsInRange(long from, long to)
+    {
+        return to - from + 1;
+    }
+
+    private long SumIdsInRanges(IEnumerable<Range> ranges)
+    {
+        var sumFreshIds = 0L;
+        var highestSeenId = -1L;
+        foreach (var range in ranges)
+        {
+            var lowestNewId = Math.Max(highestSeenId + 1, range.from);
+            highestSeenId = Math.Max(highestSeenId, range.to);
+            sumFreshIds += Math.Max(0, highestSeenId - lowestNewId + 1);
+        }
+
+        return sumFreshIds;
+    }
+}