Merge pull request #25 from MartinZikmund/feature/aoc2024-day24

AoC 2024 Day 24 Solutions

Author: MartinZikmund

src/AdventOfCode.Puzzles/2024/24/Connection.cs

@@ -0,0 +1,67 @@
+namespace AdventOfCode.Puzzles._2024._24;
+
+public class Connection
+{
+    private Connection(string input1, string input2, string output, Operation operation)
+    {
+        Input1 = input1;
+        Input2 = input2;
+        Output = output;
+        Operation = operation;
+    }
+
+    public string Input1 { get; }
+
+    public string Input2 { get; }
+
+    public string Output { get; private set; }
+
+    public Operation Operation { get; }
+
+    public bool CanEvaluate(Dictionary<string, int> knownGates) =>
+        knownGates.ContainsKey(Input1) && knownGates.ContainsKey(Input2);
+
+    public void Evaluate(Dictionary<string, int> knownGates)
+    {
+        if (!CanEvaluate(knownGates))
+        {
+            throw new InvalidOperationException("Gate inputs not known.");
+        }
+
+        var input1 = knownGates[Input1];
+        var input2 = knownGates[Input2];
+        var output = Operation switch
+        {
+            Operation.And => input1 & input2,
+            Operation.Or => input1 | input2,
+            Operation.Xor => input1 ^ input2,
+            _ => throw new InvalidOperationException()
+        };
+
+        knownGates[Output] = output;
+    }
+
+    public static Connection ParseConnection(string line)
+    {
+        var parts = line.Split(" ");
+        var input1 = parts[0];
+        var input2 = parts[2];
+        var output = parts[4];
+        var operation = parts[1] switch
+        {
+            "AND" => Operation.And,
+            "OR" => Operation.Or,
+            "XOR" => Operation.Xor,
+            _ => throw new InvalidOperationException()
+        };
+
+        return new Connection(input1, input2, output, operation);
+    }
+
+    public void SwapOutput(Connection otherConnection)
+    {
+        var temp = Output;
+        Output = otherConnection.Output;
+        otherConnection.Output = temp;
+    }
+}

src/AdventOfCode.Puzzles/2024/24/Operation.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AdventOfCode.Puzzles._2024._24;
+
+public enum Operation
+{
+    And,
+    Or,
+    Xor
+}

src/AdventOfCode.Puzzles/2024/24/Part1/Part1.cs

@@ -0,0 +1,63 @@
+namespace AdventOfCode.Puzzles._2024._24.Part1;
+
+public partial class Part1 : IPuzzleSolution
+{
+    private List<Connection> _connections = new();
+    private HashSet<string> _gates = new();
+
+    public async Task<string> SolveAsync(StreamReader inputReader)
+    {
+        var inputValues = new Dictionary<string, int>();
+        while (await inputReader.ReadLineAsync() is { } line && !string.IsNullOrEmpty(line))
+        {
+            var parts = line.Split(": ");
+            var gateName = parts[0];
+            var value = int.Parse(parts[1]);
+            inputValues.Add(gateName, value);
+            _gates.Add(gateName);
+        }
+
+        // Read connections
+        while (await inputReader.ReadLineAsync() is { } line)
+        {
+            var connection = Connection.ParseConnection(line);
+
+            _gates.Add(connection.Input1);
+            _gates.Add(connection.Input2);
+            _gates.Add(connection.Output);
+            _connections.Add(connection);
+        }
+
+        var zGates = _gates.Where(g => g.StartsWith("z")).OrderBy(g => g).Reverse().ToList();
+
+        Evaluate(inputValues);
+
+        var result = GetZValue(zGates, inputValues);
+        return result.ToString();
+    }
+
+    private long GetZValue(List<string> zGates, Dictionary<string, int> values)
+    {
+        var binary = string.Join("", zGates.Select(g => values[g]));
+        return Convert.ToInt64(binary, 2);
+    }
+
+    private void Evaluate(Dictionary<string, int> values)
+    {
+        var gatesToProcess = new Queue<string>();
+        var processedConnections = new HashSet<Connection>();
+        while (values.Count < _gates.Count)
+        {
+            foreach (var connection in _connections)
+            {
+                if (!processedConnections.Contains(connection) &&
+                    connection.CanEvaluate(values))
+                {
+                    connection.Evaluate(values);
+                    processedConnections.Add(connection);
+                }
+            }
+        }
+
+    }
+}