day 16

encse · encse · commit c0f527a73c97 · 2021-12-16T08:35:50.000+01:00
diff --git a/2021/Day16/Solution.cs b/2021/Day16/Solution.cs
@@ -7,49 +7,29 @@ namespace AdventOfCode.Y2021.Day16;
 [ProblemName("Packet Decoder")]
 class Solution : Solver {
 
-    public object PartOne(string input) {
-
-        var packet = Parse(GetInput(input));
-        int rec(Packet p)  {
-            if (p is Literal) {
-                return p.version;
-            } else if (p is Operator) {
-                return p.version + (p as Operator).packets.Select(rec).Sum();
-            } else {
-                throw new Exception();
-            }
-        }
-        return rec(packet);
+    public object PartOne(string input) =>
+        GetTotalVersion(GetPacket(GetInput(input)));
+
+    public object PartTwo(string input) =>
+        Evaluate(GetPacket(GetInput(input)));
+
+    long Evaluate(Packet packet) {
+        var parts = packet.packets.Select(Evaluate).ToArray();
+        return packet.type switch {
+            0 => parts.Sum(),
+            1 => parts.Aggregate(1L, (acc, x) => acc * x),
+            2 => parts.Min(),
+            3 => parts.Max(),
+            4 => packet.payload,
+            5 => parts[0] > parts[1] ? 1 : 0,
+            6 => parts[0] < parts[1] ? 1 : 0,
+            7 => parts[0] == parts[1] ? 1 : 0,
+            _ => throw new Exception()
+        };
     }
 
-
-    public object PartTwo(string input) {
-        var packet = Parse(GetInput(input));
-        long rec(Packet p) {
-            if (p is Literal) {
-                return (p as Literal).value;
-            } else if (p is Operator) {
-                var op = p as Operator;
-                var parts = op.packets.Select(rec).ToArray();
-                switch (op.type) {
-                    case 0:
-                        return parts.Sum();
-                    case 1:
-                        return parts.Aggregate(1L, (acc, x) => acc * x);
-                    case 2: return parts.Min();
-                    case 3: return parts.Max();
-                    case 5: return parts[0] > parts[1] ? 1 : 0;
-                    case 6: return parts[0] < parts[1] ? 1 : 0;
-                    case 7: return parts[0] == parts[1] ? 1 : 0;
-                    default: throw new Exception();
-                }
-            } else {
-                throw new Exception();
-            }
-        }
-        return rec(packet);
-
-    }
+    int GetTotalVersion(Packet packet) =>
+        packet.version + packet.packets.Select(GetTotalVersion).Sum();
 
     Input GetInput(string input) => new Input(
         (from ch in input
@@ -58,74 +38,62 @@ from bit in bits
          select bit - '0').ToList()
     );
 
-    Packet Parse(Input input) {
+    Packet GetPacket(Input input) {
         var version = input.ReadInt(3);
         var type = input.ReadInt(3);
-        return
-            type == 0x4 ?
-                ParseLiteral(version, type, input) :
-                ParseOperator(version, type, input);
-    }
-
-    Packet ParseLiteral(int version, int type, Input input) {
-        var value = 0L;
-        while (true) {
-            var last = input.ReadInt(1) == 0;
-            value <<= 4;
-            value += input.ReadInt(4);
-            if (last) {
-                break;
-            }
-        }
-        return new Literal(version, type, value);
-    }
-
-    Packet ParseOperator(int version, int type, Input input) {
         var packets = new List<Packet>();
-        if (input.ReadInt(1) == 0) {
+        var payload = 0L;
+
+        if (type == 0x4) {
+            while (true) {
+                var isLast = input.ReadInt(1) == 0;
+                payload = payload * 16 + input.ReadInt(4);
+                if (isLast) {
+                    break;
+                }
+            }
+        } else if (input.ReadInt(1) == 0) {
             var length = input.ReadInt(15);
-            var subInput = input.ReadInput(length);
-            while (subInput.Any()) {
-                packets.Add(Parse(subInput));
+            var subPackages = input.ReadInput(length);
+            while (subPackages.Any()) {
+                packets.Add(GetPacket(subPackages));
             }
-
         } else {
-            var length = input.ReadInt(11);
-            packets = Enumerable.Range(0, length).Select(x => Parse(input)).ToList();
+            var packetCount = input.ReadInt(11);
+            packets.AddRange(from _ in Enumerable.Range(0, packetCount) select GetPacket(input));
         }
 
-        return new Operator(version, type, packets.ToArray());
+        return new Packet(version, type, payload, packets.ToArray());
     }
-
 }
 
 class Input {
-    private List<int> numbers;
+    private List<int> bits;
     private int ptr;
+
     public Input(List<int> numbers) {
-        this.numbers = numbers;
+        this.bits = numbers;
     }
 
     public bool Any() {
-        return ptr < numbers.Count();
+        return ptr < bits.Count();
     }
+
     public Input ReadInput(int n) {
-        var sub = numbers.GetRange(ptr, n).ToList();
+        var sub = bits.GetRange(ptr, n).ToList();
         var res = new Input(sub);
         ptr += n;
         return res;
     }
 
     public int ReadInt(int n) {
         var res = 0;
-        foreach (var bit in numbers.GetRange(ptr, n)) {
+        foreach (var bit in bits.GetRange(ptr, n)) {
             res = res * 2 + bit;
         }
         ptr += n;
         return res;
     }
 }
 
-record Packet(int version, int type);
-record Literal(int version, int type, long value) : Packet(version, type);
-record Operator(int version, int type, Packet[] packets) : Packet(version, type);
+record Packet(int version, int type, long payload, Packet[] packets);
