apply style fixes

* trailing comma
* prefer concrete collection type
* collection expression

Solutions/2015/Day04.cs

···
         while (true)
         {
             var hash = MD5.HashData(Encoding.ASCII.GetBytes(_key + counter));
-            if (BitConverter.ToString(hash).Replace("-", "").StartsWith("00000"))
+            if (Convert.ToHexString(hash).StartsWith("00000"))
                 return counter;
             counter++;
         }

Solutions/2015/Day07.cs

···
                 case 3:
                     if (ushort.TryParse(split[0], out var val))
                     {
-                        _actions.Add(destination, () => val);
+                        var result = val;
+                        _actions.Add(destination, () => result);
                         _wires.Add(destination, val);
                     }
                     else

Solutions/2015/Day18.cs

···
                     lights[i][j + 1],
                     lights[i + 1][j - 1],
                     lights[i + 1][j],
-                    lights[i + 1][j + 1]
+                    lights[i + 1][j + 1],
                 }.Count(n => n);
 
                 nextGrid[i][j] = lights[i][j] ? activeNeighbors is 2 or 3 : activeNeighbors == 3;

Solutions/2015/Day21.cs

···
             new(Name: "Shortsword", Cost: 10, Damage: 5),
             new(Name: "Warhammer",  Cost: 25, Damage: 6),
             new(Name: "Longsword",  Cost: 40, Damage: 7),
-            new(Name: "Greataxe",   Cost: 74, Damage: 8)
+            new(Name: "Greataxe",   Cost: 74, Damage: 8),
         };
 
         var armor = new Item[]
···
             new(Name: "Chainmail",  Cost: 31,  Armor: 2),
             new(Name: "Splintmail", Cost: 53,  Armor: 3),
             new(Name: "Bandedmail", Cost: 75,  Armor: 4),
-            new(Name: "Platemail",  Cost: 102, Armor: 5)
+            new(Name: "Platemail",  Cost: 102, Armor: 5),
         };
 
         var rings = new Item[]
···
             new(Name: "Damage +3",  Cost: 100, Damage: 3, Armor: 0),
             new(Name: "Defense +1", Cost: 20,  Damage: 0, Armor: 1),
             new(Name: "Defense +2", Cost: 40,  Damage: 0, Armor: 2),
-            new(Name: "Defense +3", Cost: 80,  Damage: 0, Armor: 3)
+            new(Name: "Defense +3", Cost: 80,  Damage: 0, Armor: 3),
         };
 
         _combinations =

Solutions/2015/Day22.cs

···
         new("Drain", Mana: 73, Damage: 2, Heal: 2),
         new("Shield", Mana: 113, Armor: 7, Duration: 6),
         new("Poison", Mana: 173, Damage: 3, Duration: 6),
-        new("Recharge", Mana: 229, ManaCharge: 101, Duration: 5)
+        new("Recharge", Mana: 229, ManaCharge: 101, Duration: 5),
     ];
 
     private Dictionary<string, int> _boss = new();
···
         int ManaCharge = 0
     );
 
-    private struct GameState(bool hardMode = false, int roundNumber = 0, int totalManaSpent = 0, int playerHealth = 50,
-        int playerMana = 500, int bossHealth = 0, int bossDamage = 0, Dictionary<Spell, int>? activeSpells = null)
+    private struct GameState(
+        bool hardMode = false,
+        int roundNumber = 0,
+        int totalManaSpent = 0,
+        int playerHealth = 50,
+        int playerMana = 500,
+        int bossHealth = 0,
+        int bossDamage = 0,
+        Dictionary<Spell, int>? activeSpells = null)
     {
         public GameResult DoTurn(Spell spell)
         {
···
         private void ProcessActiveSpells()
         {
             if (activeSpells is null) return;
-            
+
             activeSpells.Keys.ForEach(ProcessSpell);
             foreach (var (spell, duration) in activeSpells.ToList())
             {
···
     {
         Win,
         Loss,
-        Continue
+        Continue,
     }
 
     private GameState ProcessStates(GameState initialState)
···
         _boss = Input.ToDictionary(k => k.Split(": ")[0], v => int.Parse(v.Split(": ")[1]));
 
     public override object Part1() => "";
-        // ProcessStates(new(bossHealth: _boss["Hit Points"], bossDamage: _boss["Damage"]));
+    // ProcessStates(new(bossHealth: _boss["Hit Points"], bossDamage: _boss["Damage"]));
 
     public override object Part2() => "";
 }

Solutions/2015/Day23.cs

···
         Dictionary<char, int> registers = new()
         {
             ['a'] = initialA,
-            ['b'] = initialB
+            ['b'] = initialB,
         };
 
         var input = Input.ToList();

Solutions/2016/Day01.cs

···
             Direction.South => (coord.x, coord.y - 1),
             Direction.East => (coord.x + 1, coord.y),
             Direction.West => (coord.x - 1, coord.y),
-            _ => (0, 0)
+            _ => (0, 0),
         };
 
     public override object Part1()

Solutions/2016/Day02.cs

···
                 'D' => c with { y = c.y == 2 ? c.y : c.y + 1 },
                 'L' => c with { x = c.x == 0 ? c.x : c.x - 1 },
                 'R' => c with { x = c.x == 2 ? c.x : c.x + 1 },
-                _ => throw new ArgumentException("invalid direction", nameof(instruction))
+                _ => throw new ArgumentException("invalid direction", nameof(instruction)),
             });
 
             answer.Add(1 + location.x + location.y * 3);
