public static SudokuPuzzle MakeSolvedPuzzle()
{
// known solution from: http://www.sudokukingdom.com/images/rules_solved.jpg
var rows = new SudokuValue[][] {
new SudokuValue [] { SudokuValue.TWO, SudokuValue.FOUR, SudokuValue.EIGHT, SudokuValue.THREE, SudokuValue.NINE, SudokuValue.FIVE, SudokuValue.SEVEN, SudokuValue.ONE, SudokuValue.SIX },
new SudokuValue [] { SudokuValue.FIVE, SudokuValue.SEVEN, SudokuValue.ONE, SudokuValue.SIX, SudokuValue.TWO, SudokuValue.EIGHT, SudokuValue.THREE, SudokuValue.FOUR, SudokuValue.NINE },
new SudokuValue [] { SudokuValue.NINE, SudokuValue.THREE, SudokuValue.SIX, SudokuValue.SEVEN, SudokuValue.FOUR, SudokuValue.ONE, SudokuValue.FIVE, SudokuValue.EIGHT, SudokuValue.TWO },
new SudokuValue [] { SudokuValue.SIX, SudokuValue.EIGHT, SudokuValue.TWO, SudokuValue.FIVE, SudokuValue.THREE, SudokuValue.NINE, SudokuValue.ONE, SudokuValue.SEVEN, SudokuValue.FOUR },
new SudokuValue [] { SudokuValue.THREE, SudokuValue.FIVE, SudokuValue.NINE, SudokuValue.ONE, SudokuValue.SEVEN, SudokuValue.FOUR, SudokuValue.SIX, SudokuValue.TWO, SudokuValue.EIGHT },
new SudokuValue [] { SudokuValue.SEVEN, SudokuValue.ONE, SudokuValue.FOUR, SudokuValue.EIGHT, SudokuValue.SIX, SudokuValue.TWO, SudokuValue.NINE, SudokuValue.FIVE, SudokuValue.THREE },
new SudokuValue [] { SudokuValue.EIGHT, SudokuValue.SIX, SudokuValue.THREE, SudokuValue.FOUR, SudokuValue.ONE, SudokuValue.SEVEN, SudokuValue.TWO, SudokuValue.NINE, SudokuValue.FIVE },
new SudokuValue [] { SudokuValue.ONE, SudokuValue.NINE, SudokuValue.FIVE, SudokuValue.TWO, SudokuValue.EIGHT, SudokuValue.SIX, SudokuValue.FOUR, SudokuValue.THREE, SudokuValue.SEVEN },
new SudokuValue [] { SudokuValue.FOUR, SudokuValue.TWO, SudokuValue.SEVEN, SudokuValue.NINE, SudokuValue.FIVE, SudokuValue.THREE, SudokuValue.EIGHT, SudokuValue.SIX, SudokuValue.ONE }
};
var puzzle = new SudokuPuzzle();
for (int i = 0; i < rows.Length; i++)
{
for (int j = 0; j < rows.Length; j++)
{
puzzle.SetValue(i, j, rows[i][j]);
}
}
return puzzle;
}
/// <summary> <!-- {{{1 --> Constructor
/// </summary>
/// <param name="idx"></param>
public Cell(SudokuCellIndex idx)
{
idx.AssertWhenInvalid();
this.index = idx;
this.candidate = new Candidates();
this.value = SudokuValue.NA;
}
public SudokuSolverEventArgs(SudokuValue value, int row, int column, SudokuSolverEventArgsAction action = SudokuSolverEventArgsAction.Set)
: base()
{
this.Row = row;
this.Column = column;
this.Value = value;
this.Action = action;
}
public void SetValueAtId(int id, SudokuValue value)
{
foreach (var group in GetGroupsForId(id))
{
group.AvailableValues.Remove(value);
}
GetBoxForId(id).SetAssigned(value);
}
/// <summary> <!-- {{{1 --> Throw exception when specified value is invalid or N/A.
/// </summary>
/// <param name="self"></param>
public static void AssertWhenInvalidOrNA(this SudokuValue self)
{
if (!self.IsValidOrNA())
{
var msg = string.Format("Invalid cell value: {0}", self.ToStr());
throw new ArgumentOutOfRangeException(msg);
}
}
/// <summary> <!-- {{{1 --> Convert SudokuValue to String
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static string ToStr(this SudokuValue self)
{
if (self.IsInvalid())
{
return(".");
}
return(self.ToInt().ToString());
}
/// <summary> <!-- {{{1 --> Constructor
/// </summary>
/// <param name="initial"></param>
public Value(SudokuValue initial)
{
if (!initial.IsNA() && initial.IsInvalid())
{
var msg = string.Format("Invalid value: {0}", initial.ToStr());
throw new ArgumentOutOfRangeException(msg);
}
this.v = initial;
}
public SudokuValue[,] FormatSudokuBoard(int[,] board)
{
SudokuValue[,] newBoard = new SudokuValue[board.GetLength(0), board.GetLength(1)];
for (int i = 0; i < board.GetLength(0); i++)
{
for (int y = 0; y < board.GetLength(1); y++)
{
bool wasGiven = board[i, y] != 0;
newBoard[i, y] = new SudokuValue()
{
value = board[i, y], wasGiven = wasGiven
};
}
}
return(newBoard);
}
public void FormatSudokuBoard_BoardFormatted_ReturnsTrue()
{
// Arrange
int[,] unformattedBoard = new int[2, 2] {
{ 1, 0 }, { 3, 4 }
};
SudokuValue[,] expected = new SudokuValue[2, 2]
{
{
new SudokuValue()
{
value = 1, wasGiven = true
},
new SudokuValue()
{
value = 0, wasGiven = false
}
},
{
new SudokuValue()
{
value = 3, wasGiven = true
},
new SudokuValue()
{
value = 4, wasGiven = true
}
}
};
// Act
SudokuValue[,] actual = _service.FormatSudokuBoard(unformattedBoard);
// Assert
Assert.IsTrue(_service.CheckIfSudokuBoardsAreEqual(expected, actual));
}
/// <summary> <!-- {{{1 --> Return true if the value is same with specified Value instance.
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
public bool Equals(SudokuValue val)
{
return(val == this.value);
}
/// <summary> <!-- {{{1 --> Copy value from specified cell value.
/// </summary>
/// <param name="val"></param>
public void CopyFrom(SudokuValue val)
{
val.AssertWhenInvalidOrNA();
this.value = val;
}
/// <summary> <!-- {{{1 --> Return true if the value is same with specified value.
/// </summary>
/// <param name="src"></param>
/// <returns></returns>
public bool Equals(SudokuValue v)
{
return(v == this.v);
}
private int CountOccurencesInBox(SudokuValue value, int row, int col)
{
var count = 0;
// adjust (0, 1, 2) => 0, (3, 4, 5) => 3, (6, 7, 8) => 6
row = row - row % NUM_CELLS_PER_BOX;
col = col - col % NUM_CELLS_PER_BOX;
for (int i = row; i < row + NUM_CELLS_PER_BOX; i++)
{
for (int j = col; j < col + NUM_CELLS_PER_BOX; j++)
{
if (this.CurrentBoard[i][j] == value)
{
count++;
}
}
}
return count;
}
public bool IsValidValue(SudokuValue sudokuValue, int row, int col)
{
if (this.IsValueInRow(sudokuValue, row) || this.IsValueInColumn(sudokuValue, col) || this.IsValueInBox(sudokuValue, row, col))
{
return false;
}
return true;
}
/// <summary> <!-- {{{1 --> Convert SudokuValue to Integer
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static int ToInt(this SudokuValue self)
{
return((int)self);
}
/// <summary> <!-- {{{1 --> Return true if the value is valid or NA.
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static bool IsValidOrNA(this SudokuValue self)
{
return(self.IsValid() || self.IsNA());
}
/// <summary> <!-- {{{1 --> Return true if the value is valid.
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static bool IsValid(this SudokuValue self)
{
return(!self.IsInvalid());
}
/// <summary> <!-- {{{1 --> Return true if the value is invalid.
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static bool IsInvalid(this SudokuValue self)
{
return((SudokuValue._1 > self) || (SudokuValue._9 < self));
}
/// <summary> <!-- {{{1 --> Return true if the value is not available.
/// </summary>
/// <param name="self"></param>
/// <returns></returns>
public static bool IsNA(this SudokuValue self)
{
return(SudokuValue.NA == self);
}
private void NotifyCallback(SudokuValue value, int row, int col, SudokuSolverEventArgsAction action)
{
if (this.Callback != null)
{
var args = new SudokuSolverEventArgs(value, row, col, action);
this.Callback.Invoke(this, args);
if (args.Delay > 0)
{
Thread.Sleep(args.Delay);
}
}
}
private int CountOccurencesInRow(SudokuValue value, int row)
{
var count = 0;
for (int i = 0; i < NUM_ROWS; i++)
{
if (this.CurrentBoard[row][i] == value)
{
count++;
}
}
return count;
}
private bool IsValueInColumn(SudokuValue value, int col)
{
return this.CountOccurencesInColumn(value, col) > 0;
}
public void SetValue(int row, int col, SudokuValue value)
{
this.CurrentBoard[row][col] = value;
}
/// <summary> <!-- {{{1 --> Remove specified candidate
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public bool Remove(SudokuValue v)
{
return(!values.Remove(v));
}
private int CountOccurencesInColumn(SudokuValue value, int col)
{
var count = 0;
for (int i = 0; i < NUM_ROWS; i++)
{
if (this.CurrentBoard[i][col] == value)
{
count++;
}
}
return count;
}
/// <summary> <!-- {{{1 --> Copy members from specified Value instance.
/// </summary>
/// <param name="src"></param>
public void CopyFrom(Value src)
{
this.v = src.v;
}
private bool IsValueInBox(SudokuValue value, int row, int col)
{
return this.CountOccurencesInBox(value, row, col) > 0;
}
public void SetAssigned(SudokuValue value)
{
Assigned = value;
}
private bool IsValueInRow(SudokuValue value, int row)
{
return this.CountOccurencesInRow(value, row) > 0;
}
/// <summary> <!-- {{{1 --> Add specified candidate
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public bool Add(SudokuValue v)
{
return(!values.Add(v));
}
