Gen 2

src/Sudoku/Extensions/IntArrayExtensions.cs

@@ -2,6 +2,11 @@ namespace Sudoku.Extensions;
 
 public static class IntArrayExtensions
 {
+    public static bool IsValidSudoku(this int[] puzzle)
+    {
+        return SpanIntExtensions.IsValidSudoku(puzzle);
+    }
+
     public static void DumpToConsole(this int[] array, int left = -1, int top = -1)
     {
         SetPosition(left, top, 0);

src/Sudoku/Extensions/SpanIntExtensions.cs

@@ -20,14 +20,14 @@ public static bool IsValidSudoku(this Span<int> puzzle)
 
             for (var x = 0; x < 9; x++)
             {
-                if (puzzle[x + y * 9] != 0)
+                if (puzzle[x + y * 9] > 0)
                 {
                     uniqueRow.Add(puzzle[x + y * 9]);
 
                     countRow++;
                 }
 
-                if (puzzle[y + x * 9] != 0)
+                if (puzzle[y + x * 9] > 0)
                 {
                     uniqueColumn.Add(puzzle[y + x * 9]);
 
@@ -55,7 +55,7 @@ public static bool IsValidSudoku(this Span<int> puzzle)
                 {
                     for (var y = 0; y < 3; y++)
                     {
-                        if (puzzle[(yO + y) * 9 + xO + x] != 0)
+                        if (puzzle[(yO + y) * 9 + xO + x] > 0)
                         {
                             uniqueBox.Add(puzzle[(yO + y) * 9 + xO + x]);
 

src/Sudoku/Generator.cs

@@ -4,97 +4,81 @@ namespace Sudoku;
 
 public class Generator
 {
+    private readonly List<int> _positions = new();
+
     private readonly List<int>[] _candidates = new List<int>[81];
 
+    private int[] _puzzle;
+
     private readonly Random _rng = Random.Shared;
 
     private readonly Solver _solver = new(HistoryType.None, SolveMethod.FindUnique);
 
     public int[] Generate(int cluesToLeave = 30)
     {
-        var puzzle = new int[81];
+        _puzzle = new int[81];
 
-        InitialiseCandidates();
-
-        CreateSolvedPuzzle(puzzle);
-
-        RemoveCells(puzzle, 81 - cluesToLeave);
-
-        return puzzle;
+        GeneratePositions(cluesToLeave);
+
+        FillPositions(cluesToLeave);
+
+        return _puzzle;
     }
 
-    private void RemoveCells(int[] puzzle, int cellsToRemove)
+    private void GeneratePositions(int cluesToLeave)
     {
-        var copy = new int[81];
-
-        for (var i = 0; i < 81; i++)
-        {
-            copy[i] = puzzle[i];
-        }
-
-        var filledCells = new List<int>();
-
-        for (var i = 0; i < 81; i++)
-        {
-            filledCells.Add(i);
-        }
-
-        while (true)
+        _positions.Clear();
+
+        for (var i = 0; i < cluesToLeave; i++)
         {
-            for (var i = 0; i < cellsToRemove; i++)
-            {
-                var cell = filledCells[_rng.Next(filledCells.Count)];
-
-                filledCells.Remove(cell);
-
-                puzzle[cell] = 0;
-            }
+            var position = _rng.Next(81);
 
-            if (_solver.Solve(puzzle).Solved)
+            while (_puzzle[position] != 0)
             {
-                return;
+                position = _rng.Next(81);
             }
 
-            for (var i = 0; i < 81; i++)
-            {
-                if (puzzle[i] == 0)
-                {
-                    filledCells.Add(i);
-
-                    puzzle[i] = copy[i];
-                }
-            }
+            _puzzle[position] = -1;
+
+            _positions.Add(position);
         }
     }
 
-    private bool CreateSolvedPuzzle(Span<int> puzzle, int cell = 0)
+    private bool FillPositions(int cluesToLeave, int position = 0)
     {
-        while (_candidates[cell].Count > 0)
-        {
-            var candidateIndex = _rng.Next(_candidates[cell].Count);
+        InitialiseCandidates();
 
-            var candidate = _candidates[cell][candidateIndex];
+        var cell = _positions[position];
 
-            _candidates[cell].RemoveAt(candidateIndex);
+        while (_candidates[cell].Count > 0)
+        {
+            var index = _rng.Next(_candidates[cell].Count);
 
-            puzzle[cell] = candidate;
+            _puzzle[cell] = _candidates[cell][index];
+
+            _candidates[cell].RemoveAt(index);
 
-            if (puzzle.IsValidSudoku())
+            if (_puzzle.IsValidSudoku())
             {
-                if (cell == 80)
+                if (position == cluesToLeave - 1)
                 {
-                    return true;
+                    return _solver.Solve(_puzzle).Solved;
                 }
 
-                return CreateSolvedPuzzle(puzzle, cell + 1);
+                return FillPositions(cluesToLeave, position + 1);
             }
         }
 
-        puzzle[cell] = 0;
+        if (position == 0)
+        {
+            return false;
+        }
+
+        _puzzle[cell] = -1;
 
         _candidates[cell] = [1, 2, 3, 4, 5, 6, 7, 8, 9];
 
-        return CreateSolvedPuzzle(puzzle, cell - 1);
+        return FillPositions(cluesToLeave, position - 1);
     }
 
     private void InitialiseCandidates()