···
                 'D' => c with { y = c.y == 4 || keyPad[c.y + 1, c.x] == '\0' ? c.y : c.y + 1 },
                 'L' => c with { x = c.x == 0 || keyPad[c.y, c.x - 1] == '\0' ? c.x : c.x - 1 },
                 'R' => c with { x = c.x == 4 || keyPad[c.y, c.x + 1] == '\0' ? c.x : c.x + 1 },
-                _ => throw new ArgumentException("invalid direction", nameof(instruction))
+                _ => throw new ArgumentException("invalid direction", nameof(instruction)),
             });
 
             answer.Add(keyPad[location.y, location.x]);

Solutions/2016/Day07.cs

···
     private static bool SupportsSsl(string input)
     {
         foreach (var ip in BracketsRegex().Split(input))
-            foreach (var aba in CheckAba(ip))
-                foreach (var m in InsideBracketsRegex().Matches(input).Cast<Match>())
-                    if (m.Value.Contains($"{aba[1]}{aba[0]}{aba[1]}"))
-                        return true;
+        foreach (var aba in CheckAba(ip))
+        foreach (var m in InsideBracketsRegex().Matches(input).Cast<Match>())
+            if (m.Value.Contains($"{aba[1]}{aba[0]}{aba[1]}"))
+                return true;
 
         return false;
     }

Solutions/2019/Day02.cs

···
             {
                 1 => v[v[i + 1]] + v[v[i + 2]],
                 2 => v[v[i + 1]] * v[v[i + 2]],
-                _ => throw new ArgumentOutOfRangeException(nameof(verb))
+                _ => throw new ArgumentOutOfRangeException(nameof(verb)),
             };
 
         return v[0];

Solutions/2019/Day05.cs

···
     public override void ProcessInput() =>
         _tape = Input.First().Split(',').Select(int.Parse);
 
-    private void RunIntCode(IList<int> v, int input)
+    private void RunIntCode(List<int> v, int input)
     {
         var i = 0;
         while (i < v.Count && v[i] != 99)

Solutions/2019/Day10.cs

···
         foreach (var asteroid in _asteroids!)
         {
             var canSee = _asteroids
-                .Except(new[] { asteroid })
+                .Except([asteroid])
                 .Select(a => (x: a.x - asteroid.x, y: a.y - asteroid.y))
                 .GroupBy(a => Math.Atan2(a.y, a.x))
                 .Count();

Solutions/2019/Day11.cs

···
         Up,
         Down,
         Left,
-        Right
+        Right,
     }
 
     public override void ProcessInput() =>
···
             Direction.Down => direction == 0 ? Direction.Right : Direction.Left,
             Direction.Left => direction == 0 ? Direction.Down : Direction.Up,
             Direction.Right => direction == 0 ? Direction.Up : Direction.Down,
-            _ => _heading
+            _ => _heading,
         };
 
         Move();

Solutions/2019/Day13.cs

···
                 2 => "#",
                 3 => "_",
                 4 => ".",
-                _ => value
+                _ => value,
             });
         }
     }

Solutions/2019/Day14.cs

···
                 return new()
                 {
                     Quantity = int.Parse(spl[0]),
-                    Name = spl[1]
+                    Name = spl[1],
                 };
             }
         }

Solutions/2019/Day15.cs

