private Boolean CanBeSet(SudokuItem sudokuItem, Int32 row, Int32 column, Byte value)
{
for (Int32 i = 0; i < sudokuItem.Field.GetLength(0); i++)
{
if (sudokuItem.Field[row, i] == value)
{
return(false);
}
if (sudokuItem.Field[i, column] == value)
{
return(false);
}
}
Int32 boxSize = (Int32)Math.Sqrt(sudokuItem.Field.GetLength(0));
Int32 boxRow = row / boxSize;
Int32 boxColumn = column / boxSize;
for (Int32 i = boxRow * boxSize; i < (boxRow * boxSize) + boxSize; i++)
{
for (Int32 j = boxColumn * boxSize; j < (boxColumn * boxSize) + boxSize; j++)
{
if (sudokuItem.Field[i, j] == value)
{
return(false);
}
}
}
return(true);
}
private IEnumerable <SudokuResult> FindSolutions(SudokuItem sudokuItem, Int32 row, Int32 column)
{
if (row == sudokuItem.Field.GetLength(0))
{
return(new List <SudokuResult>()
{
this.resultMapper.Map(sudokuItem)
});
}
Int32 nextRow = row + ((column + 1) / sudokuItem.Field.GetLength(0));
Int32 nextColumn = (column + 1) % sudokuItem.Field.GetLength(1);
if (sudokuItem.Field[row, column] != 0)
{
return(this.FindSolutions(sudokuItem, nextRow, nextColumn));
}
IEnumerable <SudokuResult> results = new List <SudokuResult>();
foreach (Byte candidateValue in this.GetCandidates(sudokuItem, row, column))
{
sudokuItem.Field[row, column] = candidateValue;
//findAllSingles(newSudoku);
results = results.Union(this.FindSolutions(sudokuItem, nextRow, nextColumn));
}
sudokuItem.Field[row, column] = 0;
return(results);
}
public void TestCopyConstructor()
{
List <CellContent> contentlist = new List <CellContent>
{
new CellContent(0), // 0, 0
new CellContent(1), // 0, 1
new CellContent(0), // 0, 2
new CellContent(2), // 1, 0
new CellContent(0), // 1, 1
new CellContent(3), // 1, 2
new CellContent(9), // 2, 0
new CellContent(4), // 2, 1
new CellContent(5), // 2, 2
};
SudokuItem item1 = new SudokuItem(contentlist);
Assert.IsTrue(item1[1] == new CellContent(1));
Assert.IsTrue(item1[8] == new CellContent(5));
SudokuItem copy = new SudokuItem(item1);
for (int i = 0; i < 9; i++)
{
Assert.IsTrue(copy[i] == item1[i]);
}
} //
public void TestFixedItems()
{
List <CellContent> contentlist = new List <CellContent>
{
new CellContent(0), // 0, 0
new CellContent(1, true), // 0, 1
new CellContent(0), // 0, 2
new CellContent(2), // 1, 0
new CellContent(0), // 1, 1
new CellContent(3), // 1, 2
new CellContent(9, true), // 2, 0
new CellContent(4), // 2, 1
new CellContent(5), // 2, 2
};
SudokuItem item = new SudokuItem(contentlist);
Assert.IsTrue(item[1].IsFixed);
item.ReplaceItem(new CellContent(1), 1);
Assert.AreEqual(new CellContent(1), item[1]);
Assert.IsTrue(item[1].IsFixed);
Assert.IsFalse(item[1].IsEmpty);
item.ReplaceItem(new CellContent(7), 1);
Assert.AreEqual(new CellContent(1), item[1]);
}
public IEnumerable <SudokuResult> Solve(SudokuItem sudokuItem)
{
if (sudokuItem == null)
{
throw new ArgumentNullException(nameof(sudokuItem));
}
return(this.FindSolutions(sudokuItem, 0, 0));
}
public void Test_Sudoku_Grid()
{
Sudoku Sudoku = new Sudoku();
// top left
Sudoku[2, 2] = new CellContent(9);
int rank = Sudoku[2, 2].Rank;
Assert.AreEqual(9, Sudoku[2, 2].Rank);
SudokuItem row = Sudoku.GetRowAt(2);
Assert.AreEqual(9, row[2].Rank);
SudokuItem col = Sudoku.GetColumnAt(2);
Assert.AreEqual(9, col[2].Rank);
Sudoku3x3 sgrid = Sudoku.GetSudoku3x3AtGridPosition(2, 2);
Assert.AreEqual(9, sgrid[2, 2].Rank);
// bottom right
Sudoku[7, 8] = new CellContent(1);
rank = Sudoku[7, 8].Rank;
Assert.AreEqual(rank, Sudoku[7, 8].Rank);
row = Sudoku.GetRowAt(8);
Assert.AreEqual(rank, row[7].Rank);
col = Sudoku.GetColumnAt(7);
Assert.AreEqual(rank, col[8].Rank);
sgrid = Sudoku.GetSudoku3x3AtGridPosition(7, 8);
Assert.AreEqual(rank, sgrid[1, 2].Rank);
// middle
Sudoku[4, 5] = new CellContent(5);
rank = Sudoku[4, 5].Rank;
Assert.AreEqual(rank, Sudoku[4, 5].Rank);
row = Sudoku.GetRowAt(5);
Assert.AreEqual(rank, row[4].Rank);
col = Sudoku.GetColumnAt(4);
Assert.AreEqual(rank, col[5].Rank);
sgrid = Sudoku.GetSudoku3x3AtGridPosition(4, 5);
Assert.AreEqual(rank, sgrid[1, 2].Rank);
// middle bottom
Sudoku[5, 7] = new CellContent(2);
rank = Sudoku[5, 7].Rank;
Assert.AreEqual(rank, Sudoku[5, 7].Rank);
row = Sudoku.GetRowAt(7);
Assert.AreEqual(rank, row[5].Rank);
col = Sudoku.GetColumnAt(5);
Assert.AreEqual(rank, col[7].Rank);
sgrid = Sudoku.GetSudoku3x3AtGridPosition(5, 7);
Assert.AreEqual(rank, sgrid[2, 1].Rank);
Assert.IsTrue(Sudoku.Validate());
//Sudoku.
}
public void TestBasics()
{
SudokuItem row = new SudokuItem();
Assert.IsTrue(row.IsEmpty);
Assert.AreEqual(9, row.EmptyCount);
Assert.AreEqual(0, row.ContentCount);
Assert.IsTrue(row.HasContent(new CellContent(0)));
Assert.IsFalse(row.HasContent(new CellContent(1)));
Assert.IsTrue(row.Validate());
}
// TODO 1x berechnen, dann wiederholt zugreifen
private IEnumerable <Byte> GetCandidates(SudokuItem sudokuItem, Int32 row, Int32 column)
{
if (sudokuItem.Field[row, column] != 0)
{
yield break;
}
for (Byte candidateValue = 1; candidateValue <= sudokuItem.Field.GetLength(0); candidateValue++)
{
if (this.CanBeSet(sudokuItem, row, column, candidateValue))
{
yield return(candidateValue);
}
}
}
public void TestDataManipulation()
{
List <CellContent> contentlist = new List <CellContent>
{
new CellContent(0), // 0, 0
new CellContent(1), // 1, 0
new CellContent(0), // 2, 0
new CellContent(2), // 0, 1
new CellContent(0), // 1, 1
new CellContent(3), // 2, 1
new CellContent(0), // 0, 2
new CellContent(4), // 1, 2
new CellContent(5), // 2, 2
};
Sudoku3x3 grid = new Sudoku3x3(contentlist);
Assert.AreEqual(grid[0, 0], new CellContent(0));
Assert.AreEqual(grid[1, 0], new CellContent(1));
Assert.AreEqual(grid[0, 1], new CellContent(2));
Assert.AreEqual(grid[2, 1], new CellContent(3));
Assert.AreEqual(grid[2, 2], new CellContent(5));
SudokuItem t1 = new SudokuItem(contentlist);
SudokuItem t2 = grid.ToSudokuItem();
for (int idx = 0; idx < 9; idx++)
{
Assert.AreEqual(t1[idx], t2[idx]);
}
List <CellContent> col = grid.GetColumn(2);
Assert.AreEqual(col[0], grid[2, 0]);
Assert.AreEqual(col[1], grid[2, 1]);
Assert.AreEqual(col[2], grid[2, 2]);
List <CellContent> row = grid.GetRow(1);
Assert.AreEqual(row[0], grid[0, 1]);
Assert.AreEqual(row[1], grid[1, 1]);
Assert.AreEqual(row[2], grid[2, 1]);
} // TestDataManipulation
public void TestAddReplaceContent()
{
SudokuItem column = new SudokuItem();
column[0] = new CellContent(9);
Assert.IsFalse(column.IsEmpty);
Assert.AreEqual(1, column.ContentCount);
column[1] = new CellContent(8);
Assert.ThrowsException <ArgumentException>(() => column[2] = new CellContent(9));
Assert.AreEqual(2, column.ContentCount);
column.ClearCell(1);
Assert.AreEqual(1, column.ContentCount);
column[1] = new CellContent(8);
column[2] = new CellContent(7);
Assert.ThrowsException <InvalidOperationException>(() => column.InsertItem(new CellContent(6), 2));
List <int> ranks = column.AvailableRanks();
Assert.AreEqual(6, ranks.Count);
Assert.AreEqual(1, ranks[0]);
Assert.AreEqual(2, ranks[1]);
Assert.AreEqual(6, ranks[5]);
column[3] = new CellContent(6);
column[4] = new CellContent(5);
column[5] = new CellContent(4);
column[6] = new CellContent(3);
column[7] = new CellContent(2);
Assert.AreEqual(8, column.ContentCount);
ranks = column.AvailableRanks();
Assert.AreEqual(1, ranks.Count);
Assert.AreEqual(1, ranks[0]);
column[8] = new CellContent(1);
Assert.IsTrue(column.IsFull);
Assert.IsTrue(column.Validate());
//Assert.ThrowsException<InvalidOperationException>(() => column.InsertItem(new CellContent(9), 5) );
}
static SudokuPuzzle ClearPossiblesForACell(int i, int j, SudokuPuzzle puzzle)
{
// 读取一个值，如果此值为0，则继续下一个
int currVal = puzzle.Item[i][j].Val;
if (currVal == 0)
{
return(puzzle);
}
// 清除根据此值可以排除的值
// 清除同行的值
int row = i;
int col = 0;
for (col = 0; col < 9; col++)
{
if (col == j)
{
continue;
}
SudokuItem tempItem = puzzle.Item[row][col];
if (tempItem.Val == currVal)
{
throw new Exception("同一行有相同值");
}
if (tempItem.IsConfirmed)
{
continue;
}
tempItem.RemoviePossibleVal(currVal);
}
// 清除同列的值
col = j;
for (row = 0; row < 9; row++)
{
if (row == i)
{
continue;
}
SudokuItem tempItem = puzzle.Item[row][col];
if (tempItem.Val == currVal)
{
throw new Exception("同一列有相同值");
}
if (tempItem.IsConfirmed)
{
continue;
}
tempItem.RemoviePossibleVal(currVal);
}
// 清除同块的值
col = j / 3;
row = i / 3;
int rowTml = (row + 1) * 3;
int colTml = (col + 1) * 3;
for (int tr = row * 3; tr < rowTml; tr++)
{
for (int tc = col * 3; tc < colTml; tc++)
{
if (tr == i && tc == j)
{
continue;
}
SudokuItem tempItem = puzzle.Item[tr][tc];
if (tempItem.Val == currVal)
{
throw new Exception("同一框有相同值");
}
if (tempItem.IsConfirmed)
{
continue;
}
tempItem.RemoviePossibleVal(currVal);
}
}
return(puzzle);
}
public void TestAvailbleItems()
{
SudokuItem item = new SudokuItem();
Assert.AreEqual(9, item.AvailableRanks().Count);
}
