Merge pull request #34 from MartinZikmund/feature/aoc2025-day8

Author: MartinZikmund

src/AdventOfCode.Puzzles/2025/08/Part1/AoC2025Day8Part1.cs

@@ -0,0 +1,73 @@
+namespace AdventOfCode.Puzzles._2025._08.Part1;
+
+public class AoC2025Day8Part1 : IPuzzleSolution
+{
+    public async Task<string> SolveAsync(StreamReader inputReader)
+    {
+        var lines = await inputReader.ReadAllLinesAsync();
+        int targetConnections = lines.Count < 50 ? 10 : 1000;
+
+        var boxes = new List<Point3d>();
+        foreach (var line in lines)
+        {
+            var parts = line.Split(',', StringSplitOptions.TrimEntries);
+            boxes.Add(new Point3d
+            {
+                X = int.Parse(parts[0]),
+                Y = int.Parse(parts[1]),
+                Z = int.Parse(parts[2]),
+            });
+        }
+
+        var distinctDistances = new List<(Point3d box1, Point3d box2, double distance)>();
+
+        var distances = new Dictionary<(Point3d, Point3d), double>();
+        for (int box1 = 0; box1 < boxes.Count; box1++)
+        {
+            for (int box2 = box1 + 1; box2 < boxes.Count; box2++)
+            {
+                var distance = boxes[box1].Distance(boxes[box2]);
+                distances[(boxes[box1], boxes[box2])] = distance;
+                distances[(boxes[box2], boxes[box1])] = distance;
+                distinctDistances.Add((boxes[box1], boxes[box2], distance));
+            }
+        }
+
+        distinctDistances = distinctDistances
+            .OrderBy(t => t.distance)
+            .ToList();
+
+        var circuits = new Dictionary<Point3d, List<Point3d>>();
+        foreach (var box in boxes)
+        {
+            var circuit = new List<Point3d> { box };
+            circuits.Add(box, circuit);
+        }
+
+        for (var distanceId = 0; distanceId < targetConnections; distanceId++)
+        {
+            var (box1, box2, distance) = distinctDistances[distanceId];
+
+            var circuit1 = circuits[box1];
+            var circuit2 = circuits[box2];
+            if (circuit1 != circuit2)
+            {
+                // Merge circuits
+                circuit1.AddRange(circuit2);
+                foreach (var box in circuit2)
+                {
+                    circuits[box] = circuit1;
+                }
+            }
+        }
+
+        var largestCircuits = circuits
+            .Select(c => c.Value)
+            .Distinct()
+            .OrderByDescending(c => c.Count)
+            .Select(c => c.Count)
+            .Take(3)
+            .ToArray();
+        return (largestCircuits[0] * largestCircuits[1] * largestCircuits[2]).ToString();
+    }
+}

src/AdventOfCode.Puzzles/2025/08/Part2/AoC2025Day8Part2.cs

@@ -0,0 +1,69 @@
+namespace AdventOfCode.Puzzles._2025._08.Part2;
+
+public class AoC2025Day8Part2 : IPuzzleSolution
+{
+    public async Task<string> SolveAsync(StreamReader inputReader)
+    {
+        var lines = await inputReader.ReadAllLinesAsync();
+        int targetConnections = lines.Count < 50 ? 10 : 1000;
+
+        var boxes = new List<Point3d>();
+        foreach (var line in lines)
+        {
+            var parts = line.Split(',', StringSplitOptions.TrimEntries);
+            boxes.Add(new Point3d
+            {
+                X = int.Parse(parts[0]),
+                Y = int.Parse(parts[1]),
+                Z = int.Parse(parts[2]),
+            });
+        }
+
+        var distinctDistances = new List<(Point3d box1, Point3d box2, double distance)>();
+
+        var distances = new Dictionary<(Point3d, Point3d), double>();
+        for (int box1 = 0; box1 < boxes.Count; box1++)
+        {
+            for (int box2 = box1 + 1; box2 < boxes.Count; box2++)
+            {
+                var distance = boxes[box1].Distance(boxes[box2]);
+                distances[(boxes[box1], boxes[box2])] = distance;
+                distances[(boxes[box2], boxes[box1])] = distance;
+                distinctDistances.Add((boxes[box1], boxes[box2], distance));
+            }
+        }
+
+        distinctDistances = distinctDistances
+            .OrderBy(t => t.distance)
+            .ToList();
+
+        var circuits = new Dictionary<Point3d, List<Point3d>>();
+        foreach (var box in boxes)
+        {
+            var circuit = new List<Point3d> { box };
+            circuits.Add(box, circuit);
+        }
+
+        for (var distanceId = 0; ; distanceId++)
+        {
+            var (box1, box2, distance) = distinctDistances[distanceId];
+
+            var circuit1 = circuits[box1];
+            var circuit2 = circuits[box2];
+            if (circuit1 != circuit2)
+            {
+                // Merge circuits
+                circuit1.AddRange(circuit2);
+                foreach (var box in circuit2)
+                {
+                    circuits[box] = circuit1;
+                }
+
+                if (circuit1.Count == boxes.Count)
+                {
+                    return (box1.X * box2.X).ToString();
+                }
+            }
+        }
+    }
+}

src/AdventOfCode.Puzzles/2025/08/TestData.txt

@@ -0,0 +1,20 @@
+162,817,812
+57,618,57
+906,360,560
+592,479,940
+352,342,300
+466,668,158
+542,29,236
+431,825,988
+739,650,466
+52,470,668
+216,146,977
+819,987,18
+117,168,530
+805,96,715
+346,949,466
+970,615,88
+941,993,340
+862,61,35
+984,92,344
+425,690,689

src/AdventOfCode.Puzzles/Tools/Point3d.cs

@@ -11,4 +11,6 @@ public record struct Point3d(int X, int Y, int Z)
     public static implicit operator Point3d((int X, int Y, int Z) tuple) => new Point3d(tuple.X, tuple.Y, tuple.Z);
 
     public int ManhattanDistance(Point3d b) => Math.Abs(X - b.X) + Math.Abs(Y - b.Y) + Math.Abs(Z - b.Z);
+
+    public double Distance(Point3d b) => Math.Sqrt(Math.Pow(X - b.X, 2) + Math.Pow(Y - b.Y, 2) + Math.Pow(Z - b.Z, 2));
 }