private void ShowNotesForSquare(ISudokuSquare square)
{
if (square.GetText().Trim().Length > 0)
{
return;
}
ShowNotesForSquareAt(square);
}
bool BruteForceAttack(int startingRow = 0, int startingColumn = 0)
{
if (startingColumn >= 9)
{
startingColumn = 0;
startingRow++;
}
for (int row = startingRow; row < 9; row++)
{
for (int column = startingColumn; column < 9; column++)
{
startingColumn = 0;
ISudokuSquare sudokuSquare = SudokuBoard.squares[row, column];
if (!sudokuSquare.IsEmpty)
{
continue;
}
// Magic - I have an empty square!!!
if (sudokuSquare.Notes == "")
{
ShowNotesForSquareAt(sudokuSquare);
if (sudokuSquare.Notes == "") // That means we have a conflict.
{
return(BruteForceAttack(row, column + 1));
}
}
List <int> notes = BaseGroupSolver.GetNumbers(sudokuSquare.Notes);
foreach (int number in notes)
{
sudokuSquare.Value = number.ToString()[0];
sudokuSquare.HasTestValue = true;
numCombinationsTried++;
if (HasConflicts(row, column))
{
sudokuSquare.Value = Char.MinValue;
sudokuSquare.HasTestValue = false;
}
else if (BruteForceAttack(row, column + 1))
{
sudokuSquare.Notes = "";
return(true);
}
else
{
sudokuSquare.Value = Char.MinValue;
sudokuSquare.HasTestValue = false;
}
}
return(false);
}
}
return(AllSquaresAreFilled());
}
bool NoteCountsAreSufficient(ISudokuSquare[] group, List <int> indicesToCheck, out List <List <int> > allNoteNumbers)
{
allNoteNumbers = new List <List <int> >();
foreach (int index in indicesToCheck)
{
ISudokuSquare square = group[index];
List <int> squareNoteNumbers = GetNumbers(square.Notes);
allNoteNumbers.Add(squareNoteNumbers);
if (squareNoteNumbers.Count < 2 || squareNoteNumbers.Count > indicesToCheck.Count)
{
return(false);
}
}
return(true);
}
bool GroupAlreadyIsShowing(ISudokuSquare[] group, int note)
{
char noteChar = note.ToString()[0];
for (int i = 0; i < group.Length; i++)
{
ISudokuSquare sudokuSquare = group[i];
if (sudokuSquare.Value == noteChar)
{
return(true);
}
}
return(false);
}
bool AllSquaresAreFilled()
{
for (int row = 0; row < 9; row++)
{
for (int column = 0; column < 9; column++)
{
ISudokuSquare sudokuSquare = SudokuBoard.squares[row, column];
if (sudokuSquare.IsEmpty)
{
return(false);
}
}
}
return(true);
}
public override SolveResult Solve(ISudokuSquare[] group, GroupKind groupKind)
{
SolveResult result = SolveResult.None;
Dictionary <int, int> numbersFound = new Dictionary <int, int>();
for (int i = 0; i < group.Length; i++)
{
ISudokuSquare sudokuSquare = group[i];
List <int> notes = GetNumbers(sudokuSquare.Notes);
foreach (int note in notes)
{
if (!numbersFound.ContainsKey(note))
{
numbersFound.Add(note, 1);
}
else
{
numbersFound[note]++;
}
}
}
foreach (int note in numbersFound.Keys)
{
if (numbersFound[note] == 1)
{
int onlyOneNote = note;
if (GroupAlreadyIsShowing(group, onlyOneNote))
{
continue;
}
// note has to be in this square!
for (int i = 0; i < group.Length; i++)
{
ISudokuSquare sudokuSquare = group[i];
List <int> notes = GetNumbers(sudokuSquare.Notes);
if (notes.Contains(onlyOneNote))
{
sudokuSquare.Notes = "";
sudokuSquare.Value = onlyOneNote.ToString()[0];
result = SolveResult.SquaresSolved;
}
}
}
}
return(result);
}
private void ShowNotesForSquareAt(ISudokuSquare square)
{
ISudokuSquare[] column = SudokuBoard.GetColumn(square.Column);
ISudokuSquare[] row = SudokuBoard.GetRow(square.Row);
ISudokuSquare[] block = SudokuBoard.GetBlock(square.Row, square.Column);
List <char> availableChars = new List <char>();
foreach (char item in tbxAvailableCharacter.Text)
{
availableChars.Add(item);
}
RemoveCharactersFromGroup(availableChars, row);
RemoveCharactersFromGroup(availableChars, column);
RemoveCharactersFromGroup(availableChars, block);
square.SetNotes(string.Join(", ", availableChars));
}
public SolveResult RemoveNotesFrom(ISudokuSquare sudokuSquare, string notes)
{
if (string.IsNullOrEmpty(sudokuSquare.Notes))
{
return(SolveResult.None);
}
else
{
List <int> toRemoveList = GetNumbers(notes);
List <int> squareNotes = GetNumbers(sudokuSquare.Notes);
foreach (int numberToRemove in toRemoveList)
{
squareNotes.Remove(numberToRemove);
}
string newNotes = string.Join(", ", squareNotes);
if (newNotes != sudokuSquare.Notes)
{
sudokuSquare.Notes = newNotes;
return(SolveResult.SquaresSolved);
}
}
return(SolveResult.None);
}
bool CheckForConflicts(int r, int c, bool setHasConflictedProperty = true)
{
ISudokuSquare thisSquare = SudokuBoard.squares[r, c];
string text = thisSquare.GetText();
if (string.IsNullOrWhiteSpace(text))
{
return(false);
}
ISudokuSquare[] column = SudokuBoard.GetColumn(c);
ISudokuSquare[] row = SudokuBoard.GetRow(r);
ISudokuSquare[] block = SudokuBoard.GetBlock(r, c);
bool isConflicted = false;
for (int rowIndex = 0; rowIndex < 9; rowIndex++)
{
if (rowIndex != r && column[rowIndex].GetText() == text)
{
if (setHasConflictedProperty)
{
thisSquare.HasConflict = true;
column[rowIndex].HasConflict = true;
}
isConflicted = true;
}
}
for (int colIndex = 0; colIndex < 9; colIndex++)
{
if (colIndex != c && row[colIndex].GetText() == text)
{
if (setHasConflictedProperty)
{
thisSquare.HasConflict = true;
row[colIndex].HasConflict = true;
}
isConflicted = true;
}
}
for (int squareIndex = 0; squareIndex < 9; squareIndex++)
{
GetSquarePosition(block[squareIndex], out int blockRow, out int blockColumn);
if (blockRow == r && blockColumn == c)
{
continue;
}
if (block[squareIndex].GetText() == text)
{
if (setHasConflictedProperty)
{
thisSquare.HasConflict = true;
block[squareIndex].HasConflict = true;
}
isConflicted = true;
}
}
return(isConflicted);
}
void GetSquarePosition(ISudokuSquare square, out int row, out int column)
{
row = square.Row;
column = square.Column;
}
