Code cleanup, improving code coverage of SimpleSudokuSolver.Strategy namespace.

Author: kurtanr

SimpleSudokuSolver.Tests/DefaultSolverTests.cs

@@ -0,0 +1,49 @@
+using NUnit.Framework;
+using SimpleSudokuSolver.Strategy;
+using System.Linq;
+
+namespace SimpleSudokuSolver.Tests
+{
+  [TestFixture]
+  public class DefaultSolverTests
+  {
+    private readonly int[,] _sudoku = new int[,]
+    {
+      { 0,0,0,0,0,0,0,0,3 },
+      { 3,0,0,0,0,0,0,0,9 },
+      { 0,0,0,0,9,3,1,4,2 },
+      { 0,0,0,8,6,9,3,2,4 },
+      { 0,0,0,3,1,2,8,5,7 },
+      { 2,3,8,4,7,5,9,6,1 },
+      { 0,0,4,7,5,8,2,3,6 },
+      { 5,6,7,2,3,1,4,9,8 },
+      { 8,2,3,9,4,6,7,1,5 }
+    };
+
+    [Test]
+    public void DefaultSolverWithDefaultStrategies_CanSolvePuzzle_Test()
+    {
+      var defaultSolver = new DefaultSolver();
+      var sudokuPuzzle = defaultSolver.Solve(_sudoku);
+      Assert.That(sudokuPuzzle.Cells[0, 0].Value, Is.EqualTo(4));
+    }
+
+    [Test]
+    public void DefaultSolverWithOnlyEliminationStrategies_CannotSolvePuzzle_Test()
+    {
+      var defaultSolver = new DefaultSolver(new BasicElimination());
+      var sudokuPuzzle = defaultSolver.Solve(_sudoku);
+      Assert.That(sudokuPuzzle.Cells[0, 0].Value, Is.EqualTo(0));
+      Assert.That(sudokuPuzzle.Cells[0, 0].CanBe.Count, Is.EqualTo(5));
+    }
+
+    [Test]
+    public void SolveSingleStepForSolvedPuzle_ReturnsNull_Test()
+    {
+      var defaultSolver = new DefaultSolver();
+      var sudokuPuzzle = defaultSolver.Solve(_sudoku);
+      Assert.That(sudokuPuzzle.IsSolved);
+      Assert.That(defaultSolver.SolveSingleStep(sudokuPuzzle), Is.Null);
+    }
+  }
+}

SimpleSudokuSolver.Tests/Strategy/LockedCandidatesTests.cs

@@ -53,8 +53,8 @@ public void LockedCandidatesInRowTest()
         { 0,0,0,0,0,0,0,0,0 }
       };
 
-      var solver = new DefaultSolver();
-      var sudokuPuzzle = solver.Solve(sudoku);
+      var sudokuPuzzle = new SudokuPuzzle(sudoku);
+      SolveUsingStrategy(sudokuPuzzle, _strategy);
 
       CollectionAssert.DoesNotContain(sudokuPuzzle.Cells[0, 3].CanBe, 3);
       CollectionAssert.DoesNotContain(sudokuPuzzle.Cells[0, 4].CanBe, 3);

SimpleSudokuSolver/DefaultSolver.cs

@@ -1,6 +1,5 @@
 using SimpleSudokuSolver.Model;
 using SimpleSudokuSolver.Strategy;
