static void Main(string[] args)
{
string dir = args.First();
var files = Directory.EnumerateFiles(dir).Where(file => file.EndsWith(".txt", true, CultureInfo.InvariantCulture));
foreach (string file in files)
{
string outputString = "";
try
{
SudokuBoard board = new SudokuBoard(9);
SudokuParser parser = new SudokuParser();
parser.ParserText(File.ReadAllText(file), board);
SudokuSolver solver = new SudokuSolver();
solver.SolvePuzzle(board);
file.Substring(0, file.Length - 4);
outputString = board.ToString();
}
catch (Exception e) when((e is ParseException) || (e is SolveException))
{
outputString = e.Message;
}
File.WriteAllText($"{file.Substring(0,file.Length-4)}.sln.txt", outputString);
}
}
static void Main(string[] args)
{
// Traditional 9x9 sudoku
SudokuSolver solver = new SudokuSolver("C:\\SudokuData\\sudoku1.txt");
var result = solver.SolvePuzzle();
var validAnswer = solver.ValidatePuzzle("C:\\SudokuData\\sudoku1_answer.txt");
MessageBox.Show("Puzzle solved: " + result.ToString() + "\n" +
"Result valid: " + validAnswer.ToString() + "\n\n" +
solver.PuzzleText());
// 4x4 sudoku
solver = new SudokuSolver("C:\\SudokuData\\sudoku2.txt");
result = solver.SolvePuzzle();
validAnswer = solver.ValidatePuzzle("C:\\SudokuData\\sudoku2_answer.txt");
MessageBox.Show("Puzzle solved: " + result.ToString() + "\n" +
"Result valid: " + validAnswer.ToString() + "\n\n" +
solver.PuzzleText());
// 16x16 sudoku
solver = new SudokuSolver("C:\\SudokuData\\sudoku3.txt");
result = solver.SolvePuzzle();
validAnswer = solver.ValidatePuzzle("C:\\SudokuData\\sudoku3_answer.txt");
MessageBox.Show("Puzzle solved: " + result.ToString() + "\n" +
"Result valid: " + validAnswer.ToString() + "\n\n" +
solver.PuzzleText());
}
public void testSolvePuzzle()
{
//TODO: More test cases!
// A solvable puzzle
int[,] puzzle = {{9,0,0,8,4,0,3,7,0},
{1,3,7,0,0,0,0,0,2},
{0,0,0,3,0,0,6,0,9},
{0,7,0,1,0,8,0,3,6},
{0,0,8,0,0,0,7,0,0},
{6,4,0,7,0,9,0,5,0},
{8,0,3,0,0,5,0,0,0},
{4,0,0,0,0,0,9,2,3},
{0,2,6,0,1,3,0,0,4}};
int[,] answer = {{9,6,2,8,4,1,3,7,5},
{1,3,7,5,9,6,8,4,2},
{5,8,4,3,7,2,6,1,9},
{2,7,9,1,5,8,4,3,6},
{3,5,8,2,6,4,7,9,1},
{6,4,1,7,3,9,2,5,8},
{8,9,3,4,2,5,1,6,7},
{4,1,5,6,8,7,9,2,3},
{7,2,6,9,1,3,5,8,4}};
//Sudoku. puzzle;
SudokuSolver solver = new SudokuSolver(puzzle);
bool result = solver.SolvePuzzle();
Assert.IsTrue(result);
}
static void Main(string[] args)
{
SudokuFieldProvider sudokuFieldProvider = SudokuFieldProvider.Instance;
sudokuFieldProvider.SetInitialList(InitializeSquares(ReadFile()));
SudokuSolver c = new SudokuSolver(sudokuFieldProvider);
List <Thread> allThreads = new List <Thread>();
for (int x = 0; x < Environment.ProcessorCount; x++)
{
Thread thread = new Thread(new ThreadStart(c.GetSolutions));
thread.Start();
allThreads.Add(thread);
}
foreach (Thread thread in allThreads)
{
thread.Join();
}
WriteResult(sudokuFieldProvider.GetResultList());
Console.ReadLine();
}
//indexShowFirst = The index where most cells were set
public void Process(out ArrayList resultStrings, out ArrayList sudokuBoardStrings, out ArrayList listBoxEntries, out int indexShowFirst)
{
Random random = new Random((int)(DateTime.Now.Ticks % (long)int.MaxValue));
string ResultStr, iterationDebugDirectory, debugDirectory;
int numberOfTries = 0, maxCellsSetInATry = -1, totalNumberOfCellsSet, numberOfCellsSetInTry;
ArrayList result = new ArrayList();
resultStrings = new ArrayList();
sudokuBoardStrings = new ArrayList();
listBoxEntries = new ArrayList();
indexShowFirst = -1;
debugDirectory = _debugDirectory + "\\Solve_Sudoku_" + DateTime.Now.ToString("yyyy-MM-dd HH.mm.ss.fff");
Directory.CreateDirectory(debugDirectory);
SudokuSolver sudokuSolver = new SudokuSolver(random, _sudokuBoard, _isDebug);
while ((numberOfTries < _maxNumberOfTries) && !_sudokuBoard.SudokuIsSolved)
{
numberOfTries++;
iterationDebugDirectory = debugDirectory + "\\Try" + numberOfTries.ToString();
Directory.CreateDirectory(iterationDebugDirectory);
result = sudokuSolver.Process(iterationDebugDirectory, out ResultStr);
resultStrings.Add(ResultStr);
sudokuBoardStrings.Add(_sudokuBoard.SudokuBoardString);
totalNumberOfCellsSet = _sudokuBoard.NumberOfCellsSet;
numberOfCellsSetInTry = result.Count;
listBoxEntries.Add(string.Format("Try{0} ({1}, {2}, {3})", numberOfTries, totalNumberOfCellsSet, _numberOfCellsSetInOriginalData, numberOfCellsSetInTry));
if ((_originalData.Count + result.Count) != totalNumberOfCellsSet)
{
throw new Exception("if ((_originalData.Count + result.Count) != totalNumberOfCellsSet)");
}
if (numberOfTries == 1)
{
maxCellsSetInATry = totalNumberOfCellsSet;
indexShowFirst = 0;
}
else if ((numberOfTries > 1) && (totalNumberOfCellsSet > maxCellsSetInATry))
{
maxCellsSetInATry = totalNumberOfCellsSet;
indexShowFirst = numberOfTries - 1;
}
if (_sudokuBoard.SudokuIsSolved)
{
if ((_originalData.Count + result.Count) != 81)
{
throw new Exception("((_originalData.Count + result.Count) != 81) in method SolveSudoku.Process");
}
}
else if (numberOfTries < _maxNumberOfTries)
{
_sudokuBoard.Reset(_originalData);
}
}
}
private void SolveSudoku(object sender, RoutedEventArgs e)
{
var sudokuSolver = new SudokuDifficulty();
var sudokuValidator = new SudokuSolver();
var sudokuToSolve = new SudokuCell[9, 9];
var counter = 0;
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
var textBox = this.FindName("TextBox" + counter) as TextBox;
sudokuToSolve[row, col] = new SudokuCell(row, col);
if (textBox.Text != string.Empty)
{
sudokuToSolve[row, col].Value = int.Parse(textBox.Text);
}
counter++;
}
}
if (lastSudokuDifficulty == 0)
{
MessageBox.Show("You must first generate a sudoku!");
return;
}
if (!sudokuValidator.CheckIfSudokuIsValid(sudokuToSolve))
{
MessageBox.Show("This sudoku is not valid! Please check for errors!", "Warning");
return;
}
try
{
sudokuToSolve = sudokuSolver.SolveSudoku(sudokuToSolve);
}
catch (ArgumentException)
{
MessageBox.Show("This sudoku is not valid! Please check for errors!", "Warning");
return;
}
counter = 0;
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
var textBox = this.FindName("TextBox" + counter) as TextBox;
textBox.Text = string.Empty;
textBox.Text = sudokuToSolve[row, col].Value.ToString();
textBox.IsEnabled = false;
counter++;
}
}
stopWatch.Stop();
}
private void SolveSudoku()
{
grid.ClearUserCells();
SudokuSolver solver = new SudokuSolver(grid);
solver.Solve();
RefreshCellValues();
}
static void Main(string[] args)
{
var validator = new GridValidator();
var solver = new SudokuSolver(validator);
var generator = new SudokuGenerator(validator, solver);
var policy = new HardPuzzlePolicy();
var sudukoPuzzle = generator.GeneratePuzzle(policy);
sudukoPuzzle.Print();
Console.WriteLine($"Num blanks in puzzle: {validator.GetNumBlanks(sudukoPuzzle.puzzleGrid)}");
}
private void SolveSudoku()
{
//Clear user input
grid.ClearUserCells();
//Init solver and do magic
SudokuSolver solver = new SudokuSolver(grid);
solver.Solve();
RefreshCellValues();
}
public void OnCover(ExactCover ec, SudokuCandidate sc)
{
int cage = sc.c;
int num = sc.n + 1;
System.Diagnostics.Debug.Assert(info.sizes[cage] > 0);
SudokuSolver ss = (SudokuSolver)ec;
info.remaining_totals[cage] -= num;
info.remaining_sizes[cage]--;
removed = CheckRemains(ss, info, cage, num);
}
static void Main()
{
var SudokuSolver = new SudokuSolver();
var board = GetBoard(Boards.HardMetro);
PrettyPrinter.PrettyPrint(board);
var solvedBoard = SudokuSolver.Solve(board, _debug);
PrettyPrinter.PrettyPrint(solvedBoard);
Console.WriteLine(IsSolved(solvedBoard));
Console.ReadKey();
}
static void Main(string[] args)
{
FillBoard();
SudokuSolver solver = new SudokuSolver(board);
Console.WriteLine(board);
solver.Solve();
Console.WriteLine(board);
Console.ReadKey();
}
/// <summary>
/// Determines whether a specified <c><paramref name="sudoku"/></c> can be solved.
/// </summary>
/// <param name="sudoku">The <see cref="T:Sudoku.Sudoku"/> puzzle to check.</param>
/// <param name="multipleSolutions"><c>true</c> if <c><paramref name="sudoku"/></c> has multiple possible solutions; otherwise, <c>false</c>.</param>
/// <returns><c>true</c> if <c><paramref name="sudoku"/></c> has one or more possible solution; otherwise, <c>false</c>.</returns>
/// <exception cref="ArgumentNullException"><c><paramref name="sudoku"/></c> is <c>null</c>.</exception>
public static bool CheckSolvable(SudokuPuzzle sudoku, out bool multipleSolutions)
{
if (sudoku is null)
{
throw new ArgumentNullException(nameof(sudoku));
}
int count = 0;
SudokuSolver.RecursiveSolve((SudokuPuzzle)sudoku.Clone(), 0, 0, ref count, true);
multipleSolutions = count > 1;
return(count != 0);
}
/// <summary>
/// Fills an existing <see cref="SudokuPuzzle"/> with numbers.
/// </summary>
/// <param name="sudoku">The puzzle to fill with numbers.</param>
/// <exception cref="ArgumentNullException"><c><paramref name="sudoku"/></c> is <c>null</c>.</exception>
public static void AddNumbers(SudokuPuzzle sudoku)
{
if (sudoku is null)
{
throw new ArgumentNullException(nameof(sudoku));
}
sudoku.DisablePossible = true;
SudokuSolver.RecursiveSolve(sudoku);
sudoku.DisablePossible = false;
sudoku.ResetPossible();
sudoku.ClearReadOnlyProperties();
sudoku.SetSolutions();
}
/// <summary>
/// Solve the specified <see cref="T:Sudoku.Sudoku"/> puzzle using recursion, otherwise known as "brute-force".
/// </summary>
/// <param name="sudoku">The <see cref="T:Sudoku.Sudoku"/> puzzle to solve.</param>
/// <exception cref="ArgumentNullException"><c><paramref name="sudoku"/></c> is <c>null</c>.</exception>
public static void RecursiveSolve(SudokuPuzzle sudoku)
{
if (sudoku is null)
{
throw new ArgumentNullException(nameof(sudoku));
}
int count = 0;
sudoku.DisablePossible = true;
SudokuSolver.RecursiveSolve(sudoku, 0, 0, ref count);
sudoku.DisablePossible = false;
sudoku.ResetPossible();
}
private void CheckIfDigit(object sender, TextCompositionEventArgs e)
{
try
{
if (!char.IsDigit(e.Text, e.Text.Length - 1))
{
e.Handled = true;
return;
}
else
{
(sender as TextBox).Text = e.Text;
}
var sudokuToSolve = new SudokuCell[9, 9];
var sudokuValidator = new SudokuSolver();
var counter = 0;
var numbersCount = 0;
for (int row = 0; row < 9; row++)
{
for (int col = 0; col < 9; col++)
{
var textBox = this.FindName("TextBox" + counter) as TextBox;
sudokuToSolve[row, col] = new SudokuCell(row, col);
if (textBox.Text != string.Empty)
{
sudokuToSolve[row, col].Value = int.Parse(textBox.Text);
numbersCount++;
}
counter++;
}
}
if (numbersCount == 81)
{
if (!sudokuValidator.CheckIfSudokuIsValid(sudokuToSolve))
{
MessageBox.Show("This sudoku is not valid! Please check for errors!", "Warning");
return;
}
MessageBox.Show("Congratulations! You solved this sudoku for: " + GetTime() + "!");
}
}
catch (Exception)
{
}
}
public static void Main(string[] args)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var sudoku = new Sudoku("./input.txt");
var visualiser = new SudokuVisualiser(sudoku);
var solver = new SudokuSolver(sudoku, visualiser);
solver.Solve();
stopWatch.Stop();
Console.WriteLine($"Finished in {stopWatch.Elapsed}");
}
public void ClearGrid(GridOptions options)
{
this.cageInfo = null;
this.gridOptions = options;
values = new int[Cells, Cells];
flags = new CellFlags[Cells, Cells];
for (int x = 0; x < Cells; ++x)
{
for (int y = 0; y < Cells; ++y)
{
values[x, y] = -1;
flags[x, y] = CellFlags.Free;
}
}
solver = new SudokuSolver(this);
}
private void button_Solve_Click(object sender, EventArgs e)
{
var timer = Stopwatch.StartNew();
SudokuSolver sudokuSolver = new SudokuSolver(Sudoku);
sudokuSolver.SolveSudoku();
var log = sudokuSolver.Log;
Heatmap = log.Heatmap;
textBox_Log.Text = log.LogText;
Text = timer.ElapsedMilliseconds + " ms";
pictureBox1.Refresh();
}
private static bool RecursiveSolveNextNumber(SudokuPuzzle sudoku, int row, int column, ref int count, bool findMultiple = false)
{
int nextColumn = column + 1, nextRow = row;
if (nextColumn == sudoku.Size)
{
nextRow++;
nextColumn = 0;
}
if (nextRow == sudoku.Size)
{
count++;
return(true);
}
return(SudokuSolver.RecursiveSolve(sudoku, nextRow, nextColumn, ref count, findMultiple));
}
private void textBox_SudokuStr_Validated(object sender, EventArgs e)
{
var str = textBox_SudokuStr.Text.Trim();
// Check how many chars
if (str.Length != 9 * 9)
{
return;
}
// check each char
foreach (var c in str)
{
if ((c != '.')
&&
(c < '0' || c > '9'))
{
return;
}
}
// Clear model
Sudoku.Initialize();
PresetIndexes.Clear();
for (byte i = 0; i < str.Length; i++)
{
char c = str[i];
byte byteVal = c == '.' ? NDEF_VALUE : (byte)(c - '0');
Sudoku[i] = byteVal;
if (byteVal != NDEF_VALUE)
{
PresetIndexes.Add(i);
}
}
// Init solver
Solver = new SudokuSolver(Sudoku);
// Repaint
pictureBox1.Refresh();
}
/// <summary>
/// Removes numbers from an existing <see cref="SudokuPuzzle"/> according to its difficulty.
/// </summary>
/// <param name="sudoku">The <see cref="SudokuPuzzle"/> to remove numbers from.</param>
/// <exception cref="ArgumentNullException"><c><paramref name="sudoku"/></c> is <c>null</c>.</exception>
public static void RemoveNumbers(SudokuPuzzle sudoku)
{
if (sudoku is null)
{
throw new ArgumentNullException(nameof(sudoku));
}
sudoku.ClearReadOnlyProperties();
int attempts = 45;
switch (sudoku.Difficulty)
{
case SudokuDifficulty.Medium:
attempts = 60;
break;
case SudokuDifficulty.Hard:
attempts = 75;
break;
}
do
{
int row, column;
do
{
row = SudokuGenerator.Random.Next(sudoku.Size);
column = SudokuGenerator.Random.Next(sudoku.Size);
} while (sudoku[row, column] == 0);
int value = sudoku[row, column];
sudoku[row, column] = 0;
bool solvable = SudokuSolver.CheckSolvable(sudoku, out bool multipleSolutions);
if (!solvable || multipleSolutions)
{
sudoku[row, column] = value;
}
} while (attempts-- > 0);
sudoku.SetReadOnlyProperties();
}
public void ResetSolver()
{
if (cageInfo != null)
{
cageInfo.Reset();
}
for (int x = 0; x < Cells; x++)
{
for (int y = 0; y < Cells; y++)
{
if (FlagAt(x, y) == CellFlags.Solved)
{
flags[x, y] = CellFlags.Free;
values[x, y] = -1;
}
}
}
solver = new SudokuSolver(this);
Updated();
}
private List <byte> EliminationSearch(IEnumerable <byte> rowColCellSearchSolutions)
{
var eliminationSearchSolutions = new List <byte>();
foreach (var recentlyFoundIndex in rowColCellSearchSolutions)
{
var eliminatedElements = new List <byte>();
// store digit for later
var digit = Sudoku[recentlyFoundIndex];
// Remove all line, col and cell entries (cannot go there again)
foreach (var removerIndex in
SudokuSolver.GetRowIterator(recentlyFoundIndex)
.Union(SudokuSolver.GetColIterator(recentlyFoundIndex))
.Union(SudokuSolver.GetCellIterator(recentlyFoundIndex))
)
{
var possibleSolutions = PossibilitySpace[removerIndex];
// Check if already set
if (possibleSolutions is null)
{
continue;
}
// Remove possibility
possibleSolutions.Remove(digit);
// check if only solution
if (possibleSolutions.Count == 1)
{
ProcessNewMatch(possibleSolutions.First(), (byte)removerIndex, ref eliminatedElements);
}
}
eliminationSearchSolutions.AddRange(eliminatedElements);
}
return(eliminationSearchSolutions);
}
private bool CheckMoveMade(int row, int column, int number, SudokuPattern pattern)
{
if (this.Moves.Count == 0)
{
return(false);
}
int count = 0;
foreach (SudokuMove move in this)
{
count++;
int nextCount = 0;
foreach (SudokuMove nextMove in this)
{
nextCount++;
if (Object.ReferenceEquals(move, nextMove))
{
continue;
}
if (SudokuSolver.Compare(move.Rows, nextMove.Rows) && SudokuSolver.Compare(move.Columns, nextMove.Columns) && SudokuSolver.Compare(move.Numbers, nextMove.Numbers) && move.Pattern == nextMove.Pattern)
{
return(true);
}
}
}
foreach (SudokuMove move in this)
{
if (move.Pattern == pattern && move.Rows.Contains(row) && move.Columns.Contains(column) && move.Numbers.Contains(number))
{
return(true);
}
}
return(false);
}
public static void Main (string[] args)
{
int[,] input = new int[9,9] {
{7,2,0,0,3,9,0,0,6},
{0,0,0,0,5,0,3,0,1},
{0,0,0,0,0,7,0,0,5},
{0,0,0,0,0,0,1,0,0},
{9,0,6,0,0,0,0,0,2},
{0,3,0,0,0,0,5,0,0},
{3,7,0,0,0,4,8,0,0},
{6,0,8,9,7,0,0,3,0},
{5,0,0,0,0,0,0,0,0}
};
// int[,] input = new int[9,9] {
// {7,2,5,1,3,9,4,8,6},
// {4,6,9,2,5,8,3,7,1},
// {1,8,3,4,6,7,9,2,5},
// {8,4,7,5,9,2,1,6,3},
// {9,5,6,3,8,1,7,4,2},
// {2,3,1,7,4,6,5,9,8},
// {3,7,2,6,1,4,8,5,9},
// {6,1,8,9,7,5,2,3,4},
// {5,9,4,8,2,3,6,1,7}
// };
// int[,] input = new int[4, 4] {
// { 0, 2, 0, 1 } ,
// { 1, 0, 0, 4 } ,
// { 0, 4, 1, 3 } ,
// { 3, 0, 4, 0 }
// };
SudokuSolver ss = new SudokuSolver (input);
ss.Print ();
Console.WriteLine ("");
}
private static bool RecursiveSolve(SudokuPuzzle sudoku, int row, int column, ref int count, bool findMultiple = false)
{
if (sudoku[row, column] != 0)
{
return(SudokuSolver.RecursiveSolveNextNumber(sudoku, row, column, ref count, findMultiple));
}
List <int> possible = new List <int>();
for (int i = 1; i <= sudoku.Size; i++)
{
if (!(sudoku.RowContains(row, i) || sudoku.ColumnContains(column, i) || sudoku.BlockContains(row, column, i)))
{
possible.Add(i);
}
}
SudokuSolver.ShuffleNumbers(possible);
while (possible.Count > 0)
{
sudoku[row, column] = possible[0];
bool solvable = SudokuSolver.RecursiveSolveNextNumber(sudoku, row, column, ref count, findMultiple);
if (solvable)
{
if (!findMultiple || count > 1)
{
return(true);
}
}
possible.RemoveAt(0);
}
sudoku[row, column] = 0;
return(false);
}
public static void Main(string[] args)
{
int[,] input = new int[9,9] {
{7,2,0,0,3,9,0,0,6},
{0,0,0,0,5,0,3,0,1},
{0,0,0,0,0,7,0,0,5},
{0,0,0,0,0,0,1,0,0},
{9,0,6,0,0,0,0,0,2},
{0,3,0,0,0,0,5,0,0},
{3,7,0,0,0,4,8,0,0},
{6,0,8,9,7,0,0,3,0},
{5,0,0,0,0,0,0,0,0}
};
// int[,] input = new int[9,9] {
// {7,2,5,1,3,9,4,8,6},
// {4,6,9,2,5,8,3,7,1},
// {1,8,3,4,6,7,9,2,5},
// {8,4,7,5,9,2,1,6,3},
// {9,5,6,3,8,1,7,4,2},
// {2,3,1,7,4,6,5,9,8},
// {3,7,2,6,1,4,8,5,9},
// {6,1,8,9,7,5,2,3,4},
// {5,9,4,8,2,3,6,1,7}
// };
// int[,] input = new int[4, 4] {
// { 0, 2, 0, 1 } ,
// { 1, 0, 0, 4 } ,
// { 0, 4, 1, 3 } ,
// { 3, 0, 4, 0 }
// };
SudokuSolver ss = new SudokuSolver (input);
ss.Print ();
Console.WriteLine ("");
}
public static SudokuCandidate[] CheckRemains(SudokuSolver ss, SudokuGrid.CageInfo info, int cage, int ex)
{
int s = info.remaining_sizes[cage];
if (s == 1)
{
// One empty cell remains in the cage, so make the total
int total = info.remaining_totals[cage];
return(Filter(ss, cage, (int n) => (n == total)));
}
/*
* else if(s > 1)
* {
* // 's' numbers left to choose from
* int total = info.remaining_totals[cage];
* int m0 = total - 45 + (11 - s) * (10 - s) / 2;
* int m1 = total - s * (s - 1) / 2;
* Filter(ss, cage, (int n) => n == ex || (n >= m0 && n <= m1));
* }
* */
return(null);
}
static void Main(string[] args)
{
var boardMaster = new SudokuSolver();
// var board = boardMaster.SetBoard();
var board = boardMaster.ReadBoardFromFile();
var result = boardMaster.Solve(board);
foreach (var salution in result)
{
boardMaster.Print(salution);
Console.WriteLine(new string('-', 17));
}
if (result.Count() > 1)
{
Console.WriteLine("Salutions count: " + result.Count());
}
else if (result.Count() == 0)
{
Console.WriteLine("No solution possible!");
}
}
public static void Main(string[] args)
{
bool verbose = false;
if (args.Length > 0)
{
verbose = args[0].Equals("v");
}
int i = 0;
int[][] matrix = new int[9][];
while (i < 9)
{
string s = Console.ReadLine();
string[] line = s.Split(' ');
if (line.Length == 9)
{
int[] intArr = new int[9];
for (int j = 0; j < 9; j++)
{
int x = int.Parse(line[j]);
intArr[j] = x;
}
//sud.AddRow(intArr);
matrix[i] = intArr;
i++;
}
else
{
//invalid, please retype
Console.WriteLine("invalid line, please retype");
continue;
}
}
Console.WriteLine();
PrintMatrix(matrix);
DateTime startTime = DateTime.Now;
Console.WriteLine("Started: {0}", startTime);
//SudokuSolver_old solver = new SudokuSolver_old(sud);
//solver.Iterate(false);
SudokuSolver solver = new SudokuSolver(matrix, verbose);
solver.Solve();
DateTime stopTime = DateTime.Now;
Console.WriteLine("Stopped: {0}", stopTime);
Console.WriteLine("solution generated: {0}", solver.possibleSolutions.Count);
Console.WriteLine("backtracks: {0}", solver.deadendCount);
foreach (int[][] solution in solver.possibleSolutions)
{
PrintMatrix(solution);
}
Console.WriteLine();
TimeSpan elapsedTime = stopTime - startTime;
Console.WriteLine("Elapsed: {0}", elapsedTime);
Console.WriteLine("in hours :" + elapsedTime.TotalHours);
Console.WriteLine("in minutes :" + elapsedTime.TotalMinutes);
Console.WriteLine("in seconds :" + elapsedTime.TotalSeconds);
Console.WriteLine("in milliseconds:" + elapsedTime.TotalMilliseconds);
}
private void SolverToolStripMenuItem_Click(object sender, EventArgs e)
{
DialogResult EstaSeguro = MessageBox.Show("Esta seguro que desea resolver el sudoku actual? No podra terminarlo una vez haya confirmado."
, "Resolver Sudoku?", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (EstaSeguro == DialogResult.Yes)
{
Sudoku ToBeSolved;
List<int> Fields = new List<int>();
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (Texts[i][j].Text == "")
Fields.Add(0);
else
Fields.Add(int.Parse(Texts[i][j].Text));
}
}
ToBeSolved = new Sudoku(Fields);
SudokuSolver Solver = new SudokuSolver();
Sudoku Result = Solver.Solve(ToBeSolved, false, 4);
Resolviendo = true;
Display(Result);
Resolviendo = false;
SolverToolStripMenuItem.Enabled = false;
}
else
{
MessageBox.Show("Adelante no te desesperes, todavia se puede!", "Tu puedes", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
private void SolveSudoku()
{
//Clear user input
grid.ClearUserCells();
//Init solver and do magic
SudokuSolver solver = new SudokuSolver(grid);
solver.Solve();
RefreshCellValues();
}
static void Main(string[] args)
{
int[,] professorSudoku = new int[9, 9] {
{ 3, 7, 0, 5, 0, 0, 0, 0, 6 },
{ 0, 0, 0, 3, 6, 0, 0, 1, 2 },
{ 0, 0, 0, 0, 9, 1, 7, 5, 0 },
{ 0, 0, 0, 1, 5, 4, 0, 7, 0 },
{ 0, 0, 3, 0, 7, 0, 6, 0, 0 },
{ 0, 5, 0, 6, 3, 8, 0, 0, 0 },
{ 0, 6, 4, 9, 8, 0, 0, 0, 0 },
{ 5, 9, 0, 0, 2, 6, 0, 0, 0 },
{ 2, 0, 0, 0, 0, 5, 0, 6, 4 }
};
// World most difficult sudoku
// http://aisudoku.com/index_en.html
// http://www.telegraph.co.uk/news/science/science-news/9359579/Worlds-hardest-sudoku-can-you-crack-it.html
// http://www.mirror.co.uk/news/weird-news/worlds-hardest-sudoku-puzzle-ever-942299
int[,] worldSudoku = new int[9, 9] {
{ 8, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 3, 6, 0, 0, 0, 0, 0 },
{ 0, 7, 0, 0, 9, 0, 2, 0, 0 },
{ 0, 5, 0, 0, 0, 7, 0, 0, 0 },
{ 0, 0, 0, 0, 4, 5, 7, 0, 0 },
{ 0, 0, 0, 1, 0, 0, 0, 3, 0 },
{ 0, 0, 1, 0, 0, 0, 0, 6, 8 },
{ 0, 0, 8, 5, 0, 0, 0, 1, 0 },
{ 0, 9, 0, 0, 0, 0, 4, 0, 0 }
};
SudokuSolver ss = new SudokuSolver(professorSudoku);
Console.WriteLine("--------------- ProfessorSudoku ---------------\n{0}", ss);
if (ss.Backtracking())
{
Console.WriteLine("ProfessorSudoku - Simple Backtracking SOLUTION in {0} steps :\n{1}", SudokuSolver.NCALL, ss);
}
else
{
Console.WriteLine("ProfessorSudoku - Simple Backtracking NO SOLUTION");
}
ss.SetSudoku(professorSudoku);
ss.PreliminaryCheck();
if (ss.BacktrackingConstr())
{
Console.WriteLine("Sudoku - Constraint Propagation SOLUTION in {0} steps :\n{1}", SudokuSolver.NCALL, ss);
}
else
{
Console.WriteLine("Sudoku - Constraint Propagation NO SOLUTION");
}
ss.SetSudoku(worldSudoku);
Console.WriteLine("--------------- World most difficult Sudoku ---------------\n{0}", ss);
if (ss.Backtracking())
{
Console.WriteLine("World most difficult - Simple Backtracking SOLUTION in {0} steps :\n{1}", SudokuSolver.NCALL, ss);
}
else
{
Console.WriteLine("World most difficult - Simple Backtracking NO SOLUTION");
}
ss.SetSudoku(worldSudoku);
ss.PreliminaryCheck();
if (ss.BacktrackingConstr())
{
Console.WriteLine("Sudoku - Constraint Propagation SOLUTION in {0} steps :\n{1}", SudokuSolver.NCALL, ss);
}
else
{
Console.WriteLine("Sudoku - Constraint Propagation NO SOLUTION");
}
/*
* //TIC
* var watch = Stopwatch.StartNew();
*
* ss.SetSudoku(sudoku);
*
* if (ss.RelaxationLabelingALC())
* Console.WriteLine("Sudoku - Relaxation Labeling SOLUTION in {0} steps :\n{1}", SudokuSolver.NCALL, ss);
* else
* Console.WriteLine("Sudoku - Relaxation Labeling NO SOLUTION");
*
* //TOC
* watch.Stop();
* var elapsedMs = watch.ElapsedMilliseconds;
* Console.WriteLine("[DEBUG]> Elapsed time: {0}", elapsedMs);
*/
Console.ReadLine();
}
public List <SmallSquare> GetAllPossibleSquares(List <SmallSquare> listOfSquares, int xPosition, int yPosition, HashSet <string> invalidFields, int smallSquareNumber)
{
int elementCounter = 0;
if (listOfSquares.Count == 0)
{
listOfSquares.Add(this);
}
if (yPosition == 3)
{
System.Diagnostics.Debug.WriteLine("GetAllPossibleSquares return");
Dictionary <string, SmallSquare> newList = new Dictionary <string, SmallSquare>();
foreach (SmallSquare sq in listOfSquares)
{
bool isOK = true;
if (smallSquareNumber < 6)
{
for (int y = 0; y < 3; y++)
{
for (int x = 0; x < 3; x++)
{
if (!sq.Fields[y, x].IsFixed)
{
if (invalidFields.Contains(SudokuSolver.GetBlockListEntry(smallSquareNumber, sq.Fields[y, x].FieldValue, x, y)))
{
isOK = false;
break;
}
}
if (!isOK)
{
break;
}
}
}
}
if (isOK && sq.IsComplete())
{
if (!newList.ContainsKey(sq.GetKey()))
{
newList.Add(sq.GetKey(), sq);
}
}
}
if (!newList.Any())
{
System.Diagnostics.Debug.WriteLine("no results");
}
return(newList.Select(val => val.Value).ToList());
}
Dictionary <string, SmallSquare> newSquares = new Dictionary <string, SmallSquare>();
foreach (SmallSquare existingSquare in listOfSquares)
{
elementCounter = 0;
for (int x = 0; x < 9; x++)
{
SmallSquare newSquare = Program.DeepClone(existingSquare);
HashSet <int> availableNumbers = newSquare.GetNumbersStillAvailable();
if (newSquare.Fields[yPosition, xPosition].IsFixed == false)
{
newSquare.Fields[yPosition, xPosition].FieldValue = availableNumbers.ElementAt(elementCounter);
elementCounter++;
}
if (!newSquares.ContainsKey(newSquare.GetKey()))
{
newSquares.Add(newSquare.GetKey(), newSquare);
}
if (availableNumbers.Count() == elementCounter)
{
break;
}
}
}
if (xPosition == 2)
{
xPosition = 0;
yPosition++;
}
else
{
xPosition++;
}
return(GetAllPossibleSquares(newSquares.Select(val => val.Value).ToList(), xPosition, yPosition, invalidFields, smallSquareNumber));
}
public Sudoku Resolver(Sudoku ToBeSolved)
{
SudokuSolver Solver = new SudokuSolver();
Sudoku Result = Solver.Solve(ToBeSolved, false, 4);
return Result;
}
public Boolean sePuedeResolver(Sudoku ToBeSolved)
{
SudokuSolver Solver = new SudokuSolver();
Sudoku Result = Solver.Solve(ToBeSolved, false, 4);
if (Result != null)
return true;
else
return false;
}
private bool DeleteField(Sudoku temp, ref int difficulty)
{
int i = Rnd.Next(0, 9); ;
int j = Rnd.Next(0, 9); ;
// select random not yet deleted field
while (!temp.Fields[i][j].Filled)
{
i = Rnd.Next(0, 9);
j = Rnd.Next(0, 9);
}
temp.Fields[i][j].Value = 0;
temp.Fields[i][j].Filled = false;
SudokuSolver Test = new SudokuSolver();
int Difficulty = difficulty;
// check the desired characteristics
Sudoku Temp = Test.Solve(temp.Copy(), true, Difficulty);
if (Temp == null)
return false;
temp.Difficulty = Temp.Difficulty;
if (Temp.NrSolutions > 1 || Temp.Difficulty > Difficulty)
return false;
else
return true;
}
