24

encse · encse · commit 35fd8834eb82 · 2020-12-24T08:17:03.000+01:00
diff --git a/2020/Day24/Solution.cs b/2020/Day24/Solution.cs
@@ -1,79 +1,72 @@
-using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
-using System.Text.RegularExpressions;
-using System.Text;
 
 namespace AdventOfCode.Y2020.Day24 {
+    record Tile(int x, int y, int z);
 
     [ProblemName("Lobby Layout")]
     class Solution : Solver {
 
-        public object PartOne(string input) {
-            var tiles = Parse(input);
-            return tiles.Values.Sum();
-        }
+        public object PartOne(string input) => ParseBlackTiles(input).Count();
 
-        public object PartTwo(string input) {
-            var tiles = Parse(input);
-            for (var i = 0; i < 100; i++) {
-                tiles = Flip(tiles);
-            }
-            return tiles.Values.Sum();
-        }
+        public object PartTwo(string input) =>
+            Enumerable.Range(0, 100)
+                .Aggregate(ParseBlackTiles(input), (blackTiles, _) => Flip(blackTiles))
+                .Count();
 
-        Dictionary<(int, int, int), int> Flip(Dictionary<(int, int, int), int> tiles) {
-            var res =  new Dictionary<(int, int, int), int>();
-            var neighbours = new []{(0,1,-1), (1,0,-1), (1,-1,0), (0,-1,1),(-1,0,1),(-1,1,0)};
+        Dictionary<string, (int x, int y, int z)> HexDirections = new Dictionary<string, (int x, int y, int z)>{
+            {"x", (0, 0, 0)},
+            {"e", (0, 1, -1)},
+            {"se", (1, 0, -1)},
+            {"sw", (1, -1, 0)},
+            {"w", (0, -1, 1)},
+            {"nw", (-1, 0, 1)},
+            {"ne", (-1, 1, 0)}
+        };
 
-            var tilesX = new HashSet<(int,int,int)>();
-            foreach(var tile in tiles.Keys){
-                tilesX.Add(tile);
-                foreach(var neighbour in  from dir in neighbours  select (tile.Item1 + dir.Item1, tile.Item2 + dir.Item2, tile.Item3 + dir.Item3)){
-                    tilesX.Add(neighbour);
-                }
-            }
+        IEnumerable<Tile> Neighbourhood(Tile point) =>
+            from dir in HexDirections.Values
+            select new Tile(point.x + dir.x, point.y + dir.y, point.z + dir.z);
 
-            foreach(var tile in tilesX){
-                var color = tiles.GetValueOrDefault(tile);
-                var blackNeighbours = 0;
-                foreach(var neighbour in  from dir in neighbours  select (tile.Item1 + dir.Item1, tile.Item2 + dir.Item2, tile.Item3 + dir.Item3)){
-                   // Console.WriteLine(tile+" "+neighbour);
-                    if(tiles.GetValueOrDefault(neighbour) == 1){
-                        blackNeighbours++;
-                    }
-                }
+        HashSet<Tile> Flip(HashSet<Tile> blackTiles) {
+            var tiles = (
+                from black in blackTiles
+                from tile in Neighbourhood(black)
+                select tile
+            ).ToHashSet();
 
-                if(color == 1){
-                    res[tile] = blackNeighbours == 0 || blackNeighbours > 2 ? 0 : 1;
-                } else {
-                    res[tile] = blackNeighbours == 2 ? 1 : 0;
-                }
-            }
-            return res;
+            return (
+                from tile in tiles
+                let blacks = Neighbourhood(tile).Count(n => blackTiles.Contains(n))
+                where blacks == 2 || blacks == 3 && blackTiles.Contains(tile)
+                select tile
+            ).ToHashSet();
         }
 
-        Dictionary<(int, int, int), int> Parse(string input) {
-            Dictionary<(int, int, int), int> tiles = new Dictionary<(int, int, int), int>();
+        HashSet<Tile> ParseBlackTiles(string input) {
+            var tiles = new Dictionary<Tile, bool>();
+
             foreach (var line in input.Split("\n")) {
-                var c = Wander(line).Last();
-                tiles[c] = (tiles.GetValueOrDefault(c) + 1) % 2;
+                var tile = Walk(line);
+                tiles[tile] = !tiles.GetValueOrDefault(tile);
             }
 
-            return tiles;
+            return (from kvp in tiles where kvp.Value select kvp.Key).ToHashSet();
         }
-        IEnumerable<(int x, int y, int z)> Wander(string input) {
+
+        Tile Walk(string line) {
             var (x, y, z) = (0, 0, 0);
-            while (input != "") {
-                if (input.StartsWith("e")) { (x, y, z) = (x + 0, y + 1, z - 1); input = input.Substring(1); } 
-                else if (input.StartsWith("se")) { (x, y, z) = (x + 1, y + 0, z - 1); input = input.Substring(2); } 
-                else if (input.StartsWith("sw")) { (x, y, z) = (x + 1, y - 1, z + 0); input = input.Substring(2); } 
-                else if (input.StartsWith("w")) { (x, y, z) = (x + 0, y - 1, z + 1); input = input.Substring(1); } 
-                else if (input.StartsWith("nw")) { (x, y, z) = (x - 1, y + 0, z + 1); input = input.Substring(2); } 
-                else if (input.StartsWith("ne")) { (x, y, z) = (x - 1, y + 1, z + 0); input = input.Substring(2); }
-                yield return (x, y, z);
+            while (line != "") {
+                foreach (var kvp in HexDirections) {
+                    if (line.StartsWith(kvp.Key)) {
+                        line = line.Substring(kvp.Key.Length);
+                        (x, y, z) = (x + kvp.Value.x, y + kvp.Value.y, z + kvp.Value.z);
+                    }
+                }
             }
+            return new Tile(x, y, z);
         }
+
     }
-}
+}