···
                     currentLocation = _vm.Result switch
                     {
                         Location.Empty or Location.System => Location.GetLocation(currentLocation.Neighbor(direction)),
-                        _ => throw new($"Unknown or unexpected response for previous room: {_vm.Result}")
+                        _ => throw new($"Unknown or unexpected response for previous room: {_vm.Result}"),
                     };
                 }
                 else
···
             Wall => "\u2587",
             Empty => X == 0 && Y == 0 ? "S" : " ",
             System => "O",
-            _ => "?"
+            _ => "?",
         };
 
         public bool UpdateDistanceToOxygenSystem()

Solutions/2019/IntCodeVM.cs

···
             0 => MemGet(param),
             1 => param,
             2 => MemGet(_relativeBase + param),
-            _ => throw new("invalid parameter mode")
+            _ => throw new("invalid parameter mode"),
         };
     }
 

Solutions/2020/Day10.cs

···
     {
         var parsed = Input.Select(int.Parse).ToArray();
         // add socket and device to the list
-        _adapters = parsed.Concat(new[] { 0, parsed.Max() + 3 }).OrderBy(i => i).ToArray();
+        _adapters = parsed.Concat([0, parsed.Max() + 3]).OrderBy(i => i).ToArray();
         _memo = new long[_adapters.Length];
     }
 

Solutions/2020/Day11.cs

···
                 {
                     'L' when CountAdjacent(y, x) == 0 => '#',
                     '#' when CountAdjacent(y, x) >= 4 => 'L',
-                    _ => Grid[y][x]
+                    _ => Grid[y][x],
                 };
 
             // next.PrintBoard();
···
             new[]
             {
                 At(y - 1, x - 1), At(y - 1, x + 0), At(y - 1, x + 1), At(y + 0, x - 1), At(y + 0, x + 1),
-                At(y + 1, x - 1), At(y + 1, x + 0), At(y + 1, x + 1)
+                At(y + 1, x - 1), At(y + 1, x + 0), At(y + 1, x + 1),
             }.Count(c => c == '#');
 
         public LifeGame StepPart2()
···
                 {
                     'L' when CanSee(y, x) == 0 => '#',
                     '#' when CanSee(y, x) >= 5 => 'L',
-                    _ => Grid[y][x]
+                    _ => Grid[y][x],
                 };
 
             // next.PrintBoard();
···
             new[]
             {
                 TraceRay(y, x, -1, -1), TraceRay(y, x, -1, +0), TraceRay(y, x, -1, +1), TraceRay(y, x, +0, -1),
-                TraceRay(y, x, +0, +1), TraceRay(y, x, +1, -1), TraceRay(y, x, +1, +0), TraceRay(y, x, +1, +1)
+                TraceRay(y, x, +0, +1), TraceRay(y, x, +1, -1), TraceRay(y, x, +1, +0), TraceRay(y, x, +1, +1),
             }.Count(c => c == '#');
 
         private char TraceRay(int y, int x, int dy, int dx)

Solutions/2020/Day17.cs

···
             _plane4[(x, y, 0, 0)] = input[y][x];
     }
 
-    private static int Neighbors(IReadOnlyDictionary<(int x, int y, int z), char> plane, int x, int y, int z)
+    private static int Neighbors(Dictionary<(int x, int y, int z), char> plane, int x, int y, int z)
     {
         var neighbors = 0;
 
···
     }
 
     private static Dictionary<(int x, int y, int z), char> Iterate(
-        IReadOnlyDictionary<(int x, int y, int z), char> prev)
+        Dictionary<(int x, int y, int z), char> prev)
     {
         var next = new Dictionary<(int x, int y, int z), char>();
 
···
         return next;
     }
 
