Cell class changes:

- removed constructor Cell(int value)
- added constructor Cell(int value, int rowIndex, int columnIndex)
- added properties RowIndex and ColumnIndex
- changed ToString method to also output RowIndex and ColumnIndex

SudokuPuzzle class - removed GetCellIndex method.

Author: kurtanr

SimpleSudokuSolver.Tests/Model/BlockTests.cs

@@ -43,9 +43,9 @@ public void ToStringTest()
       var toString = block.ToString();
       Assert.That(toString, Is.EqualTo($"     {newLine}     {newLine}     {newLine}"));
 
-      block.Cells[0, 0] = new Cell(1);
-      block.Cells[1, 1] = new Cell(5);
-      block.Cells[2, 2] = new Cell(0);
+      block.Cells[0, 0] = new Cell(1, 0, 0);
+      block.Cells[1, 1] = new Cell(5, 1, 1);
+      block.Cells[2, 2] = new Cell(0, 2, 2);
       toString = block.ToString();
       Assert.That(toString, Is.EqualTo($"1    {newLine}  5  {newLine}    0{newLine}"));
     }

SimpleSudokuSolver.Tests/Model/CellTests.cs

@@ -10,7 +10,7 @@ public class CellTests
     [Test]
     public void EmptyCellTest()
     {
-      var emptyCell = new Cell(0);
+      var emptyCell = new Cell(0, 0, 0);
       Assert.That(emptyCell.Value, Is.EqualTo(0));
       Assert.That(emptyCell.HasValue, Is.False);
       Assert.That(emptyCell.CanBe, Is.Empty);
@@ -19,29 +19,31 @@ public void EmptyCellTest()
     [Test]
     public void ValidCellTest()
     {
-      var cell = new Cell(9);
+      var cell = new Cell(9, 1, 2);
       Assert.That(cell.Value, Is.EqualTo(9));
       Assert.That(cell.HasValue, Is.True);
       Assert.That(cell.CanBe, Is.Empty);
+      Assert.That(cell.RowIndex, Is.EqualTo(1));
+      Assert.That(cell.ColumnIndex, Is.EqualTo(2));
     }
 
     [Test]
     public void InvalidCellTest()
     {
-      Assert.That(() => new Cell(-1), Throws.InstanceOf<ArgumentException>());
-      Assert.That(() => new Cell(10), Throws.InstanceOf<ArgumentException>());
+      Assert.That(() => new Cell(-1, 0, 0), Throws.InstanceOf<ArgumentException>());
+      Assert.That(() => new Cell(10, 0, 0), Throws.InstanceOf<ArgumentException>());
     }
 
     [Test]
     public void ToStringTest()
     {
-      var cell = new Cell(5);
+      var cell = new Cell(5, 1, 2);
       var toString = cell.ToString();
-      Assert.That(toString, Is.EqualTo("5"));
+      Assert.That(toString, Is.EqualTo("[1,2]=5"));
 
-      cell = new Cell(0);
+      cell = new Cell(0, 3, 4);
       toString = cell.ToString();
-      Assert.That(toString, Is.EqualTo("0"));
+      Assert.That(toString, Is.EqualTo("[3,4]=0"));
     }
   }
 }

SimpleSudokuSolver.Tests/Model/ColumnTests.cs

@@ -36,9 +36,9 @@ public void ToStringTest()
       var toString = column.ToString();
       Assert.That(toString, Is.EqualTo($" {newLine} {newLine} {newLine} {newLine} {newLine} {newLine} {newLine} {newLine} {newLine}"));
 
-      column.Cells[0] = new Cell(1);
-      column.Cells[3] = new Cell(4);
-      column.Cells[8] = new Cell(0);
+      column.Cells[0] = new Cell(1, 0, 0);
+      column.Cells[3] = new Cell(4, 3, 0);
+      column.Cells[8] = new Cell(0, 8, 0);
       toString = column.ToString();
       Assert.That(toString, Is.EqualTo($"1{newLine} {newLine} {newLine}4{newLine} {newLine} {newLine} {newLine} {newLine}0{newLine}"));
     }

