Implemented Backtracking (brute-force) solving strategy + tests.

Author: kurtanr

README.md

@@ -28,3 +28,4 @@ Out of the well known [Sudoku Solving Techniques](https://sudoku9x9.com/sudoku_s
 *   Hidden Triple
 *   Hidden Quad
 *   X-Wing
+*   Backtracking (brute-force)

SimpleSudokuSolver.Tests/Strategy/BacktrackingTests.cs

@@ -0,0 +1,31 @@
+using NUnit.Framework;
+using SimpleSudokuSolver.Strategy;
+
+namespace SimpleSudokuSolver.Tests.Strategy
+{
+  public class BacktrackingTests : BaseStrategyTest
+  {
+    private readonly ISudokuSolver solver = new DefaultSolver(new HiddenSingle(), new Backtracking());
+
+    [Test]
+    public void BacktrackingTest1()
+    {
+      var sudoku = new[,]
+      {
+        // From: https://en.wikipedia.org/wiki/Sudoku_solving_algorithms#Backtracking
+        { 0,0,0,0,0,0,0,0,0 },
+        { 0,0,0,0,0,3,0,8,5 },
+        { 0,0,1,0,2,0,0,0,0 },
+        { 0,0,0,5,0,7,0,0,0 },
+        { 0,0,4,0,0,0,1,0,0 },
+        { 0,9,0,0,0,0,0,0,0 },
+        { 5,0,0,0,0,0,0,7,3 },
+        { 0,0,2,0,1,0,0,0,0 },
+        { 0,0,0,0,4,0,0,0,9 }
+      };
+
+      var sudokuPuzzle = solver.Solve(sudoku);
+      Assert.That(sudokuPuzzle.IsSolved(), Is.True);
+    }
+  }
+}

SimpleSudokuSolver/DefaultSolver.cs

@@ -41,7 +41,8 @@ public DefaultSolver(params ISudokuSolverStrategy[] strategies)
           new HiddenPair(),
           new HiddenTriple(),
           new HiddenQuad(),
-          new XWing()
+          new XWing(),
+          new Backtracking()
         };
       }
     }

SimpleSudokuSolver/Strategy/Backtracking.cs

@@ -0,0 +1,95 @@
+using SimpleSudokuSolver.Model;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimpleSudokuSolver.Strategy
+{
+  /// <summary>
+  /// Implements brute-force search to find a solution for the puzzle.
+  /// </remarks>
+  /// <remarks>
+  /// See also:
+  /// - https://en.wikipedia.org/wiki/Sudoku_solving_algorithms#Backtracking
+  /// </remarks>
+  public class Backtracking : ISudokuSolverStrategy
+  {
+    public string StrategyName => "Backtracking (brute-force)";
+
+    public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
+    {
+      var sudokuPuzzleCopy = GetDeepCopy(sudokuPuzzle);
+      bool isSolved = SolvePuzzle(sudokuPuzzleCopy);
+      if (!isSolved)
+        return null;
+
+      // find first cell with no value
+      var cellWithNoValue = sudokuPuzzle.Cells.OfType<Cell>().First(x => !x.HasValue);
+
+      // return value of that cell
+      return new SingleStepSolution(cellWithNoValue.RowIndex, cellWithNoValue.ColumnIndex,
+        sudokuPuzzleCopy.Cells[cellWithNoValue.RowIndex, cellWithNoValue.ColumnIndex].Value, StrategyName);
+    }
+
+    private SudokuPuzzle GetDeepCopy(SudokuPuzzle sudokuPuzzle)
+    {
+      var copy = new SudokuPuzzle(sudokuPuzzle.ToIntArray());
+      foreach (var cell in sudokuPuzzle.Cells)
+      {
+        if (!cell.HasValue)
+        {
+          var cellInCopy = copy.Cells[cell.RowIndex, cell.ColumnIndex];
+          cellInCopy.CanBe.Clear();
+          cellInCopy.CanBe.AddRange(cell.CanBe);
+        }
+      }
+
+      return copy;
+    }
+
+    private bool SolvePuzzle(SudokuPuzzle sudokuPuzzle)
+    {
+      if (sudokuPuzzle.IsSolved())
+        return true;
+
+      var unsolvedCells = sudokuPuzzle.Cells.OfType<Cell>().Where(x => !x.HasValue).OrderBy(x => x.CanBe.Count).ToArray();
+
+      // for each cell
+      foreach (var cell in unsolvedCells)
+      {
+        var row = sudokuPuzzle.Rows[cell.RowIndex];
+        var column = sudokuPuzzle.Columns[cell.ColumnIndex];
+        var blockIndex = sudokuPuzzle.GetBlockIndex(cell);
+        var block = sudokuPuzzle.Blocks[blockIndex.RowIndex, blockIndex.ColumnIndex];
+
+        var potentialCellValues = new List<int>(cell.CanBe);
+
+        // for each potential value
+        foreach (var value in potentialCellValues)
+        {
+          var usedInRow = row.Cells.Count(x => x.Value == value) > 0;
+          var usedInColumn = column.Cells.Count(x => x.Value == value) > 0;
+          var usedInBlock = block.Cells.OfType<Cell>().Count(x => x.Value == value) > 0;
+
+          // if potential value already used in row, column or block, skip it
+          if (usedInRow || usedInColumn || usedInBlock)
+            continue;
+
+          // try to recursively solve the puzzle
+          cell.Value = value;
+          if (SolvePuzzle(sudokuPuzzle))
+          {
+            return true;
+          }
+          // if puzzle cannot be solve, revert the value
+          else
+          {
+            cell.Value = 0;
+            cell.CanBe.AddRange(potentialCellValues);
+          }
+        }
+        return false;
+      }
+      return false;
+    }
+  }
+}