public void SetBlockTest() { int[,] setBlockTestPuzzle = { { 1, 2, 0, 4 }, { 3, 4, 0, 2 }, { 2, 3, 0, 1 }, { 4, 1, 0, 3 } }; Sudoku sudoku = new Sudoku(setBlockTestPuzzle); sudoku.SetBlock(0, 2, 3); Assert.AreEqual(sudoku.AvailableValuesInRow(0).Count, 0); Assert.AreEqual(sudoku.AvailableValuesInColumn(2).Count, 3); Assert.AreEqual(sudoku.AvailableValuesInGrid(1).Count, 1); sudoku.SetBlock(1, 2, 1); Assert.AreEqual(sudoku.AvailableValuesInRow(1).Count, 0); Assert.AreEqual(sudoku.AvailableValuesInColumn(2).Count, 2); Assert.AreEqual(sudoku.AvailableValuesInGrid(1).Count, 0); sudoku.SetBlock(2, 2, 4); Assert.AreEqual(sudoku.AvailableValuesInRow(2).Count, 0); Assert.AreEqual(sudoku.AvailableValuesInColumn(2).Count, 0); Assert.AreEqual(sudoku.AvailableValuesInGrid(3).Count, 0); Assert.IsTrue(sudoku.Solved); }
public void EgalPlusValeurCTest_DoitReussir() { int[] TabRef = { 1, 0, 0, 0, 0, 1, 0, 0, 0 }; int[,] GrilleTest = { { 1, 2, 3, 4, 5, 6, 7, 8, 0 }, { 4, 5, 6, 0, 8, 0, 5, 4, 1 }, { 7, 8, 0, 4, 0, 0, 6, 3, 2 }, { 4, 9, 0, 6, 2, 1, 0, 0, 3 }, { 5, 2, 7, 0, 0, 0, 1, 6, 4 }, { 6, 0, 0, 5, 7, 4, 0, 9, 5 }, { 7, 4, 5, 0, 0, 9, 7, 0, 6 }, { 8, 3, 2, 0, 5, 0, 8, 4, 7 }, { 0, 6, 1, 6, 5, 4, 3, 2, 1 } }; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire. Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest); Sudoku.Cellule Case = new Sudoku.Cellule(0, 0, 0); for (int i = 1; i < Case.PropValPossibles.Length; i++) { Case.PropValPossibles[i] = 0; } Case.PropValPossibles[0] = 1; Case.PropValPossibles[5] = 1; Case.PropValPossibles[6] = 1; // Toutes les valeurs du champs de de la case sont nulles sauf 3, dont deux qui correspond à celles non nulles dans le tableau de reférence. Assert.IsTrue(GrilleDeSudoku.EgalPlusValeurC(Case, TabRef)); // Donc le test réussi, il n'y a qu'une seule valeur C en plus de A et B. }
public void ConstructorTests() { Sudoku sudoku = new Sudoku(testPuzzle); Assert.AreEqual(sudoku.GridSize, 9); Assert.AreEqual(sudoku.NumBlocksUnknown, 45); Assert.IsFalse(sudoku.Solved); }
public SudokuForm() { InitializeComponent(); sdk = new Sudoku(); this.dataGridViewSudoku.Rows.Add(9); this.dataGridViewAnswer.Rows.Add(9); this.dataGridViewAnswer.Visible = false; //this.textBoxResult.Visible = false; }
public void AvailableValuesInRowTest() { Sudoku sudoku = new Sudoku(testPuzzle); var expectedValues = new List<int>() { 1, 2, 5, 6 }; var vals = sudoku.AvailableValuesInRow(0); Assert.AreEqual(vals.Count, 4); foreach (var val in vals) { Assert.IsTrue(expectedValues.Contains(val)); } }
public void AvailableValuesInColumnTest() { Sudoku sudoku = new Sudoku(testPuzzle); var expectedValues = new List<int>() { 2, 3, 5, 6, 7, 8, 9 }; var vals = sudoku.AvailableValuesInColumn(4); Assert.AreEqual(vals.Count, 7); foreach (var val in vals) { Assert.IsTrue(expectedValues.Contains(val)); } }
public void SolveAFile(string filePath) { string line; System.IO.StreamReader file = new System.IO.StreamReader(filePath); int currentLineIndex = 0; while ((line = file.ReadLine()) != null) { string[] sudokulineElements = line.Split(','); string inputProblem = sudokulineElements[0]; string expectedSolution = sudokulineElements[1]; Sudoku.Sudoku sudoku = new Sudoku.Sudoku(inputProblem); //RenderNewEntries(sudoku, Color.Black); //MessageBox.Show($"Problem {counter} loaded from DB. Click to Solve "); bool isSovled = sudoku.Solve(); string solution = sudoku.ToString(); if (isSovled) { if (!solution.Equals(expectedSolution)) { throw new Exception($"Sudoku solution does not match input solution excped: {expectedSolution}.\n Actual {solution}"); } Console.WriteLine("Solved a Problem. Rating=" + sudoku.DifficultyRating); } else { throw new Exception($"Sudoku could not be solved. Incompelete solution is {solution} expected solution was {expectedSolution}"); } currentLineIndex++; } file.Close(); }
public void UneSeuleValeurLigneTest_DoitReussir() { int[,] GrilleTest = { { 1, 2, 3, 4, 5, 6, 7, 8, 0 }, { 0, 1, 9, 0, 8, 0, 5, 4, 1 }, { 0, 0, 8, 4, 0, 0, 6, 3, 2 }, { 5, 9, 0, 6, 2, 1, 0, 0, 3 }, { 0, 2, 7, 0, 0, 0, 1, 6, 4 }, { 0, 0, 0, 5, 7, 4, 0, 9, 5 }, { 0, 8, 5, 0, 0, 9, 7, 0, 6 }, { 9, 3, 0, 0, 5, 0, 8, 4, 7 }, { 0, 0, 2, 0, 6, 0, 0, 0, 8 } }; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire. Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest); GrilleDeSudoku.ReInitialiseTableauPossiblesAChaqueCellule(); Assert.AreEqual(GrilleDeSudoku.UneSeuleValeurLigne(0, 8), 9); // Pour la ligne 0 et colonne 8, seule la valeur 9 est possible, on a bien 9 en paramètre, le test est réussi. }
public void UneSeuleValeurColonneTest_DoitEchouer() { int[,] GrilleTest = { { 1, 2, 3, 4, 5, 6, 7, 8, 0 }, { 2, 1, 9, 0, 8, 0, 5, 4, 1 }, { 3, 0, 8, 4, 0, 0, 6, 3, 2 }, { 4, 9, 0, 6, 2, 1, 0, 0, 3 }, { 5, 2, 7, 0, 0, 0, 1, 6, 4 }, { 6, 0, 0, 5, 7, 4, 0, 9, 5 }, { 7, 4, 5, 0, 0, 9, 7, 0, 6 }, { 8, 3, 2, 0, 5, 0, 8, 4, 7 }, { 0, 6, 1, 6, 5, 4, 3, 2, 1 } }; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire. Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest); GrilleDeSudoku.ReInitialiseTableauPossiblesAChaqueCellule(); Assert.AreEqual(GrilleDeSudoku.UneSeuleValeurColonne(8, 0), 3); // Pour la ligne 8 et colonne 0, seule la valeur 9 est possible, le test échoue à cause de la valeur 3 en paramètre. }
public void zGeneralTests() { var values = @"004300209005009001070060043006002087190007400050083000600000105003508690042910300"; Regex regularExpression = new Regex("[^0-9]"); string result = regularExpression.Replace(values, ""); Sudoku.Sudoku cloneWithSortedCells = new Sudoku.Sudoku(result); cloneWithSortedCells.EliminatePossibilitiesFromUnsetCells(); cloneWithSortedCells.EliminatePossibilitiesFromUnsetCells(); SudokuCell[][] cells = cloneWithSortedCells.GetSudokuCellsCopy(); SudokuCell[] linearArray = new SudokuCell[81]; for (int rowIndex = 0; rowIndex <= 8; rowIndex++) { for (int colIndex = 0; colIndex <= 8; colIndex++) { linearArray[rowIndex * 9 + colIndex] = cells[rowIndex][colIndex]; } } Array.Sort(linearArray); for (int index = 0; index < linearArray.Length; index++) { if (linearArray[index].Value == 0) { Console.Write($"({linearArray[index].RemainingPossibilities.Count}) "); } } }
public void EgalPlusValeurCTest_DoitEchouer() { int[] TabRef = { 1, 0, 0, 0, 0, 1, 0, 0, 0 }; int[,] GrilleTest = { { 1, 2, 3, 4, 5, 6, 7, 8, 0 }, { 4, 5, 6, 0, 8, 0, 5, 4, 1 }, { 7, 8, 0, 4, 0, 0, 6, 3, 2 }, { 4, 9, 0, 6, 2, 1, 0, 0, 3 }, { 5, 2, 7, 0, 0, 0, 1, 6, 4 }, { 6, 0, 0, 5, 7, 4, 0, 9, 5 }, { 7, 4, 5, 0, 0, 9, 7, 0, 6 }, { 8, 3, 2, 0, 5, 0, 8, 4, 7 }, { 0, 6, 1, 6, 5, 4, 3, 2, 1 } }; // A noter que la grille n'est pas une réelle grille de sudoku mais peut être utilisée pour un test unitaire. Sudoku.Sudoku GrilleDeSudoku = new Sudoku.Sudoku(GrilleTest); Sudoku.Cellule Case = new Sudoku.Cellule(0, 0, 0); for (int i = 0; i < Case.PropValPossibles.Length; i++) { Case.PropValPossibles[i] = 1; } // Toutes les valeurs du champs de de la case sont vallent 1. Assert.IsTrue(GrilleDeSudoku.EgalPlusValeurC(Case, TabRef)); // Donc le champs contient A et B mais aussi pleins d'autres valeurs, le test échoue. }
public void GenerateGame() { if (PlaySound != null) { PlaySound(SudokuSound.Stop); } UseTemplate(); int trials_counter = 0; int trials_max = 100; SolveMethods M = SolveMethods.All; // Generating a list of filled squares List <Point> L = new List <Point>(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (s[j, i] > 0) { L.Add(new Point(i, j)); } } } int n; for (n = 0; n < 55;) { int index = R.Next(L.Count); int x = L[index].X; int y = L[index].Y; int temp = s[x, y]; if (temp != 0) { s[x, y] = 0; Sudoku S2 = CreateCopy(); int solutionStepsCount = S2.ComputePossibleSteps(M).Count(); bool range0Ok = ((n > 35) && (solutionStepsCount > 25)); bool range1Ok = ((n > 15) && (solutionStepsCount > 25)); bool range2Ok = n < 16; bool solutionStepsCountOk = range0Ok || range1Ok || range2Ok; if (solutionStepsCountOk) { bool isSolvable = S2.SolvePuzzle(M); if (isSolvable) { L.RemoveAt(index); n++; trials_counter = 0; } else { s[x, y] = temp; } } else { s[x, y] = temp; } trials_counter++; } if (trials_counter > trials_max) { break; } } ScrambleGame(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (s[i, j] == 0) { f[i, j] = 0; } else { f[i, j] = 1; } } } // SetGameString("XX7XXX5XXXXXX4XX3XXXX832X9X8XXXXX4XXX294X586XXX6XXXXX7X5X364XXXX7XX5XXXXXX3XXX2XX"); EnumeratePossibilities(); starttime = DateTime.Now; DisplayMessage = false; if (PlaySound != null) { PlaySound(SudokuSound.NewPuzzle); } if (RequestRepaint != null) { RequestRepaint(); } }
private bool SolveByTryingPossibilities() { if (!IsAValidState()) { return(false); } int unsolvedCells = CountUnsolvedCells(); if (unsolvedCells == 0) { return(Solved); } SudokuCell[] linearArray = new SudokuCell[81]; for (int rowIndex = 0; rowIndex <= 8; rowIndex++) { for (int colIndex = 0; colIndex <= 8; colIndex++) { linearArray[rowIndex * 9 + colIndex] = sudokuCells[rowIndex][colIndex]; } } //Sorted array by remaining possibilities. Array.Sort(linearArray); foreach (var cell in linearArray) { int rowIndex = cell.RowIndex; int colIndex = cell.ColIndex; if (cell.Value == 0) { var remainingDigitsOnThisCell = cell.RemainingPossibilities; if (remainingDigitsOnThisCell.Count == 0) { Logger.WriteLine("Invalid situation. remainingDigitsOnThisCell.Count == 0 ", _cloningDepth); return(false); } //if (cloningDepth == 0) { Logger.WriteLine($"Evaluating Cell@{cell} ", _cloningDepth); Logger.WriteLine(ToStringFormatted(), _cloningDepth); } foreach (var possibility in remainingDigitsOnThisCell) { //Set this possibility and try to solve. Sudoku clone = new Sudoku(this.ToString()); clone._cloningDepth = this._cloningDepth + 1; clone.sudokuCells[rowIndex][colIndex].Value = possibility; if (clone.Solve()) { //if (cloningDepth == 0) { Logger.WriteLine($"Valid Solution found for Cell@{cell} new Value {possibility}", _cloningDepth); Logger.WriteLine($"\n{clone.ToStringFormatted()}", _cloningDepth); } cell.SolvingDifficulty = SolvingDifficulty.MaxDifficulty; cell.Value = possibility; CopyUnSolvedCellsFromSolution(clone); return(Solved); } } if (_cloningDepth == 0) { throw new Exception("No possibility worked. Root problem is not right"); } Logger.WriteLine($"No possibility worked for Cell@{cell}. Impossible situation. Should be backtraced.", _cloningDepth); return(Notsolved); } } return(Notsolved); }
static void Main(string[] args) { Sudoku.Run(args); }
/// The main entry point for the application. static void Main(string[] args) { using (Sudoku game = new Sudoku()) { game.Run(); } }
private void button1_Click(object sender, EventArgs e) { Sudoku.Solve(); }
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); } }
public Sudoku Resolver(Sudoku ToBeSolved) { SudokuSolver Solver = new SudokuSolver(); Sudoku Result = Solver.Solve(ToBeSolved, false, 4); return Result; }
public Sudoku(Sudoku instance) { array = (byte[, ])instance.array.Clone(); }
public SudokuCell[][] GetSudokuCellsCopy() { Sudoku clone = new Sudoku(ToString()); return(clone.sudokuCells); }
/// <summary> /// Takes action according to the keyboard button pressed. /// - If it is a number from numpad or from the main keyboard, /// it writes it down or overwrites the current number in that field. /// - If it is up/down/left/right/tab/enter, /// it selects the respective cell. /// - If it is escape/backspace or delete, /// it deletes the value in the cell. /// - Else, it doesn't do anything. /// - It checks if the grid has been solved, /// and prompts a window according to the result. /// - If the grid is full but it isn't a valid solution to the game, /// it doesn't do anything. /// - If the grid is solved but the time does not make it in the top 5, /// it prompts a MessageBox /// - If the grid is solved AND the time makes it in the top 5, /// it prompts a new form, that asks for the player's name /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void dataGridView_KeyDown(object sender, KeyEventArgs e) { if (standard == null && squiggly == null) { System.Media.SystemSounds.Asterisk.Play(); return; } if (dataGridView.SelectedCells.Count > 0) { var selected = dataGridView.SelectedCells[0]; int sel_i = selected.RowIndex; int sel_j = selected.ColumnIndex; if (CellMap[sel_i, sel_j] == LOCKED) { if (!(e.KeyCode == Keys.Enter || e.KeyCode == Keys.Tab || e.KeyCode == Keys.Up || e.KeyCode == Keys.Down || e.KeyCode == Keys.Left || e.KeyCode == Keys.Right)) { System.Media.SystemSounds.Asterisk.Play(); } return; } if (!(e.KeyValue >= 49 && e.KeyValue <= 57 || e.KeyValue >= 97 && e.KeyValue <= 105)) { if (e.KeyValue == 27 || e.KeyValue == 8 || e.KeyValue == 46) // Same as e.KeyCode == Keys.Enter etc. { selected.Value = ""; if (standard != null) { standard.userGrid[selected.RowIndex, selected.ColumnIndex] = 0; } else { squiggly.userGrid[selected.RowIndex, selected.ColumnIndex] = 0; } } else if (!(e.KeyCode == Keys.Enter || e.KeyCode == Keys.Tab || e.KeyCode == Keys.Up || e.KeyCode == Keys.Down || e.KeyCode == Keys.Left || e.KeyCode == Keys.Right)) { System.Media.SystemSounds.Asterisk.Play(); } } else { int value = -1; if (e.KeyValue >= 49 && e.KeyValue <= 57) { selected.Value = e.KeyValue - 48; value = e.KeyValue - 48; } else { selected.Value = e.KeyValue - 96; value = e.KeyValue - 96; } if (standard != null) { standard.userGrid[sel_i, sel_j] = value; } else if (squiggly != null) { squiggly.userGrid[sel_i, sel_j] = value; } highlightSelectedNumber(); } } if ((standard != null && Sudoku.isSolved(standard.userGrid, Standard.scheme)) || (squiggly != null && Sudoku.isSolved(squiggly.userGrid, squiggly.scheme))) { long time = ticks; timer.Stop(); DarkenGrid(); //MessageBox.Show("Congratulations!!!"); System.Media.SoundPlayer finishSoundPlayer = new System.Media.SoundPlayer(@"C:\Windows\Media\tada.wav"); System.Media.SoundPlayer finish_no_high_SoundPlayer = new System.Media.SoundPlayer(@"C:\Windows\Media\chimes.wav"); gameType type = standard == null ? gameType.Squiggly : gameType.Standard; Difficulty level = standard == null ? squiggly.diff : standard.diff; int d = level == Difficulty.Easy ? 0 : (level == Difficulty.Medium ? 1 : 2); SaveScoreHasAppeared = true; if (HS.HS[type][d].highScores.Count == 5 && ticks > HS.HS[type][d].highScores[4].time) { finish_no_high_SoundPlayer.Play(); MessageBox.Show("\t\tCongratulations!!! \n I'm sorry but you didn't make it in the top 5."); } else { finishSoundPlayer.Play(); Form2 form2 = new Form2(this, ticks, type, level); form2.Show(); form2.name.Focus(); } standard = null; squiggly = null; sudoku = null; } }
/// <summary> /// This is used to create a new game object, according to the given parameters, /// to fill the dataGridView with the starting values, /// and to update the text shown on the form. /// </summary> /// <param name="type"></param> /// <param name="level"></param> public void setGrid(gameType type, Difficulty level) { for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { dataGridView.Rows[i].Cells[j].Value = ""; } } if (standard != null || type == gameType.Standard) { if (standard == null) { squiggly = null; standard = new Standard(level); sudoku = standard; } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (standard.mask[i, j] != 0) { dataGridView.Rows[i].Cells[j].Value = standard.mask[i, j]; } ColorMap[i, j] = Color.White; } } this.Text += " - Standard " + (standard.diff == Difficulty.Easy ? "(easy) " : (standard.diff == Difficulty.Medium ? "(medium)" : "(hard)")); } else { if (squiggly == null) { standard = null; schemeBuilder(); Random random = new Random(); squiggly = null; bool Completed = false; while (squiggly == null && !Completed) { squiggly = Limex(() => new Squiggly(level, Schemes[random.Next(0, Schemes.Count)]), 4000, out Completed); sudoku = squiggly; } } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (squiggly.mask[i, j] != 0) { dataGridView.Rows[i].Cells[j].Value = squiggly.mask[i, j]; } dataGridView.Rows[i].Cells[j].Style.BackColor = colors[squiggly.scheme[i, j]]; ColorMap[i, j] = colors[squiggly.scheme[i, j]]; } } this.Text += " - Squiggly " + (squiggly.diff == Difficulty.Easy ? "(easy) " : (squiggly.diff == Difficulty.Medium ? "(medium)" : "(hard)")); } LockCellMap(); }
private void dataGridView1_KeyDown(object sender, KeyEventArgs e) { if (modoDeJuego == null) { System.Media.SystemSounds.Asterisk.Play(); return; } if (dataGridView1.SelectedCells.Count > 0) { var selected = dataGridView1.SelectedCells[0]; int sel_i = selected.RowIndex; int sel_j = selected.ColumnIndex; if (CellMap[sel_i, sel_j] == LOCKED) { if (!(e.KeyCode == Keys.Enter || e.KeyCode == Keys.Tab || e.KeyCode == Keys.Up || e.KeyCode == Keys.Down || e.KeyCode == Keys.Left || e.KeyCode == Keys.Right)) { System.Media.SystemSounds.Asterisk.Play(); } return; } if (!(e.KeyValue >= 49 && e.KeyValue <= 57 || e.KeyValue >= 97 && e.KeyValue <= 105)) { if (e.KeyValue == 27 || e.KeyValue == 8 || e.KeyValue == 46) // Same as e.KeyCode == Keys.Enter etc. { selected.Value = ""; if (modoDeJuego != null) { modoDeJuego.grillaUsuario[selected.RowIndex, selected.ColumnIndex] = 0; } } else if (!(e.KeyCode == Keys.Enter || e.KeyCode == Keys.Tab || e.KeyCode == Keys.Up || e.KeyCode == Keys.Down || e.KeyCode == Keys.Left || e.KeyCode == Keys.Right)) { System.Media.SystemSounds.Asterisk.Play(); } } else { int value = -1; if (e.KeyValue >= 49 && e.KeyValue <= 57) { selected.Value = e.KeyValue - 48; value = e.KeyValue - 48; } else { selected.Value = e.KeyValue - 96; value = e.KeyValue - 96; } if (modoDeJuego != null) { modoDeJuego.grillaUsuario[sel_i, sel_j] = value; } highlightSelectedNumber(); } } if ((modoDeJuego != null && Sudoku.estaResuelto(modoDeJuego.grillaUsuario, ModoDeJuego.esquema))) { timer1.Stop(); ColorearAVerde(); MessageBox.Show("FELICITACIONES ! NIVEL : " + dificultadElegida + " SUPERADO"); modoDeJuego = null; sudoku = null; } }
private int[,] GetSudokuGrid(Sudoku sudoku) { return(GetSudokuGrid(sudoku, true)); }
public SudokuForm(int fieldsPerRow, Difficulty difficulty, bool diagonalRows, bool randomBoxFormation) { InitializeComponent(); this.CurrentSudoku = new Sudoku(9, difficulty, diagonalRows, false); PrepareControls(); }
public bool checkSolvable(SolveMethods M) { Sudoku copy = CreateCopy(); return(copy.SolvePuzzle(M)); }
private void BruteForce(List<Sudoku.Field> ToDo, int pos, Sudoku Temp) { // the brute force implementation for creating complete sudokus if (Finished) return; for (int i = 1; i <= 9; i++) { Sudoku Copied = Temp.Copy(); Copied.Fields[ToDo[pos].i][ToDo[pos].j].Filled = true; Copied.Fields[ToDo[pos].i][ToDo[pos].j].Value = Rnd.Next(1, 10); bool Valid = true; foreach (Sudoku.Field f in Copied.GetGroup(ToDo[pos].i, ToDo[pos].j)) { if (f.Filled && f.Value == Copied.Fields[ToDo[pos].i][ToDo[pos].j].Value) { Valid = false; break; } } if (Valid) { if (pos < ToDo.Count - 1) BruteForce(ToDo, pos + 1, Copied); else { Finished = true; Result = Copied; } } } }
private void Display(Sudoku suk) { if (suk != null) { SolverToolStripMenuItem.Enabled = true; SolverToolStripMenuItem.Visible = true; } for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (suk != null) { if (suk.Fields[i][j].Value == 0) { Texts[i][j].Text = ""; Texts[i][j].ReadOnly = false; Texts[i][j].ForeColor = Color.Black; Texts[i][j].BackColor = Color.White; } else if(Resolviendo) { Texts[i][j].Text = suk.Fields[i][j].Value.ToString(); Texts[i][j].ReadOnly = true; } else { Texts[i][j].Text = suk.Fields[i][j].Value.ToString(); Texts[i][j].ReadOnly = true; Texts[i][j].BackColor = Color.Gray; Texts[i][j].ForeColor = Color.White; } } else { if (Creando) { Texts[i][j].ReadOnly = false; Texts[i][j].Text = ""; Texts[i][j].ForeColor = Color.White; Texts[i][j].BackColor = Color.Aqua; } else { MessageBox.Show("Se ha producido un error al crear el sudoku, el juego se cerrara", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); this.Close(); } } } } }
public Sudoku CreateRandomSudoku(int Difficulty, int targetdels) { bool Start = true; bool Done = false; int Deleted = 0; int Tolerance = 10; // Various counters, we count the iterations we do in case the created instance somehow gets stuck, then we reset int FieldDelCounter = 0; int ResetCounter1 = 0; int ResetCounter2 = 0; Sudoku NewSudoku = null; Sudoku Fallback = null; int FallbackCounter = 0; while (!Done) { if (ResetCounter1 > 40) { ResetCounter1 = 0; Start = true; } if (ResetCounter2 > 40) { ResetCounter2 = 0; Start = true; } if (Start) { // first, create a complete sudoku using brute force NewSudoku = new Sudoku(new List<int>()); List<Sudoku.Field> ToDo = new List<Sudoku.Field>(); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { ToDo.Add(NewSudoku.Fields[i][j]); } } Rnd = new Random(); Finished = false; BruteForce(ToDo, 0, NewSudoku); FallbackCounter = 0; NewSudoku = Result.Copy(); Start = false; Fallback = null; } Sudoku Cloned = NewSudoku.Copy(); int difficulty = Difficulty; // take out one field and check if solutions still is unique and not harder than desired if (DeleteField(Cloned, ref difficulty)) { NewSudoku = Cloned; Deleted++; if (NewSudoku.Difficulty == Difficulty && Deleted >= targetdels) { // in this case we are done NewSudoku.Difficulty = difficulty; return NewSudoku; } else if (difficulty == Difficulty && Deleted < targetdels) { // matching difficulty found but more fields have to be deleted Fallback = NewSudoku.Copy(); } else if (Deleted >= targetdels + Tolerance) // enough fields deleted but not desired difficulty { if (FallbackCounter < 100 && Fallback != null) // first try fallback { NewSudoku = Fallback.Copy(); } else { NewSudoku = Result.Copy(); ResetCounter1++; FallbackCounter = 0; } Deleted = 0; } } else { FieldDelCounter++; if (FieldDelCounter > 100) // probably no more field can be deleted to get the desired difficulty { FieldDelCounter = 0; NewSudoku = Result.Copy(); Deleted = 0; ResetCounter2++; } continue; } } return Result; }
private void terminarToolStripMenuItem_Click(object sender, EventArgs e) { if (noHayErrores()) { Sudoku OwnSudoku = new Sudoku(Texts); if (sePuedeResolver(OwnSudoku)) { Display(OwnSudoku); terminarToolStripMenuItem.Visible = false; terminarToolStripMenuItem.Enabled = false; SolverToolStripMenuItem.Enabled = true; SolverToolStripMenuItem.Visible = true; generateOneToolStripMenuItem.Enabled = true; Creando = false; } else { MessageBox.Show("Lo hiciste tan dificil que no se puede resolver.", "Ops...", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } else MessageBox.Show("Tienes errores con los numeros, revisa los cuadros rojos", "Errores", MessageBoxButtons.OK, MessageBoxIcon.Warning); }
// Constructor // public SudokuSolver(int[,] puzzle) { this.puzzle = new Sudoku(puzzle); }
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 void BruteForce(List<Sudoku.Field> ToDo, int pos, Sudoku Temp, bool count) { if (Finished) return; for (int i = 0; i < ToDo[pos].Candidates.Count; i++) { Sudoku Copied = Temp.Copy(); Copied.Fields[ToDo[pos].i][ToDo[pos].j].Filled = true; Copied.Fields[ToDo[pos].i][ToDo[pos].j].NewFound = false; // place a random value and ... Copied.Fields[ToDo[pos].i][ToDo[pos].j].Value = ToDo[pos].Candidates[i]; bool Valid = true; // ... check if solution is still valid foreach (Sudoku.Field f in Copied.GetGroup(ToDo[pos].i, ToDo[pos].j)) { if (f.Filled && f.Value == Copied.Fields[ToDo[pos].i][ToDo[pos].j].Value) { Valid = false; break; } } if (Valid) { // if yes, go to the next position if (pos % 5 == 0) Grade0(); if (pos < ToDo.Count - 1) BruteForce(ToDo, pos + 1, Copied, count); else { // or otherwise, we are done if (!count) { Finished = true; Input = Copied; Remaining = 0; } else { // if we want to count the solutions, we do not stop after having found the first one SolCounter++; Remaining = 0; if (SolCounter > 1) { Finished = true; } } } } } }
public void NewGame() { int level; // Level if (rb_easy.IsChecked == true) { level = 55; } else if (rb_medium.IsChecked == true) { level = 30; } else if (rb_hard.IsChecked == true) { level = 0; } else { level = 30; } input = Sudoku.Create(level); int counter = 0; int solved = 0; Sudoku.Solve(0, 0, 0, input[0], ref counter, ref solved, 0); List <TextBox> TextBox = new List <TextBox>(); TextBox.Add(tb_1); TextBox.Add(tb_2); TextBox.Add(tb_3); TextBox.Add(tb_4); TextBox.Add(tb_5); TextBox.Add(tb_6); TextBox.Add(tb_7); TextBox.Add(tb_8); TextBox.Add(tb_9); TextBox.Add(tb_10); TextBox.Add(tb_11); TextBox.Add(tb_12); TextBox.Add(tb_13); TextBox.Add(tb_14); TextBox.Add(tb_15); TextBox.Add(tb_16); TextBox.Add(tb_17); TextBox.Add(tb_18); TextBox.Add(tb_19); TextBox.Add(tb_20); TextBox.Add(tb_21); TextBox.Add(tb_22); TextBox.Add(tb_23); TextBox.Add(tb_24); TextBox.Add(tb_25); TextBox.Add(tb_26); TextBox.Add(tb_27); TextBox.Add(tb_28); TextBox.Add(tb_29); TextBox.Add(tb_30); TextBox.Add(tb_31); TextBox.Add(tb_32); TextBox.Add(tb_33); TextBox.Add(tb_34); TextBox.Add(tb_35); TextBox.Add(tb_36); TextBox.Add(tb_37); TextBox.Add(tb_38); TextBox.Add(tb_39); TextBox.Add(tb_40); TextBox.Add(tb_41); TextBox.Add(tb_42); TextBox.Add(tb_43); TextBox.Add(tb_44); TextBox.Add(tb_45); TextBox.Add(tb_46); TextBox.Add(tb_47); TextBox.Add(tb_48); TextBox.Add(tb_49); TextBox.Add(tb_50); TextBox.Add(tb_51); TextBox.Add(tb_52); TextBox.Add(tb_53); TextBox.Add(tb_54); TextBox.Add(tb_55); TextBox.Add(tb_56); TextBox.Add(tb_57); TextBox.Add(tb_58); TextBox.Add(tb_59); TextBox.Add(tb_60); TextBox.Add(tb_61); TextBox.Add(tb_62); TextBox.Add(tb_63); TextBox.Add(tb_64); TextBox.Add(tb_65); TextBox.Add(tb_66); TextBox.Add(tb_67); TextBox.Add(tb_68); TextBox.Add(tb_69); TextBox.Add(tb_70); TextBox.Add(tb_71); TextBox.Add(tb_72); TextBox.Add(tb_73); TextBox.Add(tb_74); TextBox.Add(tb_75); TextBox.Add(tb_76); TextBox.Add(tb_77); TextBox.Add(tb_78); TextBox.Add(tb_79); TextBox.Add(tb_80); TextBox.Add(tb_81); int k = 0; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (input[0][i, j] == 0) { TextBox[k].Text = Convert.ToString(""); TextBox[k].Background = Brushes.Transparent; k++; } else { TextBox[k].Text = Convert.ToString(input[0][i, j]); TextBox[k].Background = Brushes.Transparent; k++; } } } }
public static int[][,] Create(int fieldsLeft) { int zeile, spalte, n, solved, counter, selectedIndependentBlocks; int[,] OutputField = new int[9, 9]; int[,] SolvedGame = new int[9, 9]; int[,] tmp = new int[9, 9]; int[,] independentBlocks = new int[6, 3] { { 0, 30, 60 }, { 0, 33, 57 }, { 3, 27, 60 }, { 3, 33, 54 }, { 6, 30, 54 }, { 6, 27, 57 } }; int[] ShuffeledArray; selectedIndependentBlocks = rnd.Next(5); counter = 0; solved = 0; for (int currentBlock = 0; currentBlock < 3; currentBlock++) { ShuffeledArray = Sudoku.Shuffle(); zeile = independentBlocks[selectedIndependentBlocks, currentBlock] / 9; spalte = independentBlocks[selectedIndependentBlocks, currentBlock] % 9; n = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { OutputField[spalte - (spalte % 3) + i, zeile - (zeile % 3) + j] = ShuffeledArray[n++]; SolvedGame[spalte - (spalte % 3) + i, zeile - (zeile % 3) + j] = OutputField[spalte - (spalte % 3) + i, zeile - (zeile % 3) + j]; } } } Sudoku.Solve(0, 0, 0, OutputField, ref counter, ref solved, 1); OutputField = solution[0]; n = 81 - fieldsLeft; Array.Copy(OutputField, tmp, OutputField.Length); do { zeile = rnd.Next(9); spalte = rnd.Next(9); solution.Clear(); tmp[zeile, spalte] = 0; counter = 0; solved = 0; Sudoku.Solve(0, 0, 0, tmp, ref counter, ref solved, 0); if (solved == 1) { Array.Copy(tmp, OutputField, OutputField.Length); n--; } else { Array.Copy(OutputField, tmp, OutputField.Length); } } while (n > 0); SolvedGame = solution[0]; Array.Copy(SolvedGame, tmp, SolvedGame.Length); zeile = rnd.Next(9); spalte = rnd.Next(9); solution.Clear(); tmp[zeile, spalte] = 0; counter = 0; solved = 0; Sudoku.Solve(0, 0, 0, tmp, ref counter, ref solved, 0); Array.Copy(SolvedGame, tmp, SolvedGame.Length); int[][,] SendBack = new int[2][, ]; SendBack[0] = OutputField; SendBack[1] = SolvedGame; return(SendBack); }
public void Fill1() { sd = new Sudoku(); btn = new Button[9, 9]; btn[0, 0] = btn1_1; btn[0, 1] = btn2_1; btn[0, 2] = btn3_1; btn[0, 3] = btn1_2; btn[0, 4] = btn2_2; btn[0, 5] = btn3_2; btn[0, 6] = btn1_3; btn[0, 7] = btn2_3; btn[0, 8] = btn3_3; btn[1, 0] = btn4_1; btn[1, 1] = btn5_1; btn[1, 2] = btn6_1; btn[1, 3] = btn4_2; btn[1, 4] = btn5_2; btn[1, 5] = btn6_2; btn[1, 6] = btn4_3; btn[1, 7] = btn5_3; btn[1, 8] = btn6_3; btn[2, 0] = btn7_1; btn[2, 1] = btn8_1; btn[2, 2] = btn9_1; btn[2, 3] = btn7_2; btn[2, 4] = btn8_2; btn[2, 5] = btn9_2; btn[2, 6] = btn7_3; btn[2, 7] = btn8_3; btn[2, 8] = btn9_3; btn[3, 0] = btn1_4; btn[3, 1] = btn2_4; btn[3, 2] = btn3_4; btn[3, 3] = btn1_5; btn[3, 4] = btn2_5; btn[3, 5] = btn3_5; btn[3, 6] = btn1_6; btn[3, 7] = btn2_6; btn[3, 8] = btn3_6; btn[4, 0] = btn4_4; btn[4, 1] = btn5_4; btn[4, 2] = btn6_4; btn[4, 3] = btn4_5; btn[4, 4] = btn5_5; btn[4, 5] = btn6_5; btn[4, 6] = btn4_6; btn[4, 7] = btn5_6; btn[4, 8] = btn6_6; btn[5, 0] = btn7_4; btn[5, 1] = btn8_4; btn[5, 2] = btn9_4; btn[5, 3] = btn7_5; btn[5, 4] = btn8_5; btn[5, 5] = btn9_5; btn[5, 6] = btn7_6; btn[5, 7] = btn8_6; btn[5, 8] = btn9_6; btn[6, 0] = btn1_7; btn[6, 1] = btn2_7; btn[6, 2] = btn3_7; btn[6, 3] = btn1_8; btn[6, 4] = btn2_8; btn[6, 5] = btn3_8; btn[6, 6] = btn1_9; btn[6, 7] = btn2_9; btn[6, 8] = btn3_9; btn[7, 0] = btn4_7; btn[7, 1] = btn5_7; btn[7, 2] = btn6_7; btn[7, 3] = btn4_8; btn[7, 4] = btn5_8; btn[7, 5] = btn6_8; btn[7, 6] = btn4_9; btn[7, 7] = btn5_9; btn[7, 8] = btn6_9; btn[8, 0] = btn7_7; btn[8, 1] = btn8_7; btn[8, 2] = btn9_7; btn[8, 3] = btn7_8; btn[8, 4] = btn8_8; btn[8, 5] = btn9_8; btn[8, 6] = btn7_9; btn[8, 7] = btn8_9; btn[8, 8] = btn9_9; }
public SudokuColumn(Sudoku sudoku, int n, int index) : base(sudoku, n, index) { }
static void Main(string[] args) { #region Teil 1 byte[,] Beispiel = { { 0, 3, 0, 0, 0, 0, 0, 0, 0 }, //0 { 0, 0, 0, 1, 9, 5, 0, 0, 0 }, { 0, 0, 8, 0, 0, 0, 0, 6, 0 }, // 2 { 8, 0, 0, 0, 6, 0, 0, 0, 0 }, //3 { 4, 0, 0, 8, 0, 0, 0, 0, 1 }, { 0, 0, 0, 0, 2, 0, 0, 0, 0 }, // 5 { 0, 6, 0, 0, 0, 0, 2, 8, 0 }, //6 { 0, 0, 0, 4, 1, 9, 0, 0, 5 }, { 0, 0, 0, 0, 0, 0, 0, 7, 0 } // 8 }; Sudoku s = new Sudoku(Beispiel); Sudoku t = new Sudoku(); s.Print(); t.Print(); #endregion #region Teil 2 Console.WriteLine("Setze 4 in das 3. Feld der ersten Zeile:"); s.SetzeFeld(3, 1, 4); s.Print(); #endregion #region Teil 3 Console.WriteLine("Zeilen:"); for (int i = 1; i <= 9; i++) { Console.WriteLine("{0} {1}", i, s.ZeilenFehler(i) ? "Fehler" : "OK"); } #endregion #region Teil 4 Console.WriteLine("Spalten"); for (int i = 1; i <= 9; i++) { Console.WriteLine("{0} {1}", i, s.SpaltenFehler(i) ? "Fehler" : "OK"); } Console.WriteLine("Blöcke:"); for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 3; j++) { Console.WriteLine("{0}|{1} {2}", i, j, s.BlockFehler(i, j) ? "Fehler" : "OK"); } } #endregion #region Teil 5 if (s.Fehler) { Console.WriteLine("Fehlerhaft!"); } else { Console.WriteLine("Fehlerfrei"); } #endregion #region Teil 6 t = new Sudoku(s); Console.WriteLine("t == s : {0}", (t == s) ? "JA" : "NEIN"); Console.WriteLine("t.IstGleich(s) : {0}", (t.IstGleich(s)) ? "JA" : "NEIN"); t.SetzeFeld(1, 1, 5); Console.WriteLine("t neu:"); t.Print(); Console.WriteLine("t.IstGleich(s) : {0}", (t.IstGleich(s)) ? "JA" : "NEIN"); #endregion #region Teil 7 Console.WriteLine("Datei lesen:"); Sudoku u = Sudoku.LeseDatei(@"..\..\..\beispiel.sudoku"); u.Print(); if (u.Fehler) { Console.WriteLine("Fehlerhaft!"); } else { Console.WriteLine("Fehlerfrei"); } #endregion #region Teil 8 Console.WriteLine("Datei speichern:"); s.SpeichernUnter(@"..\..\..\mein.sudoku"); #endregion }
public MainForm() { InitializeComponent(); squareColors = new Color[9, 9]; saved = true; undo = new UndoRedo(new Update(setMark), new UpdateState(undoRedoButtons)); sudoku = new Sudoku(undo); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { squareColors[i, j] = Color.FromArgb(214, 230, 237); } for (int j = 3; j < 6; j++) { squareColors[i, j] = Color.FromArgb(208, 227, 234); } for (int j = 6; j < 9; j++) { squareColors[i, j] = Color.FromArgb(201, 223, 232); } } for (int i = 3; i < 6; i++) { for (int j = 0; j < 3; j++) { squareColors[i, j] = Color.FromArgb(193, 219, 229); } for (int j = 3; j < 6; j++) { squareColors[i, j] = Color.FromArgb(186, 215, 226); } for (int j = 6; j < 9; j++) { squareColors[i, j] = Color.FromArgb(179, 211, 224); } } for (int i = 6; i < 9; i++) { for (int j = 0; j < 3; j++) { squareColors[i, j] = Color.FromArgb(171, 207, 221); } for (int j = 3; j < 6; j++) { squareColors[i, j] = Color.FromArgb(161, 203, 218); } for (int j = 6; j < 9; j++) { squareColors[i, j] = Color.FromArgb(152, 198, 215); } undoRedoButtons(); } gridSudoku.RowsDefaultCellStyle.Font = new Font("Courier New", 12, FontStyle.Bold); gridSudoku.RowsDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter; gridSudoku.MultiSelect = false; for (int i = 1; i < 10; i++) { gridSudoku.Rows.Add(); if (gridSudoku.Rows[i - 1].IsNewRow) { continue; } gridSudoku.Rows[i - 1].HeaderCell.Value = i.ToString(); gridSudoku.Rows[i - 1].Height = 40; for (int j = 0; j < 9; j++) { gridSudoku.Rows[i - 1].Cells[j].Style.BackColor = squareColors[i - 1, j]; } } // Connect the virtual-mode events to event handlers. gridSudoku.CellValueNeeded += new DataGridViewCellValueEventHandler(gridSudoku_CellValueNeeded); gridSudoku.CellValuePushed += new DataGridViewCellValueEventHandler(gridSudkou_CellValuePushed); gridSudoku.RowValidated += new DataGridViewCellEventHandler(gridSudoku_RowValidated); gridSudoku.RowDirtyStateNeeded += new QuestionEventHandler(gridSudoku_RowDirtyStateNeeded); gridSudoku.CancelRowEdit += new QuestionEventHandler(gridSudoku_CancelRowEdit); }
public SudokuRow(Sudoku sudoku, int index) : this(sudoku, 3, index) { }
public SudokuRow(Sudoku sudoku, int n, int index) : base(sudoku, n, index) { }
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; }
public SudokuCollection(Sudoku sudoku, int index) : this(sudoku, 3, index) { }
public static string GenerateSudokuAndGetSeed(int fieldsPerRowAmount, Difficulty difficulty, bool diagonalRows, bool randomBoxFormation) { var sudoku = new Sudoku(fieldsPerRowAmount, difficulty, diagonalRows, randomBoxFormation); return(ConvertSudokuIntoSeed(sudoku)); }
private static byte[] Solve(Sudoku sudoku) { bool updated; bool solved; do { updated = false; solved = true; for (int i = 0; i < sudoku.Answer.Length; i++) { if (sudoku.Answer[i] != 0) { continue; } solved = false; int c = sudoku.GetCandidateBit(i); if (c == 0) { return(null); } int lowest = LowestOneBit(c); if (c == lowest) { sudoku.Update(i, ToNum(lowest)); updated = true; } } } while (updated); if (solved) { return(sudoku.Answer); } // 候補が少ない箇所を探す int count = int.MaxValue; int index = 0; for (int i = 0; i < sudoku.Answer.Length; i++) { if (sudoku.Answer[i] != 0) { continue; } int c = BitCount(sudoku.GetCandidateBit(i)); if (c < count) { count = c; index = i; } } // 複数ある候補のうちの一つを仮定して、再帰的に解析 int candidate = sudoku.GetCandidateBit(index); for (int i = 0; i < 9; i++) { int bit = (candidate & (1 << i)); if (bit == 0) { continue; } Sudoku newSudoku = new Sudoku(sudoku); newSudoku.Update(index, (byte)(i + 1)); byte[] answer = Solve(newSudoku); if (answer != null) { return(answer); } } return(null); }
// Constructor // filename - file from which to read the puzzle public SudokuSolver(string puzzleFile) { puzzle = new Sudoku(puzzleFile); }
public SudokuColumn(Sudoku sudoku, int index) : this(sudoku, 3, index) { }
int SolCounter; // Solution counter #endregion Fields #region Methods public Sudoku Solve(Sudoku suk, bool count, int maxDifficulty) { Remaining = 81; Input = suk; InitCandidates(); SolCounter = 0; int Difficulty = 1; int HighestDifficulty = 1; Input.Rem1 = -1; Input.Rem2 = -1; Input.Rem3 = -1; while (Remaining > 0) { int oldRem = Remaining; if (Grade0()) continue; if (Grade1()) continue; if (Difficulty >= 2) { if (Input.Rem1 == -1) Input.Rem1 = Remaining; if (GradeX(2)) { continue; } if (CandidateLine()) { continue; } } if (Difficulty >= 3) { if (Input.Rem2 == -1) Input.Rem2 = Remaining; if (GradeX(3)) continue; if (XWing()) { continue; } } if (Difficulty >= 4) { // this completes the sudoku in one step if (Input.Rem3 == -1) Input.Rem3 = Remaining; NonLogic(count); } if (Remaining == oldRem) { Difficulty++; if (Difficulty > HighestDifficulty) HighestDifficulty = Difficulty; if (Difficulty > maxDifficulty) { Input.Difficulty = HighestDifficulty; Input.NrSolutions = 0; return null; } if (Difficulty > 4) break; } else Difficulty = 1; } // brute force counts the number of solutions Input.NrSolutions = SolCounter; if (Input.NrSolutions == 0) Input.NrSolutions = 1; // no brute force used Input.Difficulty = HighestDifficulty; return Input; }
public Sudoku Copy() { Sudoku Result = new Sudoku(new List<int>()); for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { Result.Fields[i][j] = Fields[i][j].Copy(); } } Result.Difficulty = Difficulty; Result.Rem1 = Rem1; Result.Rem2 = Rem2; Result.Rem3 = Rem3; Result.NrSolutions = NrSolutions; return Result; }