-using System.Collections.Generic;
 
 namespace SimpleSudokuSolver
 {
@@ -10,7 +9,36 @@ namespace SimpleSudokuSolver
   public partial class DefaultSolver : ISudokuSolver
   {
     private SudokuPuzzle _sudokuPuzzleAfterFailedSolveSingleStep;
-    private BasicElimination _basicElimination = new BasicElimination();
+    private readonly BasicElimination _basicElimination = new BasicElimination();
+    private readonly ISudokuSolverStrategy[] _strategies;
+
+    /// <summary>
+    /// Constructor.
+    /// </summary>
+    /// <param name="strategies">
+    /// Strategies used to try and solve the puzzle.
+    /// If no strategies are provided, a default set of strategies is used.
+    /// </param>
+    public DefaultSolver(params ISudokuSolverStrategy[] strategies)
+    {
+      if (strategies.Length > 0)
+      {
+        _strategies = strategies;
+      }
+      else
+      {
+        _strategies = new ISudokuSolverStrategy[]
+        {
+          // Ordered from the simplest to the most complex
+          new SingleInCells(),
+          new HiddenSingle(),
+          new NakedSingle(),
+          new LockedCandidates(),
+          new NakedPair(),
+          new NakedTriple()
+        };
+      }
+    }
 
     /// <inheritdoc />
     public SudokuPuzzle Solve(int[,] sudoku)
@@ -29,6 +57,7 @@ public SudokuPuzzle Solve(int[,] sudoku)
         else
         {
           sudokuPuzzle.ApplySingleStepSolution(solution);
+          _sudokuPuzzleAfterFailedSolveSingleStep = sudokuPuzzle;
         }
       }
 
@@ -41,29 +70,17 @@ public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
       if (sudokuPuzzle.IsSolved())
         return null;
 
-      var solvingTechniques = new ISudokuSolverStrategy[]
-      {
-        // Ordered from the simples to the most complex
-        new SingleInCells(),
-        new HiddenSingle(),
-        new NakedSingle(),
-        new LockedCandidates(),
-        new NakedPair(),
-        new NakedTriple()
-      };
-
-      foreach (var technique in solvingTechniques)
+      foreach (var strategy in _strategies)
       {
         var elimination = _basicElimination.SolveSingleStep(sudokuPuzzle);
         if (elimination != null)
           return elimination;
 
-        var solution = technique.SolveSingleStep(sudokuPuzzle);
+        var solution = strategy.SolveSingleStep(sudokuPuzzle);
         if (solution != null)
           return solution;
       }
 
-      _sudokuPuzzleAfterFailedSolveSingleStep = sudokuPuzzle;
       return null;
     }
   }

SimpleSudokuSolver/Model/Formatter.cs

@@ -82,12 +82,7 @@ internal static string PuzzleToString(SudokuPuzzle sudokuPuzzle)
         for (int j = 0; j < columnCount; j++)
         {
           var prefix = (j == 0 ? "" : " ");
-
-          if (sudokuPuzzle.Cells[i, j] != null)
-          {
-            sb.Append($"{prefix}{sudokuPuzzle.Cells[i, j].Value}");
-          }
-          else sb.Append($"{prefix} ");
+          sb.Append($"{prefix}{sudokuPuzzle.Cells[i, j].Value}");
 
         }
         sb.Append(Environment.NewLine);

SimpleSudokuSolver/Strategy/NakedSingle.cs

@@ -1,15 +1,12 @@
 using SimpleSudokuSolver.Model;
