Added Day 11 (#3)

Co-authored-by: Xander Sigler <alexander@siglerdev.us>
Co-authored-by: Alexander Sigler <asigler@costar.com>
Reviewed-on: #3

AdventOfCode/Common/AOCExtensions.cs

@@ -57,5 +57,17 @@ namespace AdventOfCode.Common
                 Console.WriteLine();
             }
         }
+
+        public static void PrintSquareArray(this string[,] arr)
+        {
+            for (int x = 0; x < arr.GetLength(0); x++)
+            {
+                for (int y = 0; y < arr.GetLength(1); y++)
+                {
+                    Console.Write(arr[x, y] + " ");
+                }
+                Console.WriteLine();
+            }
+        }
     }
 }

AdventOfCode/_2023/Day10.cs

@@ -1,83 +0,0 @@
-using AdventOfCode.Models;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-
-namespace AdventOfCode._2023
-{
-    public class Day1 : AOCDay
-    {
-        private Dictionary<string, int> lookup = new Dictionary<string, int>()
-        {
-            {"zero", 0 },
-            {"one", 1 },
-            {"two", 2 },
-            {"three", 3 },
-            {"four", 4 },
-            {"five", 5 },
-            {"six", 6 },
-            {"seven", 7 },
-            {"eight", 8 },
-            {"nine", 9 },
-        };
-        protected override AOCResponse ExecutePartA()
-        {
-            var totalCount = 0;
-            foreach (var line in this.GetSplitInput())
-            {
-                totalCount += this._request.Version == AOCVersion.A ? ParseLineIntoNumber(line) : ParseTextLineIntoNumber(line);
-            }
-            this.Answer = totalCount;
-            return this._response;
-        }
-
-        protected override AOCResponse ExecutePartB()
-        {
-            return ExecutePartA();
-        }
-
-        private int ParseLineIntoNumber(string line)
-        {
-            var firstDigit = line.First(x => char.IsDigit(x));
-            var lastDigit = line.Reverse().First(x => char.IsDigit(x));
-            Log($"{line} => first: {firstDigit} last: {lastDigit}");
-            return int.Parse($"{firstDigit}{lastDigit}");
-        }
-
-        private int ParseTextLineIntoNumber(string line)
-        {
-            var foundDigits = new List<int>();
-            for (int c = 0; c < line.Length; c++)
-            {
-                if (char.IsDigit(line[c]))
-                {
-                    foundDigits.Add(int.Parse(line[c].ToString()));
-                    continue;
-                }
-                foreach (var key in lookup.Keys)
-                {
-                    var length = c + key.Length;
-                    if (length <= line.Length) //Check if we exceeded our line length
-                    {
-                        var section = new String(line.Skip(c).Take(key.Length).ToArray());
-                        if (section.Equals(key))
-                        {
-                            foundDigits.Add(lookup[key]);
-
-                            //We can't skip the length because eighthree => 83 and sevenine => 79. We only advance one char to fix
-                            //c += key.Length-1; //Outer forloop auto increments one already
-                            break;
-                        }
-                    }
-                }
-            }
-            var firstDigit = foundDigits.First();
-            var lastDigit = foundDigits.Last();
-            if (firstDigit > 9 || lastDigit > 9) throw new Exception("No digit should be higher than 9");
-            var total = int.Parse($"{firstDigit}{lastDigit}");
-            Log($"{line} => first: {firstDigit} last: {lastDigit} for total of {total}" );
-            return total;
-        }
-    }
-}

AdventOfCode/_2023/Day11.cs

