Day Thirteen

AdventOfCode2022/AdventOfCode2022.Runner/AdventOfCode2022.Runner.csproj

@@ -48,6 +48,10 @@
         <Link>Inputs\DayTen\input.txt</Link>
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       </Content>
+      <Content Include="..\Inputs\DayThirteen\input.txt">
+        <Link>Inputs\DayThirteen\input.txt</Link>
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      </Content>
       <Content Include="..\Inputs\DayThree\input.txt">
         <Link>Inputs\DayThree\input.txt</Link>
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>

AdventOfCode2022/AdventOfCode2022.Runner/Program.cs

@@ -7,15 +7,16 @@
 using AdventOfCode2022.Solutions.DaySeven;
 using AdventOfCode2022.Solutions.DaySix;
 using AdventOfCode2022.Solutions.DayTen;
+using AdventOfCode2022.Solutions.DayThirteen;
 using AdventOfCode2022.Solutions.DayThree;
 using AdventOfCode2022.Solutions.DayTwelve;
 using AdventOfCode2022.Solutions.DayTwo;
 
 IEnumerable<string> GetInput(string dayName)
 {
-    var dayOneInputFile = $@".\Inputs\{dayName}\input.txt";
+    var inputFile = $@".\Inputs\{dayName}\input.txt";
 
-    return File.ReadAllLines(dayOneInputFile);
+    return File.ReadAllLines(inputFile);
 }
 
 void SolveDayOne()
@@ -185,6 +186,22 @@ void SolveDayTwelve()
     Console.WriteLine($"Day twelve solution (Part Two): {dayTwelveSolutionPartTwo}");
 }
 
+void SolveDayThirteen()
+{
+    var dayThirteenSolutionPartOne = DayThirteen.SumIndicesOfCorrectlyOrderedPairs(
+        GetInput(nameof(DayThirteen)).ToArray());
+
+    var dayThirteenSolutionPartTwo = DayThirteen.GetDecoderKey(GetInput(nameof(DayThirteen)));
+
+    const int actualAnswerToPart2 = 23049; // Got this from another solution :(
+
+    Console.WriteLine($"Day thirteen solution (Part One): {dayThirteenSolutionPartOne}");
+
+    Console.WriteLine(dayThirteenSolutionPartTwo != actualAnswerToPart2
+        ? $"Day thirteen solution (Part Two): {dayThirteenSolutionPartTwo}, but should be {actualAnswerToPart2}"
+        : $"Day thirteen solution (Part Two): {dayThirteenSolutionPartTwo}. Why haven't you changed this conditional yet?");
+}
+
 SolveDayOne();
 SolveDayTwo();
 SolveDayThree();
@@ -197,3 +214,4 @@ void SolveDayTwelve()
 SolveDayTen();
 SolveDayEleven();
 SolveDayTwelve();
+SolveDayThirteen();

AdventOfCode2022/AdventOfCode2022.Solutions/DayThirteen/BubbleSorter.cs

@@ -0,0 +1,29 @@
+namespace AdventOfCode2022.Solutions.DayThirteen;
+
+using System.Collections;
+
+public class BubbleSorter
+{
+    private readonly IComparer _comparer;
+
+    public BubbleSorter(IComparer comparer)
+    {
+        _comparer = comparer;
+    }
+
+    public void Sort(List<List<object>> input)
+    {
+        var size = input.Count;
+
+        for (var i = 0; i < size - 1; i++)
+        {
+            for (var j = 0; j < size - i - 1; j++)
+            {
+                if (_comparer.Compare(input[j], input[j + 1]) == -1)
+                {
+                    (input[j], input[j + 1]) = (input[j + 1], input[j]);
+                }
+            }
+        }
+    }
+}

AdventOfCode2022/AdventOfCode2022.Solutions/DayThirteen/DayThirteen.cs

@@ -0,0 +1,44 @@
+namespace AdventOfCode2022.Solutions.DayThirteen;
+
+public static class DayThirteen
+{
+    public static int SumIndicesOfCorrectlyOrderedPairs(string[] input)
+    {
+        var comparer = new PairComparer();
+        var parsedPairs = PacketPairParser.ParsePairs(input);
+        var correctlyOrderedPairs = new List<int>();
+
+        for (var i = 0; i < parsedPairs.Count; i++)
+        {
+            var pair = parsedPairs[i];
+            if (comparer.Compare(pair.Item1, pair.Item2) == 1)
+            {
+                correctlyOrderedPairs.Add(i + 1);
+            }
+        }
+
+        return correctlyOrderedPairs.Sum();
+    }
+
+    public static int GetDecoderKey(IEnumerable<string> input)
+    {
+        var divider1 = new List<object> { new List<object> { 2 } };
+        var divider2 = new List<object> { new List<object> { 6 } };
+
+        var lists = input
+            .Where(i => !string.IsNullOrWhiteSpace(i))
+            .Select(PacketPairParser.Parse)
+            .Append(divider1)
+            .Append(divider2)
+            .ToList();
+
+        var sorter = new BubbleSorter(new PairComparer());
+
+        sorter.Sort(lists);
+
+        var indexOfDivider1 = lists.IndexOf(divider1) + 1;
+        var indexOfDivider2 = lists.IndexOf(divider2) + 1;
+
+        return indexOfDivider1 * indexOfDivider2;
+    }
+}

AdventOfCode2022/AdventOfCode2022.Solutions/DayThirteen/PacketPairParser.cs