SimpleSudokuSolver.Tests/Model/RowTests.cs

@@ -34,9 +34,9 @@ public void ToStringTest()
       var toString = row.ToString();
       Assert.That(toString, Is.EqualTo(new string(' ', 17)));
 
-      row.Cells[0] = new Cell(1);
-      row.Cells[3] = new Cell(4);
-      row.Cells[8] = new Cell(0);
+      row.Cells[0] = new Cell(1, 0, 0);
+      row.Cells[3] = new Cell(4, 0, 3);
+      row.Cells[8] = new Cell(0, 0, 8);
       toString = row.ToString();
       Assert.That(toString, Is.EqualTo("1     4         0"));
     }

SimpleSudokuSolver.Tests/Model/SudokuPuzzleTests.cs

@@ -128,32 +128,10 @@ public void GetCellIndexTest()
     {
       var sudokuPuzzle = new SudokuPuzzle(_sudoku);
       var cell = sudokuPuzzle.Cells[4, 7];
-      Assert.That(cell.Value, Is.EqualTo(5));
-
-      var cellIndex = sudokuPuzzle.GetCellIndex(cell);
-
-      Assert.That(cellIndex.RowIndex, Is.EqualTo(4));
-      Assert.That(cellIndex.ColumnIndex, Is.EqualTo(7));
-    }
-
-    [Test]
-    public void GetCellIndexForNullTest()
-    {
-      var sudokuPuzzle = new SudokuPuzzle(_sudoku);
-      var cellIndex = sudokuPuzzle.GetCellIndex(null);
 
-      Assert.That(cellIndex.RowIndex, Is.EqualTo(-1));
-      Assert.That(cellIndex.ColumnIndex, Is.EqualTo(-1));
-    }
-
-    [Test]
-    public void GetCellIndexForNonExistingCellTest()
-    {
-      var sudokuPuzzle = new SudokuPuzzle(_sudoku);
-      var cellIndex = sudokuPuzzle.GetCellIndex(new Cell(5));
-
-      Assert.That(cellIndex.RowIndex, Is.EqualTo(-1));
-      Assert.That(cellIndex.ColumnIndex, Is.EqualTo(-1));
+      Assert.That(cell.Value, Is.EqualTo(5));
+      Assert.That(cell.RowIndex, Is.EqualTo(4));
+      Assert.That(cell.ColumnIndex, Is.EqualTo(7));
     }
 
     [Test]
@@ -183,8 +161,9 @@ public void GetBlockIndexForNullTest()
     public void GetBlockIndexForNonExistingCellTest()
     {
       var sudokuPuzzle = new SudokuPuzzle(_sudoku);
-      var cellIndex = sudokuPuzzle.GetBlockIndex(new Cell(5));
+      var cellIndex = sudokuPuzzle.GetBlockIndex(new Cell(0, 0, 0));
 
+      // Cell equality is compared by reference (Object.ReferenceEquals)
       Assert.That(cellIndex.RowIndex, Is.EqualTo(-1));
       Assert.That(cellIndex.ColumnIndex, Is.EqualTo(-1));
     }

SimpleSudokuSolver.UI/SudokuBoard.xaml.cs

@@ -91,8 +91,7 @@ private void OnKeyDown(object sender, KeyEventArgs e)
         return;
 
       // if value is not correct or solver cannot solve the puzzle (so we do not know if the value is correct), we do not allow it
-      var cellIndex = SudokuPuzzle.GetCellIndex(_activeCell.Cell);
-      var solvedValue = SolvedSudokuPuzzle.Cells[cellIndex.RowIndex, cellIndex.ColumnIndex].Value;
+      var solvedValue = SolvedSudokuPuzzle.Cells[_activeCell.Cell.RowIndex, _activeCell.Cell.ColumnIndex].Value;
 
       var mainViewModel = (MainViewModel)DataContext;
       if (solvedValue == 0)