-using System.Collections.Generic;
 using System.Linq;
 
 namespace SimpleSudokuSolver.Strategy
 {
   /// <summary>
   /// Strategy runs after <see cref="BasicElimination"/> when we have already reduced number of candidates in each empty cell.
-  /// For each row, column and block of the puzzle, strategy:
-  /// - iterates through all the empty cells of that row, column and block
-  /// - looks for a case where a cell can contain only one value
-  ///   (cell's list of candidates contains only one value)
+  /// Strategy iterates through all the empty cells of the puzzle and looks for cells that can contain only one value
+  /// (cell's list of candidates contains only one value).
   /// </summary>
   /// <remarks>
   /// See also:
@@ -22,33 +19,7 @@ public class NakedSingle : ISudokuSolverStrategy
 
     public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
     {
-      foreach (var row in sudokuPuzzle.Rows)
-      {
-        var rowSolution = GetNakedSingle(sudokuPuzzle, row.Cells);
-        if (rowSolution != null)
-          return rowSolution;
-      }
-
-      foreach (var column in sudokuPuzzle.Columns)
-      {
-        var columnSolution = GetNakedSingle(sudokuPuzzle, column.Cells);
-        if (columnSolution != null)
-          return columnSolution;
-      }
-
-      foreach (var block in sudokuPuzzle.Blocks)
-      {
-        var blockSolution = GetNakedSingle(sudokuPuzzle, block.Cells.OfType<Cell>());
-        if (blockSolution != null)
-          return blockSolution;
-      }
-
-      return null;
-    }
-
-    private SingleStepSolution GetNakedSingle(SudokuPuzzle sudokuPuzzle, IEnumerable<Cell> cells)
-    {
-      var cellsWithNoValue = cells.Where(x => !x.HasValue).ToArray();
+      var cellsWithNoValue = sudokuPuzzle.Cells.OfType<Cell>().Where(x => !x.HasValue).ToArray();
 
       // if cell can contain only one value, then it must contain that value
       foreach (var cell in cellsWithNoValue)

SimpleSudokuSolver/Strategy/NakedTriple.cs

@@ -60,14 +60,10 @@ public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
         for (int j = i + 1; j < nakedTripleCandidates.Length - 1; j++)
         {
           Cell second = nakedTripleCandidates[j];
-          if (first == second)
-            continue;
 
           for (int k = j + 1; k < nakedTripleCandidates.Length; k++)
           {
             Cell third = nakedTripleCandidates[k];
-            if (first == third || second == third)
-              continue;
 
             var distinctPotentialCellValuesInCandidates = GetDistinctPotentialCellValuesInCandidates(
               first.CanBe, second.CanBe, third.CanBe);
@@ -102,11 +98,8 @@ public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
         {
           foreach (var finalItem in finalItems)
           {
-            if (cellWithNoValue.CanBe.Contains(finalItem))
-            {
-              var (RowIndex, ColumnIndex) = sudokuPuzzle.GetCellIndex(cellWithNoValue);
-              eliminations.Add(new SingleStepSolution.Candidate(RowIndex, ColumnIndex, finalItem));
-            }
+            var (RowIndex, ColumnIndex) = sudokuPuzzle.GetCellIndex(cellWithNoValue);
+            eliminations.Add(new SingleStepSolution.Candidate(RowIndex, ColumnIndex, finalItem));
           }
         }
       }

SimpleSudokuSolver/Strategy/SingleInCells.cs

@@ -9,35 +9,38 @@ namespace SimpleSudokuSolver.Strategy
   /// </summary>
   public class SingleInCells : ISudokuSolverStrategy
   {
-    public string StrategyName => "Single in Cells";
+    public string StrategyName { get; private set; }
 
     public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
     {
       foreach (var row in sudokuPuzzle.Rows)
       {
-        var rowSolution = GetSingleInCells(sudokuPuzzle, row.Cells, "Single in Row");
+        StrategyName = "Single in Row";
+        var rowSolution = GetSingleInCells(sudokuPuzzle, row.Cells);
         if (rowSolution != null)
           return rowSolution;
       }
 
       foreach (var column in sudokuPuzzle.Columns)
       {
-        var columnSolution = GetSingleInCells(sudokuPuzzle, column.Cells, "Single in Column");
+        StrategyName = "Single in Column";
+        var columnSolution = GetSingleInCells(sudokuPuzzle, column.Cells);
         if (columnSolution != null)
           return columnSolution;
       }
 
       foreach (var block in sudokuPuzzle.Blocks)
       {
-        var blockSolution = GetSingleInCells(sudokuPuzzle, block.Cells.OfType<Cell>(), "Single in Block");
+        StrategyName = "Single in Block";
+        var blockSolution = GetSingleInCells(sudokuPuzzle, block.Cells.OfType<Cell>());
         if (blockSolution != null)
           return blockSolution;
       }
 
       return null;
     }
 
-    private SingleStepSolution GetSingleInCells(SudokuPuzzle sudokuPuzzle, IEnumerable<Cell> cells, string strategyName)
+    private SingleStepSolution GetSingleInCells(SudokuPuzzle sudokuPuzzle, IEnumerable<Cell> cells)
     {
       var cellsWithNoValue = cells.Where(x => !x.HasValue).ToArray();
 
@@ -48,7 +51,7 @@ private SingleStepSolution GetSingleInCells(SudokuPuzzle sudokuPuzzle, IEnumerab
         var value = sudokuPuzzle.PossibleCellValues.Except(knownValues).Single();
 
         var (RowIndex, ColumnIndex) = sudokuPuzzle.GetCellIndex(cellsWithNoValue[0]);
-        return new SingleStepSolution(RowIndex, ColumnIndex, value, strategyName);
+        return new SingleStepSolution(RowIndex, ColumnIndex, value, StrategyName);
       }
 
       return null;