-    private static int Neighbors4(IReadOnlyDictionary<(int x, int y, int z, int w), char> plane, int x, int y,
+    private static int Neighbors4(Dictionary<(int x, int y, int z, int w), char> plane, int x, int y,
         int z, int w)
     {
         var neighbors = 0;
···
     }
 
     private static Dictionary<(int x, int y, int z, int w), char> Iterate4(
-        IReadOnlyDictionary<(int x, int y, int z, int w), char> prev)
+        Dictionary<(int x, int y, int z, int w), char> prev)
     {
         var next = new Dictionary<(int x, int y, int z, int w), char>();
 

Solutions/2020/Day19.cs

···
         var sub = string.Join("|", _rules![key].Select(test => test.Length switch
         {
             1 => test[0][0] == '"' ? test[0].Trim('"') : MakeRegexExpression(test[0]),
-            _ => string.Join(string.Empty, test.Select(MakeRegexExpression))
+            _ => string.Join(string.Empty, test.Select(MakeRegexExpression)),
         }));
         _stack.Pop();
         return _rules[key].Length > 1 ? $"({sub})" : sub;

Solutions/2020/Day20.cs

···
             (piece._topSide.Value, new(piece._topSide.Value.Reverse().ToArray())),
             (piece.RightSide.Value, new(piece.RightSide.Value.Reverse().ToArray())),
             (piece.BottomSide.Value, new(piece.BottomSide.Value.Reverse().ToArray())),
-            (piece._leftSide.Value, new(piece._leftSide.Value.Reverse().ToArray()))
+            (piece._leftSide.Value, new(piece._leftSide.Value.Reverse().ToArray())),
         ];
 
         private static HashSet<string> CalculateAllSidesWithFlipped(PuzzlePiece piece) =>

Solutions/2020/Day22.cs

···
         bool recursive) =>
         Play(new(enumerable1), new(enumerable2), recursive);
 
-    private static int CalculateScore(IReadOnlyCollection<int> deck) =>
+    private static int CalculateScore(Queue<int> deck) =>
         deck.Reverse().Zip(Enumerable.Range(1, deck.Count), (a, b) => a * b).Sum();
 
     public override object Part1()

Solutions/2020/Day24.cs

···
         { "se", (0, 1, -1) },
         { "sw", (-1, 1, 0) },
         { "nw", (0, -1, 1) },
-        { "ne", (1, -1, 0) }
+        { "ne", (1, -1, 0) },
     };
 
     private Dictionary<(int q, int r, int s), Tile>? _tiles;

Solutions/2021/Day04.cs

···
 
     private int At(int x, int y) => x * _size + y;
 
-    private bool HasWin(HashSet<int> c, IReadOnlyList<int> b)
+    private bool HasWin(HashSet<int> c, List<int> b)
     {
         for (var y = 0; y < _size; y++)
         {

Solutions/2021/Day08.cs

···
             "1010010" => 7,
             "1111111" => 8,
             "1111011" => 9,
-            _ => -1
+            _ => -1,
         };
 
     private static int Decode(string line)

Solutions/2021/Day10.cs

···
         {'(', ')'},
         {'[', ']'},
         {'{', '}'},
-        {'<', '>'}
+        {'<', '>'},
     };
 
     private static readonly Dictionary<char, long> Scores = new()
···
         { ')', 3 },
         { ']', 57 },
         { '}', 1197 },
-        { '>', 25137 }
+        { '>', 25137 },
     };
 
     private static readonly Dictionary<char, long> ScoresPart2 = new()
···
         { '(', 1 },
         { '[', 2 },
         { '{', 3 },
-        { '<', 4 }
+        { '<', 4 },
     };
 
     private readonly List<long> _scores2 = [];

Solutions/2021/Day11.cs

···
 
             // increment all octopuses
             for (var row = 0; row < _octopusField.Length; row++)
-                for (var col = 0; col < _octopusField[row].Length; col++)
-                    _octopusField[row][col]++;
+            for (var col = 0; col < _octopusField[row].Length; col++)
+                _octopusField[row][col]++;
 
             // flash any that exceeded 10
             for (var row = 0; row < _octopusField.Length; row++)
-                for (var col = 0; col < _octopusField[row].Length; col++)
-                    if (_octopusField[row][col] == 10)
-                        FlashAt(row, col);
+            for (var col = 0; col < _octopusField[row].Length; col++)
+                if (_octopusField[row][col] == 10)
+                    FlashAt(row, col);
 
             var done = true;
             for (var row = 0; row < _octopusField.Length; row++)
-                for (var col = 0; col < _octopusField[row].Length; col++)
-                    if (_octopusField[row][col] == -1)
-                        _octopusField[row][col] = 0;
-                    else
-                        done = false;
+            for (var col = 0; col < _octopusField[row].Length; col++)
+                if (_octopusField[row][col] == -1)
+                    _octopusField[row][col] = 0;
+                else
+                    done = false;
 
             if (_totalTurns == 100) _flashesAfter100 = _flashTally;
             if (done) break;
···
         _flashTally++;
         _octopusField![r][c] = -1;
         foreach (var rr in new[] { -1, 0, 1 }.Select(dr => dr + r))