@@ -102,11 +101,11 @@ private void OnKeyDown(object sender, KeyEventArgs e)
       }
       if (enteredValue != solvedValue)
       {
-        mainViewModel.AppendMessage($"Row {cellIndex.RowIndex + 1} Column {cellIndex.ColumnIndex + 1} Value {enteredValue} [Wrong value entered by user]");
+        mainViewModel.AppendMessage($"Row {_activeCell.Cell.RowIndex + 1} Column {_activeCell.Cell.ColumnIndex + 1} Value {enteredValue} [Wrong value entered by user]");
         return;
       }
 
-      var solution = new SingleStepSolution(cellIndex.RowIndex, cellIndex.ColumnIndex, enteredValue, "Entered by user");
+      var solution = new SingleStepSolution(_activeCell.Cell.RowIndex, _activeCell.Cell.ColumnIndex, enteredValue, "Entered by user");
       SudokuPuzzle.ApplySingleStepSolution(solution);
       _activeCell.NotifyCellValueChanged();
       SetSelection(_activeCell);
@@ -228,13 +227,11 @@ private void ChangeActiveCell(int rowOffset, int columnOffset)
       }
       else
       {
-        var activeCellIndex = SudokuPuzzle.GetCellIndex(_activeCell.Cell);
-
-        var proposedRowIndex = activeCellIndex.RowIndex + rowOffset;
+        var proposedRowIndex = _activeCell.Cell.RowIndex + rowOffset;
         var rowIndex = (proposedRowIndex < 0) ? maxIndex :
           proposedRowIndex % SudokuPuzzle.NumberOfRowsOrColumnsInPuzzle;
 
-        var proposedColumnIndex = activeCellIndex.ColumnIndex + columnOffset;
+        var proposedColumnIndex = _activeCell.Cell.ColumnIndex + columnOffset;
         var columnIndex = (proposedColumnIndex < 0) ? maxIndex :
           proposedColumnIndex % SudokuPuzzle.NumberOfRowsOrColumnsInPuzzle;
 
@@ -280,15 +277,12 @@ private void SetSelection(CellViewModel selectedCellViewModel)
       if (SudokuPuzzle == null)
         return;
 
-      var selectedCellIndex = SudokuPuzzle.GetCellIndex(selectedCellViewModel.Cell);
-
       foreach (var cellViewModel in _cellViewModels)
       {
-        var index = SudokuPuzzle.GetCellIndex(cellViewModel.Cell);
         var hasValue = cellViewModel.Cell.HasValue;
         var hasSameValue = cellViewModel.Cell.Value == selectedCellViewModel.Cell.Value;
-        var isInSameRow = selectedCellIndex.RowIndex == index.RowIndex;
-        var isInSameColumn = selectedCellIndex.ColumnIndex == index.ColumnIndex;
+        var isInSameRow = selectedCellViewModel.Cell.RowIndex == cellViewModel.Cell.RowIndex;
+        var isInSameColumn = selectedCellViewModel.Cell.ColumnIndex == cellViewModel.Cell.ColumnIndex;
 
         if (isInSameRow || isInSameColumn || (hasValue && hasSameValue))
         {

SimpleSudokuSolver/Model/Cell.cs

@@ -25,6 +25,16 @@ public int Value
       }
     }
 
+    /// <summary>
+    /// Zero-based row index of cell in the puzzle.
+    /// </summary>
+    public int RowIndex { get; }
+
+    /// <summary>
+    /// Zero-based column index of cell in the puzzle.
+    /// </summary>
+    public int ColumnIndex { get; }
+
     /// <summary>
     /// List of values which are allowed in this cell.
     /// Empty if cell has a value.
@@ -33,7 +43,12 @@ public int Value
 
     public bool HasValue => _value > 0;
 
-    public Cell(int value) => Value = value;
+    public Cell(int value, int rowIndex, int columnIndex)
+    {
+      Value = value;
+      RowIndex = rowIndex;
+      ColumnIndex = columnIndex;
+    }
 
     public override string ToString() => Formatter.CellToString(this);
   }

