/// <summary>
/// Calls the FindLegalDigits method on the board
/// </summary>
/// <param name="board">Board to check</param>
public static void FindLegalDigits(SudokuBoard board)
{
int row, col;
GetRow:
Console.WriteLine("Enter the row that you want to check (1-9)");
int userInput;
if (!int.TryParse(Console.ReadLine(), out userInput) || userInput < 1 || userInput > 9)
{
Console.WriteLine("You have entered an incorrect input. Please try again.");
goto GetRow;
}
row = userInput;
GetCol:
Console.WriteLine("Enter the col that you want to place (1-9)");
if (!int.TryParse(Console.ReadLine(), out userInput) || userInput < 1 || userInput > 9)
{
Console.WriteLine("You have entered an incorrect input. Please try again.");
goto GetCol;
}
col = userInput;
Console.WriteLine();
foreach (int validVal in board.FindLegalDigits(row - 1, col - 1))
{
Console.WriteLine(validVal + " is a legal digit for row " + row + " and column " + col);
}
Console.WriteLine();
}
/// <summary>
/// Algorithmically finds a solution (if there is one) to this sudoku puzzle.
/// Make sure to assign the solved board back to the board argument
/// </summary>
/// <param name="board">The board to solve</param>
/// <returns>True if the board was solved, false otherwise.</returns>
public static bool SolveBoardIterativelyWithQueue(ref SudokuBoard board)
{
Queue <SudokuBoard> boards = new Queue <SudokuBoard>();
boards.Push(board);
List <int> nums = new List <int>();
while (boards.Count != 0)
{
SudokuBoard temp = boards.Pop();
if (temp.VerifyBoard() == true)
{
board = temp;
return(true);
}
int index1 = 0;
int index2 = 0;
bool hasrun = false;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (temp.Board[i, j] == 0)
{
index1 = i;
index2 = j;
nums = temp.FindLegalDigits(i, j);
hasrun = true;
if (hasrun == true)
{
break;
}
}
}
}
for (int i = 0; i < nums.Count; i++)
{
SudokuBoard newBoard = new SudokuBoard(temp);
newBoard.Board[index1, index2] = nums[i];
boards.Push(newBoard);
}
}
return(false);
//As long as there is a board in the queue, do the following:
//dequeue from the queue and store the returned value
//if the returned value is complete
//apply board to our ref parameter and return true
//Find the first blank space "0" on the board
//FindLegalDigits() on that space
//Enqueue a new board for each legal digit found(make sure to put that digit on the new board!)
}
/// <summary>
/// Algorithmically finds a solution (if there is one) to this sudoku puzzle.
/// Make sure to assign the solved board back to the board argument
/// </summary>
/// <param name="board">The board to solve</param>
/// <returns>True if the board was solved, false otherwise.</returns>
public static bool SolveBoardIterativelyWithQueue(ref SudokuBoard board)
{
Queue <SudokuBoard> boards = new Queue <SudokuBoard>();
SudokuBoard fatdaddy = new SudokuBoard();
boards.Enqueue(board);
//As long as there is a board in the queue, do the following:
while (boards.Count > 0)
{
//dequeue from the queue and store the returned value
fatdaddy = boards.Dequeue();
//if the returned value is complete
if (fatdaddy.VerifyBoard())
{
//apply board to our ref parameter and return true
board = fatdaddy;
return(true);
}
bool isgood = false;
//Find the first blank space "0" on the board
for (int x = 0; x < 9; x++)
{
for (int y = 0; y < 9; y++)
{
if (fatdaddy.Board[x, y] == 0)
{
//FindLegalDigits() on that space
List <int> legal_digits = fatdaddy.FindLegalDigits(x, y);
//Enqueue a new board for each legal digit found (make sure to put that digit on the new board!)
if (isgood == false)
{
for (int i = 0; i < legal_digits.Count; i++)
{
SudokuBoard copy = new SudokuBoard(fatdaddy);
copy.Board[x, y] = legal_digits[i];
boards.Enqueue(copy);
}
isgood = true;
}
}
}
}
}
return(false);
}
/// <summary>
/// Algorithmically finds a solution (if there is one) to this sudoku puzzle.
/// Make sure to assign the solved board back to the board argument
/// </summary>
/// <param name="board">The board to solve</param>
/// <returns>True if the board was solved, false otherwise.</returns>
public static bool SolveBoardIterativelyWithQueue(ref SudokuBoard board)
{
// throw new NotImplementedException();
Queue <SudokuBoard> boards = new Queue <SudokuBoard>();
SudokuBoard one = new SudokuBoard();
boards.Enqueue(board);
while (boards.Count > 0)
{
one = boards.Dequeue();
if (one.VerifyBoard())
{
board = one;
return(true);
}
bool wee = false;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (one.Board[i, j] == 0)
{
List <int> digits = one.FindLegalDigits(i, j);
if (wee == false)
{
for (int x = 0; x < digits.Count; x++)
{
SudokuBoard two = new SudokuBoard(one);
two.Board[i, j] = digits[x];
boards.Enqueue(two);
}
wee = true;
}
}
}
}
}
//As long as there is a board in the queue, do the following:
//dequeue from the queue and store the returned value
//if the returned value is complete
//apply board to our ref parameter and return true
//Find the first blank space "0" on the board
//FindLegalDigits() on that space
//Enqueue a new board for each legal digit found (make sure to put that digit on the new board!)
return(false);
}
/// <summary>
/// Algorithmically finds a solution (if there is one) to this sudoku puzzle.
/// Make sure to assign the solved board back to the board argument
/// </summary>
/// <param name="board">The board to solve</param>
/// <returns>True if the board was solved, false otherwise.</returns>
public static bool SolveBoardIterativelyWithQueue(ref SudokuBoard board)
{
Stack <SudokuBoard> boards = new Stack <SudokuBoard>();
boards.Push(board);
while (boards.Count != 0)
{
SudokuBoard CurrentBoard = boards.Pop();
if (CurrentBoard.VerifyBoard() == true)
{
//Apply Board to our Ref Parameter and return true
board = CurrentBoard;
return(true);
}
bool HasRun = false;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (HasRun != true && CurrentBoard.Board[i, j] == 0)
{
List <int> LegalBoard = CurrentBoard.FindLegalDigits(i, j);
foreach (int S in LegalBoard)
{
SudokuBoard B = new SudokuBoard(CurrentBoard);
B.Board[i, j] = S;
boards.Push(B);
}
HasRun = true;
}
}
}
}
return(false);
////apply board to our ref parameter and return true
////Find the first blank space "0" on the board
////FindLegalDigits() on that space
////Enqueue a new board for each legal digit found (make sure to put that digit on the new board!)
}
/// <summary>
/// Algorithmically finds a solution (if there is one) to this sudoku puzzle.
/// Make sure to assign the solved board back to the board argument
/// </summary>
/// <param name="board">The board to solve</param>
/// <returns>True if the board was solved, false otherwise.</returns>
public static bool SolveBoardIterativelyWithQueue(ref SudokuBoard board)
{
Stack <SudokuBoard> boards = new Stack <SudokuBoard>();
boards.Push(board);
while (boards.Count != 0)
{
SudokuBoard currentboard = boards.Pop();
if (currentboard.VerifyBoard() == true)
{
//apply board to our ref parameter
board = currentboard;
//and return true
return(true);
}
bool hasrun = false;
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (hasrun != true && currentboard.Board[i, j] == 0)
{
List <int> legalboard = currentboard.FindLegalDigits(i, j);
foreach (int s in legalboard)
{
SudokuBoard b = new SudokuBoard(currentboard);
b.Board[i, j] = s;
boards.Push(b);
}
hasrun = true;
}
}
}
}
return(false);
}