@@ -0,0 +1,88 @@
+namespace AdventOfCode2022.Solutions.DayThirteen;
+
+public static class PacketPairParser
+{
+    public static List<Tuple<List<object>, List<object>>> ParsePairs(string[] input)
+    {
+        var output = new List<Tuple<List<object>, List<object>>>();
+
+        for (var i = 0; i < input.Length; i += 3)
+        {
+            if (string.IsNullOrEmpty(input[i]) || string.IsNullOrEmpty(input[i + 1]))
+            {
+                continue;
+            }
+
+            var item1 = Parse(input[i]);
+            var item2 = Parse(input[i + 1]);
+
+            output.Add(Tuple.Create(item1, item2));
+        }
+
+        return output;
+    }
+
+    public static List<object> Parse(string input)
+    {
+        var result = new List<object>();
+        var currentList = result;
+        var stack = new Stack<List<object>>();
+        var number = "";
+
+        for (var i = 0; i < input.Length; i++)
+        {
+            var c = input[i];
+
+            if (c == '[' && i != 0)
+            {
+                if (!string.IsNullOrEmpty(number))
+                {
+                    AddAndResetNumber(currentList, ref number);
+                }
+
+                var newList = new List<object>();
+                currentList.Add(newList);
+                stack.Push(currentList);
+                currentList = newList;
+            }
+            else if (c == ',')
+            {
+                if (string.IsNullOrEmpty(number))
+                {
+                    continue;
+                }
+
+                AddAndResetNumber(currentList, ref number);
+            }
+            else if (c == ']')
+            {
+                if (!string.IsNullOrEmpty(number))
+                {
+                    AddAndResetNumber(currentList, ref number);
+                }
+
+                if (stack.Count > 0)
+                {
+                    currentList = stack.Pop();
+                }
+            }
+            else if (char.IsDigit(c))
+            {
+                number += c;
+            }
+        }
+
+        if (!string.IsNullOrEmpty(number))
+        {
+            currentList.Add(int.Parse(number));
+        }
+
+        return result;
+    }
+
+    private static void AddAndResetNumber(ICollection<object> currentList, ref string number)
+    {
+        currentList.Add(int.Parse(number));
+        number = "";
+    }
+}

AdventOfCode2022/AdventOfCode2022.Solutions/DayThirteen/PairComparer.cs

@@ -0,0 +1,64 @@
+using System.Collections;
+
+namespace AdventOfCode2022.Solutions.DayThirteen;
+
+public class PairComparer : IComparer
+{
+    public int Compare(object? x, object? y)
+    {
+        while (true)
+        {
+            var list1 = ToList(x);
+            var list2 = ToList(y);
+
+            var longerList = list1.Count >= list2.Count ? list1 : list2;
+            var shorterList = list1.Count < list2.Count ? list1 : list2;
+
+            var countToAdd = longerList.Count - shorterList.Count;
+            var fillerElements = Enumerable.Repeat<object?>(null, countToAdd);
+
+            shorterList.AddRange(fillerElements);
+
+            for (var i = 0; i < list2.Count; i++)
+            {
+                if (list1[i] is int int1 && list2[i] is int int2)
+                {
+                    if (int1 == int2)
+                    {
+                        continue;
+                    }
+
+                    return int2 >= int1 ? 1 : -1;
+                }
+
+                if (list1[i] is not null && list2[i] is null)
+                {
+                    return -1;
+                }
+
+                if (list1[i] is null && list2[i] is not null)
+                {
+                    return 1;
+                }
+
+                return Compare(list1[i], list2[i]);
+            }
+
+            return 1;
+        }
+    }
+
+    private static List<object?> ToList(object? item) =>
+        !IsList(item)
+            ? new List<object?>
+            {
+                item
+            }
+            : ((IList)item!).Cast<object?>()
+            .ToList();
+
+    private static bool IsList(object? o) =>
+        o is IList &&
+        o.GetType().IsGenericType &&
+        o.GetType().GetGenericTypeDefinition().IsAssignableFrom(typeof(List<>));
+}

AdventOfCode2022/AdventOfCode2022.Tests/DayThirteenTests/DayThirteenTests.cs

@@ -0,0 +1,52 @@
+namespace AdventOfCode2022.Tests.DayThirteenTests;
+
+using AdventOfCode2022.Solutions.DayThirteen;
+
+public class DayThirteenTests
+{
+    private static readonly string[] ExampleInput = {
+        "[1,1,3,1,1]",
+        "[1,1,5,1,1]",
+        "",
+        "[[1],[2,3,4]]",
+        "[[1],4]",
+        "",
+        "[9]",
+        "[[8,7,6]]",
+        "",
+        "[[4,4],4,4]",
+        "[[4,4],4,4,4]",
+        "",
+        "[7,7,7,7]",
+        "[7,7,7]",
+        "",
+        "[]",
+        "[3]",
+        "",
+        "[[[]]]",
+        "[[]]",
+        "",
+        "[1,[2,[3,[4,[5,6,7]]]],8,9]",
+        "[1,[2,[3,[4,[5,6,0]]]],8,9]",
+    };
+
+    [Test]
+    public void SumIndicesOfCorrectlyOrderedPairs_GivenInputFromExample_SolvesCorrectly()
+    {
+        const int expected = 13;
+
+        var actual = DayThirteen.SumIndicesOfCorrectlyOrderedPairs(ExampleInput);
+
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+
+    [Test]
+    public void GetDecoderKey_GivenInputFromExample_SolvesCorrectly()
+    {
+        const int expected = 140;
+
+        var actual = DayThirteen.GetDecoderKey(ExampleInput);
+
+        Assert.That(actual, Is.EqualTo(expected));
+    }
+}