SimpleSudokuSolver/Model/Formatter.cs

@@ -10,7 +10,7 @@ internal static class Formatter
   {
     internal static string CellToString(Cell cell)
     {
-      return cell.Value.ToString();
+      return $"[{cell.RowIndex},{cell.ColumnIndex}]={cell.Value}";
     }
 
     internal static string BlockToString(Block block)

SimpleSudokuSolver/Model/SudokuPuzzle.cs

@@ -46,7 +46,7 @@ public SudokuPuzzle(int[,] sudoku)
             Columns[j] = new Column(j, NumberOfRowsOrColumnsInPuzzle);
           }
 
-          var cell = new Cell(sudoku[i, j]);
+          var cell = new Cell(sudoku[i, j], i, j);
           if (!cell.HasValue)
           {
             cell.CanBe.AddRange(PossibleCellValues);
@@ -156,27 +156,6 @@ public SingleStepSolution UndoLastSingleStepSolution()
       return result;
     }
 
-    /// <summary>
-    /// Returns zero-based row and column index of the <paramref name="cell"/>.
-    /// Returns -1 for both row and column index if <paramref name="cell"/> is null or not part of the puzzle.
-    /// </summary>
-    public (int RowIndex, int ColumnIndex) GetCellIndex(Cell cell)
-    {
-      if (cell == null)
-        return (-1, -1);
-
-      for (int i = 0; i < NumberOfRowsOrColumnsInPuzzle; i++)
-      {
-        for (int j = 0; j < NumberOfRowsOrColumnsInPuzzle; j++)
-        {
-          if (Cells[i, j] == cell)
-            return (i, j);
-        }
-      }
-
-      return (-1, -1);
-    }
-
     /// <summary>
     /// Returns zero-based row and column index of the block which contains the <paramref name="cell"/>.
     /// Returns -1 for both row and column index if <paramref name="cell"/> is null or not part of the puzzle.

SimpleSudokuSolver/Strategy/BasicElimination.cs

@@ -19,27 +19,27 @@ public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
       foreach (var row in sudokuPuzzle.Rows)
       {
         var cells = row.Cells;
-        eliminations.AddRange(GetEliminations(cells, sudokuPuzzle));
+        eliminations.AddRange(GetEliminations(cells));
       }
 
       foreach (var column in sudokuPuzzle.Columns)
       {
         var cells = column.Cells;
-        eliminations.AddRange(GetEliminations(cells, sudokuPuzzle));
+        eliminations.AddRange(GetEliminations(cells));
       }
 
       foreach (var block in sudokuPuzzle.Blocks)
       {
         var cells = block.Cells.OfType<Cell>().ToArray();
-        eliminations.AddRange(GetEliminations(cells, sudokuPuzzle));
+        eliminations.AddRange(GetEliminations(cells));
       }
 
       return eliminations.Count > 0 ?
         new SingleStepSolution(eliminations.Distinct().ToArray(), StrategyName) :
         null;
     }
 
-    private IEnumerable<SingleStepSolution.Candidate> GetEliminations(Cell[] cells, SudokuPuzzle sudokuPuzzle)
+    private IEnumerable<SingleStepSolution.Candidate> GetEliminations(Cell[] cells)
     {
       var cellsWithValue = cells.Where(x => x.HasValue).ToArray();
       var cellsWithNoValue = cells.Where(x => !x.HasValue).ToArray();
@@ -52,8 +52,7 @@ public SingleStepSolution SolveSingleStep(SudokuPuzzle sudokuPuzzle)
         {
           if (cellWithNoValue.CanBe.Contains(cellWithValue.Value))
           {
-            var (RowIndex, ColumnIndex) = sudokuPuzzle.GetCellIndex(cellWithNoValue);
-            eliminations.Add(new SingleStepSolution.Candidate(RowIndex, ColumnIndex, cellWithValue.Value));
+            eliminations.Add(new SingleStepSolution.Candidate(cellWithNoValue.RowIndex, cellWithNoValue.ColumnIndex, cellWithValue.Value));
           }
         }
       }