-            foreach (var cc in new[] { -1, 0, 1 }.Select(dc => dc + c))
-                if (0 <= rr && rr < _octopusField.Length && 0 <= cc && cc < _octopusField[0].Length && _octopusField[rr][cc] != -1)
-                {
-                    _octopusField[rr][cc]++;
-                    if (_octopusField[rr][cc] >= 10)
-                        FlashAt(rr, cc);
-                }
+        foreach (var cc in new[] { -1, 0, 1 }.Select(dc => dc + c))
+            if (0 <= rr && rr < _octopusField.Length && 0 <= cc && cc < _octopusField[0].Length &&
+                _octopusField[rr][cc] != -1)
+            {
+                _octopusField[rr][cc]++;
+                if (_octopusField[rr][cc] >= 10)
+                    FlashAt(rr, cc);
+            }
     }
 
     public override object Part1() => _flashesAfter100;

Solutions/2021/Day15.cs

···
         }
     }
 
-    private static int DijkstraCost(IReadOnlyDictionary<(int x, int y), Node> grid, Node target)
+    private static int DijkstraCost(Dictionary<(int x, int y), Node> grid, Node target)
     {
         var searchQueue = new PriorityQueue<Node, int>();
         grid[(0, 0)].Distance = 0;

Solutions/2021/Day16.cs

···
                 5 => Packets[0].Eval > Packets[1].Eval ? 1 : 0,
                 6 => Packets[0].Eval < Packets[1].Eval ? 1 : 0,
                 7 => Packets[0].Eval == Packets[1].Eval ? 1 : 0,
-                _ => throw new ArgumentException("invalid packet type", nameof(TypeId))
+                _ => throw new ArgumentException("invalid packet type", nameof(TypeId)),
             };
     }
 

Solutions/2021/Day19.cs

···
             (-1, 0, 0) => (pt.Y, -pt.X, pt.Z),
             (0, 0, 1) => (pt.Y, pt.Z, pt.X),
             (0, 0, -1) => (pt.Y, -pt.Z, -pt.X),
-            _ => throw new("Invalid up vector")
+            _ => throw new("Invalid up vector"),
         };
 
         return rotation switch
···
             1 => (reoriented.Z, reoriented.Y, -reoriented.X),
             2 => (-reoriented.X, reoriented.Y, -reoriented.Z),
             3 => (-reoriented.Z, reoriented.Y, reoriented.X),
-            _ => throw new("Invalid rotation")
+            _ => throw new("Invalid rotation"),
         };
     }
 

Solutions/2021/Day23.cs

···
             return possible;
         },
         Distance = tuple => tuple.distance,
-        Cell = (_, tuple) => tuple.state
+        Cell = (_, tuple) => tuple.state,
     };
 
     public override object Part1()
···
                 1 => B,
                 2 => C,
                 3 => D,
-                _ => null
+                _ => null,
             };
 
         public static State New(State from, char[] hall, int i, string hole) =>

Solutions/2021/Day25.cs

···
     public override void ProcessInput() =>
         _cucumbers = Input.Select(l => l.ToCharArray()).ToArray();
 
-    private static char[][]? DoStep(IReadOnlyList<char[]> arr)
+    private static char[][]? DoStep(char[][] arr)
     {
         var moved = false;
-        var h = arr.Count;
+        var h = arr.Length;
         var w = arr[0].Length;
         var result = new char[h][];
         for (var i = 0; i < h; i++)
···
             result2[i] = new char[w];
 
         for (var i = 0; i < h; i++)
-            for (var j = 0; j < w; j++)
-            {
-                if (result2[i][j] == 0) result2[i][j] = result[i][j];
-                if (result[i][j] != 'v') continue;
-                if (result[(i + 1) % h][j] != '.') continue;
-                result2[i][j] = '.';
-                result2[(i + 1) % h][j] = 'v';
-                moved = true;
-            }
+        for (var j = 0; j < w; j++)
+        {
+            if (result2[i][j] == 0) result2[i][j] = result[i][j];
+            if (result[i][j] != 'v') continue;
+            if (result[(i + 1) % h][j] != '.') continue;
+            result2[i][j] = '.';
+            result2[(i + 1) % h][j] = 'v';
+            moved = true;
+        }
 
         return moved ? result2 : null;
     }

Solutions/2022/Day11.cs

