Rewrite 2024 day 2

The original solution bothered me. So after I determined which edge cases tripped up my initial implementation, I was able to make a more readable version.

Author: Basje

2024.Tests/Day02Tests.cs

@@ -39,4 +39,24 @@ 1 3 6 7 9
 
         answer.Should().Be(4);
     }
+
+    [Fact]
+    public static void Part2EdgeCases()
+    {
+        var solution = new Day02();
+        
+        // These edge cases are the ones that tripped 
+        // up my initial solution. It anticipates the 
+        // fact that increase or decrease are determined
+        // using the first two numbers, and then go
+        // into the other direction. Well played, Eric.
+        const string input = """
+                             88 86 88 89 90 93 95
+                             47 50 47 46 44 41 38 37
+                             """;
+
+        var answer = solution.SolvePart2(input);
+
+        answer.Should().Be(2);
+    }
 }

2024/D02/Day02.cs

@@ -15,84 +15,56 @@ protected override List<List<int>> ParseInput(string input)
     protected override object SolvePart1(List<List<int>> reports)
     {
         return reports
-            .Select(report => report.Steps().ToList())
-            .Count(steps => steps.AllInRange() && (steps.AllIncreasing() || steps.AllDecreasing()));
+            .Count(report => report.Steps().AreSafe());
     }
 
     protected override object SolvePart2(List<List<int>> reports)
     {
         var safeReports = reports
-            .Where(report =>
-            {
-                var steps = report.Steps().ToList();
-                return steps.AllInRange() && (steps.AllIncreasing() || steps.AllDecreasing());
-            })
-            .ToList();
-
-        var unsafeReports = reports.Except(safeReports).ToList();
-        
-        unsafeReports.ForEach(report =>
-        {
-            var wrongStep = report.Steps().ToList().FindIndex((number) => report.IsIncreasing() ? number is < 1 or > 3 : number is < -3 or > -1);
-
-            for (var index = Math.Max(0, wrongStep - 1); index < Math.Min(wrongStep + 2, report.Count); index++)
-            {
-                var filteredReport = report.ToList();
-                filteredReport.RemoveAt(index);
-                var steps = filteredReport.Steps().ToList();
+            .Where(report => report.Steps().AreSafe())
+            .ToArray();
 
-                if (steps.AllInRange() && (steps.AllIncreasing() || steps.AllDecreasing()))
-                {
-                    safeReports.Add(report);
-                    break;
-                }
-            }
-        });
+        var fixedReports = reports
+            .Except(safeReports)
+            .Select(report => (Report: report, Steps: report.Steps(), Increasing: report[^1] > report[0]))
+            .Select(data => (Report: data.Report, WrongStep: data.FindFirstWrongStep()))
+            .Count(data => data.Report.CompensateForStep(data.WrongStep).Any(report => report.Steps().AreSafe()));
 
-        return safeReports.Count;
+        return safeReports.Length + fixedReports;
     }
 }
 
 internal static class Day02Extensions
 {
-    internal static bool AllInRange(this List<int> numbers)
+    internal static bool AreSafe(this IEnumerable<int> steps)
     {
-        return numbers.Count(number => Math.Abs(number) is >= 1 and <= 3) == numbers.Count;
-    }
-    
-    internal static bool AllDecreasing(this List<int> numbers)
-    {
-        return numbers.CountDecreasing() == numbers.Count;
-    }
-    
-    internal static bool AllIncreasing(this List<int> numbers)
-    {
-        return numbers.CountIncreasing() == numbers.Count;
+        return steps.All(n => n is >= 1 and <= 3)
+            || steps.All(n => n is >= -3 and <= -1);
     }
 
-    internal static IEnumerable<int> Steps(this IEnumerable<int> numbers)
+    internal static int FindFirstWrongStep(this (List<int> Report, List<int> Steps, bool Increasing) data)
     {
-        foreach (var levelSet in numbers.SlidingWindow(2))
-        {
-            var left = levelSet[0];
-            var right = levelSet[1];
-
-            yield return right - left;
-        }
+        return data
+            .Steps
+            .FindIndex((number) => data.Increasing  ? number is < 1 or > 3 : number is < -3 or > -1);
     }
 
-    internal static bool IsIncreasing(this List<int> numbers)
+    internal static List<int>[] CompensateForStep(this List<int> report, int position)
     {
-        return numbers[1] > numbers[0];
-    }
-    
-    private static int CountDecreasing(this List<int> numbers)
-    {
-        return numbers.Count(number => number < 0);
+        return 
+        [
+            // Create new reports without the values that cause the
+            // wrong step at "position" in an attempt to compensate.
+            [..report[..position], ..report[(position+1)..]],
+            [..report[..(position+1)], ..report[(position+2)..]]
+        ];
     }
 
-    private static int CountIncreasing(this List<int> numbers)
+    internal static List<int> Steps(this IEnumerable<int> numbers)
     {
-        return numbers.Count(number => number > 0);
+        return numbers
+            .Zip(numbers.Skip(1), Tuple.Create)
+            .Select(tuple => tuple.Item2 - tuple.Item1)
+            .ToList();
     }
 }