private void SimpleExclusion(IEnumerable <SudokuField> fields)
{
SudokuField.Certainty toSetTo = SudokuField.Certainty.CanNotBe;
if (Guess == true)
{
toSetTo = SudokuField.Certainty.CanNotBeOnGuess;
}
List <int> filledInNumbers = new List <int>();
foreach (SudokuField field in fields)
{
int?number = field.GetNumber();
if (number != null)
{
filledInNumbers.Add((int)number);
}
}
foreach (SudokuField field in fields)
{
SudokuField.ChangeType newChange = field.SetNumbers(filledInNumbers, toSetTo);
ChangeController(newChange);
}
}
private void ExclusionOnOnlyPositionsThatFit(List <SudokuField> fields)
{
if (boardProperty == BoardProperty.NineByNine || boardProperty == BoardProperty.SixBySix || boardProperty == BoardProperty.FourByFour || boardProperty == BoardProperty.TwoByTwo)
{
SudokuField.Certainty toSetTo = SudokuField.Certainty.CanNotBe;
if (Guess == true)
{
toSetTo = SudokuField.Certainty.CanNotBeOnGuess;
}
List <int> numbersNeeded = new List <int>();
for (int i = boardProperties[boardProperty].MinNumber; i <= boardProperties[boardProperty].MaxNumber; i++)
{
numbersNeeded.Add(i);
}
for (int i = 0; i < fields.Count; i++)
{
int?number = fields[i].GetNumber();
if (number != null)
{
numbersNeeded.Remove((int)number);
fields.Remove(fields[i]);
i--;
}
}
foreach (SudokuField field in fields)
{
List <int> numbersField = (List <int>)field.GetNumbers();
numbersField.RemoveAll(number => !numbersNeeded.Contains(number));
foreach (SudokuField fieldToCheckAgainst in fields)
{
if (field != fieldToCheckAgainst)
{
IEnumerable <int> numbersCoveredByOtherField = fieldToCheckAgainst.GetNumbers();
numbersField.RemoveAll(number => numbersCoveredByOtherField.Contains(number));
if (numbersField.Count() == 0)
{
break;
}
}
}
if (numbersField.Count() >= 1)
{
List <int> numbersToExclude = (List <int>)field.GetNumbers();
numbersToExclude.RemoveAll(number => numbersField.Contains(number));
SudokuField.ChangeType newChange = field.SetNumbers(numbersToExclude, toSetTo);
ChangeController(newChange);
}
}
}
}
private bool BinarySolveTryToSetWithTwoNumbers(int x, int y, int?number1, int?number2, SudokuField.Certainty certainty)
{
if (number1 != null && number2 != null && number1 == number2)
{
board[x, y].SetNumber(BinaryOtherNumber((int)number1), certainty);
return(true);
}
return(false);
}
private bool BinarySolve(int x, int y)
{
if (board[x, y].GetNumber() != null)
{
return(false);
}
SudokuField.Certainty toSetTo = SudokuField.Certainty.FiguredOut;
if (Guess == true)
{
toSetTo = SudokuField.Certainty.FiguredOutOnGuess;
}
int?number1;
int?number2;
if (x - 1 >= 0 && x + 1 < boardProperties[boardProperty].BoardWidth)
{
number1 = board[x - 1, y].GetNumber();
number2 = board[x + 1, y].GetNumber();
bool attempt = BinarySolveTryToSetWithTwoNumbers(x, y, number1, number2, toSetTo);
if (attempt == true)
{
return(true);
}
}
if (y - 1 >= 0 && y + 1 < boardProperties[boardProperty].BoardHeight)
{
number1 = board[x, y - 1].GetNumber();
number2 = board[x, y + 1].GetNumber();
bool attempt = BinarySolveTryToSetWithTwoNumbers(x, y, number1, number2, toSetTo);
if (attempt == true)
{
return(true);
}
}
int[] positiveAndNegative = new int[] { -1, 1 };
foreach (int positiveNegative in positiveAndNegative)
{
if (x + 2 * positiveNegative >= 0 && x + 2 * positiveNegative < boardProperties[boardProperty].BoardWidth)
{
number1 = board[x + 2 * positiveNegative, y].GetNumber();
number2 = board[x + positiveNegative, y].GetNumber();
bool attempt = BinarySolveTryToSetWithTwoNumbers(x, y, number1, number2, toSetTo);
if (attempt == true)
{
return(true);
}
}
if (y + 2 * positiveNegative >= 0 && y + 2 * positiveNegative < boardProperties[boardProperty].BoardHeight)
{
number1 = board[x, y + 2 * positiveNegative].GetNumber();
number2 = board[x, y + positiveNegative].GetNumber();
bool attempt = BinarySolveTryToSetWithTwoNumbers(x, y, number1, number2, toSetTo);
if (attempt == true)
{
return(true);
}
}
}
return(false);
}