@@ -0,0 +1,144 @@
+using AdventOfCode.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdventOfCode._2023
+{
+    public class Day11 : AOCDay
+    {
+       
+        protected override AOCResponse ExecutePartA()
+        {
+            return ExecutePartB();
+        }
+
+        protected override AOCResponse ExecutePartB()
+        {
+            //Determine how much space to replace each empty row with
+            var factor = this._request.Version == AOCVersion.A ? 2 : 1000000;
+
+            //Create our universe
+            var superUniverse = new SuperDuperUniverseGalaxy(factor, this.GetSplitInput().ToList());
+
+            var galaxies = superUniverse.Galaxies;
+
+            if (!this._request.IgnoreLogMessages)
+            {
+                foreach (var galaxy in galaxies)
+                {
+                    Console.WriteLine($"Galaxy {galaxy.Id} is at {galaxy.X},{galaxy.Y}");
+                }
+            }
+
+            //Calculate the shortest path.
+            long total = 0;
+            for (int i = 0; i < galaxies.Count; i++)
+            {
+                for (int j = i + 1; j < galaxies.Count; j++)
+                {
+                    total += galaxies[i].CalculateDistance(galaxies[j]);
+                }
+            }
+            this.Answer = total;
+            return this._response;
+        }
+    }
+
+    //AKA Part B
+    class SuperDuperUniverseGalaxy
+    {
+        public List<Galaxy> Galaxies { get; set; }
+        private string[,] _board;
+        public SuperDuperUniverseGalaxy(long factor, List<string> input)
+        {
+            var rows = input.Count;
+            var columns = input.First().Length;
+            _board = new string[rows, columns];
+
+            for (int x = 0; x < rows; x++)
+            {
+                for (int y = 0; y < columns; y++)
+                {
+                    _board[x, y] = input[x][y].ToString();
+                }
+            }
+
+            var doubledRows = GetDoubledRows();
+            var doubledColumns = GetDoubledColumns();
+
+            Galaxies = new List<Galaxy>();
+            int galaxyCount = 0;
+            for (int x = 0; x < _board.GetLength(0); x++)
+            {
+                for (int y = 0; y < _board.GetLength(1); y++)
+                {
+                    if (_board[x, y].Equals("#"))
+                    {
+                        long xOffset = doubledRows.Count(dR => dR <= x);
+                        long yOffset = doubledColumns.Count(dC => dC <= y);
+                        Galaxies.Add(new Galaxy()
+                        {
+                            Id = (++galaxyCount).ToString(),
+                            X = (xOffset * factor) + x - xOffset,
+                            Y = (yOffset * factor) + y - yOffset
+                        });
+                    }
+                }
+            }
+        }
+
+        public List<int> GetDoubledRows()
+        {
+            var doubledRows = new List<int>();
+            for (int x = 0; x < _board.GetLength(0); x++)
+            {
+                bool isEmpty = true;
+                for (int y = 0; y < _board.GetLength(1); y++)
+                {
+                    if (_board[x, y] == "#")
+                    {
+                        isEmpty = false;
+                        break;
+                    }
+                }
+                if (isEmpty)
+                    doubledRows.Add(x);
+            }
+            return doubledRows;
+        }
+
+        public List<int> GetDoubledColumns()
+        {
+            var doubledColumns = new List<int>();
+            for (int y = 0; y < _board.GetLength(1); y++)
+            {
+                bool isEmpty = true;
+                for (int x = 0; x < _board.GetLength(0); x++)
+                {
+                    if (_board[x, y] == "#")
+                    {
+                        isEmpty = false;
+                        break;
+                    }
+                }
+                if (isEmpty)
+                    doubledColumns.Add(y);
+            }
+            return doubledColumns;
+        }
+    }
+
+    class Galaxy
+    {
+        public string Id { get; set; }
+        public long X { get; set; }
+        public long Y { get; set; }
+
+        public long CalculateDistance(Galaxy galaxy)
+        {
+            //We use Manhattan distance |x2 - x1| + |y2-y1|
+            return Math.Abs(this.X - galaxy.X) + Math.Abs(this.Y - galaxy.Y);
+        }
+    }
+}

AdventOfCode/_2023/Day9.cs

@@ -0,0 +1,106 @@
+using AdventOfCode.Common;
+using AdventOfCode.Models;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace AdventOfCode._2023
+{
+    public class Day9 : AOCDay
+    {
+      
+        protected override AOCResponse ExecutePartA()
+        {
+            long total = 0;
+            foreach(var input in this.GetSplitInput())
+            {
+                var listOfValues = input.Split(' ').Select(x => long.Parse(x)).ToList();
+                var entry = new Entry()
+                {
+                    Values = listOfValues
+                };
+                entry.CreateBelowRecord(this._request.Version);
+                if (this._request.Version == AOCVersion.A)
+                {
+                    total += entry.Values.Last();
+                }
+                else
+                {
+                    total += entry.Values.First();
+                }
+                
+                Log( "Result is : \n " +entry.GetPrint());
+            }
+            this.Answer = total;
+            return this._response;
+        }
+
+        protected override AOCResponse ExecutePartB()
+        {
+            return ExecutePartA();
+        }
+    }
+
+    class Entry
+    {
+        public Entry Above { get; set; }
+        public Entry Below { get; set; }
+        public List<long> Values { get; set; }
+
+        public void CreateBelowRecord(AOCVersion version)
+        {
+            var belowValues = new List<long>();
+            for (int i = 0; i < Values.Count-1; i++)
+            {
+                belowValues.Add(Values[i + 1] - Values[i]);
+            }
+            Below = new Entry()
+            {
+                Above = this,
+                Values = belowValues
+            };
+
+            //If the below record we just created consists of all 0s
+            if (Below.IsBottom())
+            {
+                if (version == AOCVersion.A)
+                {
+                    Below.Values.Add(0); //Extrapolated value
+                    var currentAbove = this;
+                    while (currentAbove != null)
+                    {
+                        currentAbove.Values.Add(currentAbove.Values.Last() + currentAbove.Below.Values.Last());
+                        currentAbove = currentAbove.Above;
+                    }
+                }
+                else //Means it is part B
+                {
+                    Below.Values.Insert(0, 0); //Append the 0 to the start
+                    var currentAbove = this;
+                    while (currentAbove != null)
+                    {
+                        currentAbove.Values.Insert(0, currentAbove.Values.First() - currentAbove.Below.Values.First());
+                        currentAbove = currentAbove.Above;
+                    }
+                }
+
+            }
+            else
+            {
+                Below.CreateBelowRecord(version);
+            }
+        }
+
+        public bool IsBottom()
+        {
+            return Values.TrueForAll(x => x == 0);
+        }
+
+        public string GetPrint()
+        {
+            return string.Join(" ", Values)  + "\n " + (Below != null ? Below.GetPrint() : "");
+        }
+    }
+
+}