···
                         {
                             '*' => i => i * amount,
                             '+' => i => i + amount,
-                            _ => throw new ArgumentOutOfRangeException(line, "invalid operation")
+                            _ => throw new ArgumentOutOfRangeException(line, "invalid operation"),
                         };
                     else m.Operation = i => i * i;
                 }

Solutions/2022/Day15.cs

···
     public override object Part1()
     {
         var targetRow = UseTestInput ? 10 : 2_000_000;
-        
+
         var taken = _sensors!
             .Where(t => t.ClosestBeaconPosition.y == targetRow)
             .Select(t => t.ClosestBeaconPosition.x);
···
     {
         var size = UseTestInput ? 20 : 4_000_000;
         var limit = new SensorRange(0, size);
-        
+
         for (var y = 0; y <= size; y++)
         {
-            var covered = _sensors!.Select(s => s.GetSlice(y));
+            var y1 = y;
+            var covered = _sensors!.Select(s => s.GetSlice(y1));
             var gap = FindGap(covered, limit);
             if (gap is { } x)
                 return (x * 4_000_000L) + y;
         }
-        
+
         return 0;
     }
 

Solutions/2023/Day07.cs

···
 public class Day07() : Day(2023, 7, "Camel Cards")
 {
     private List<(Hand hand, long bid)> _hands = [];
-    public const string OrderedCards = "23456789TJQKA";
+    private const string OrderedCards = "23456789TJQKA";
 
     public override void ProcessInput() =>
         _hands = Input
···
 
     public override object Part2() =>
         _hands
-            .OrderBy(d => d.hand, new HandComparer(rank => rank == OrderedCards.IndexOf('J') ? 0 : rank + 1, useWilds: true))
+            .OrderBy(d => d.hand,
+                new HandComparer(rank => rank == OrderedCards.IndexOf('J') ? 0 : rank + 1, useWilds: true))
             .Select((hand, i) => hand.bid * (i + 1))
             .Sum();
 
-    public class HandComparer(Func<int, int> rankFunc, bool useWilds = false) : IComparer<Hand>
+    private class HandComparer(Func<int, int> rankFunc, bool useWilds = false) : IComparer<Hand>
     {
         public int Compare(Hand? x, Hand? y)
         {
···
     [Flags]
     public enum HandType
     {
-        HighCard, OnePair, TwoPair, ThreeOfAKind, FullHouse, FourOfAKind, FiveOfAKind
+        HighCard, OnePair, TwoPair, ThreeOfAKind, FullHouse, FourOfAKind, FiveOfAKind,
     }
 
     public class Hand(string value)
···
                 {
                     2 => HandType.FiveOfAKind,
                     1 => HandType.FourOfAKind,
-                    _ => pairs > 0 ? HandType.FullHouse : HandType.ThreeOfAKind
+                    _ => pairs > 0 ? HandType.FullHouse : HandType.ThreeOfAKind,
                 },
                 2 => pairs switch
                 {
···
                     {
                         1 => HandType.ThreeOfAKind,
                         2 => HandType.FourOfAKind,
-                        _ => wildCount > 2 ? HandType.FiveOfAKind : HandType.OnePair
+                        _ => wildCount > 2 ? HandType.FiveOfAKind : HandType.OnePair,
                     },
-                    _ => HandType.HighCard
+                    _ => HandType.HighCard,
                 },
                 _ => wildCount switch
                 {
···
                     3 => HandType.FourOfAKind,
                     4 => HandType.FiveOfAKind,
                     5 => HandType.FiveOfAKind,
-                    _ => HandType.HighCard
-                }
+                    _ => HandType.HighCard,
+                },
             };
         }
     }

Solutions/Extensions.cs

···
     {
         var array = list as T[] ?? list.ToArray();
         return array.Length == 1
-            ? new[] { array }
+            ? [array]
             : array.SelectMany(t => Permute(array.Where(x => !x!.Equals(t))), (v, p) => p.Prepend(v));
     }
 

Tests/Test2024.cs

···
 using Solutions._2024;
+
 namespace Tests;
 
 [TestClass]
···
     [DataRow(typeof(Day04), "2573", "1850")]
     public void CheckAllDays(Type dayType, string part1, string part2) =>
         Common.CheckDay(dayType, part1, part2);
-    
+
     [DataTestMethod]
     [DataRow(typeof(Day01), "11", "31")]
     [DataRow(typeof(Day02), "2", "4")]