public SudokuBoard(IEnumerable <Cell> cells, SudokuDifficulty difficulty = SudokuDifficulty.None) : this(difficulty) { foreach (var cell in cells) { this[cell.Row, cell.Col] = cell.Val; } }
/// <summary> /// Generates a new <see cref="SudokuPuzzle"/> by filling it with numbers and then removing numbers according to <c><paramref name="difficulty"/></c>. /// </summary> /// <param name="size">The number of elements that the new <see cref="SudokuPuzzle"/> can store in each row, column and block.</param> /// <param name="difficulty">The difficulty associated with the <see cref="SudokuPuzzle"/>.</param> /// <returns>A new <see cref="SudokuPuzzle"/>.</returns> /// <exception cref="ArgumentException"><c><paramref name="size"/></c> is not a positive, square integer - or - <c><paramref name="difficulty"/></c> is equal to <see cref="SudokuDifficulty.None"/>.</exception> /// <exception cref="ArgumentOutOfRangeException"><c><paramref name="size"/></c> is less than or equal to 0 or greater than <see cref="SudokuPuzzle.MaximumSupportedSize"/>.</exception> public static SudokuPuzzle Generate(int size, SudokuDifficulty difficulty) { SudokuPuzzle sudoku = SudokuGenerator.AddNumbers(size, difficulty); SudokuGenerator.RemoveNumbers(sudoku); return(sudoku); }
public void StartGeneratingSudokuPuzzle(SudokuDifficulty difficulty) { int[,] solvedBoard = this.solver.SolveForRandomSolution(new int[9, 9], this.random); Func <int[, ], int[, ]> copyBoard = board => { var newBoard = new int[9, 9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { newBoard[i, j] = board[i, j]; } } return(newBoard); }; this.numRemoved = 0; this.numTries = 0; this.currentPuzzle = copyBoard(solvedBoard); this.isDone = false; this.difficulty = difficulty; this.cellsThatCannotBeRemoved = new List <Tuple <int, int> >(); }
public SudokuBoard(SudokuDifficulty difficulty = SudokuDifficulty.None) { Difficulty = difficulty; _grid = Enumerable.Range(0, SIZE) .Select(_ => new int[SIZE]) .ToArray(); }
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 EnterTextBox(object sender, MouseEventArgs e) { ColorAnimation animation = new ColorAnimation(); var textBox = sender as TextBox; var sudokuDifficulty = new SudokuDifficulty(); var sudoku = new SudokuCell[9, 9]; if ((FindName("checkBoxHints") as CheckBox).IsChecked == true) { if (textBox.IsReadOnly == false && lastSudokuDifficulty != 0 && textBox.Text == string.Empty) { try { var counter = 0; var inputRow = 0; var inputCol = 0; for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { var box = this.FindName("TextBox" + counter) as TextBox; sudoku[row, col] = new SudokuCell(row, col); if (box.Text != string.Empty) { sudoku[row, col].Value = int.Parse(box.Text); } if ("TextBox" + counter == textBox.Name) { inputCol = col; inputRow = row; } counter++; } } var outputList = sudokuDifficulty.GetAllPossibleNumbers(inputRow, inputCol, sudoku).PossibleValues; var result = string.Join(" ", outputList); var toolTip = new ToolTip(); toolTip.Background = new SolidColorBrush(Color.FromRgb(255, 250, 252)); toolTip.Content = string.Format("You can put those numbers: {0}!", result); textBox.ToolTip = toolTip; } catch (Exception) { throw; } } } animation.To = Color.FromRgb(227, 232, 234); animation.Duration = new Duration(TimeSpan.FromSeconds(0.5)); textBox.Background.BeginAnimation(SolidColorBrush.ColorProperty, animation); }
public static SudokuBoard NewSudoku(SudokuDifficulty difficulty, ISudokuSolver solverGenerator = null) { _solverGenerator = solverGenerator ?? new DeepFirstSearchSolver(); var blankboard = new SudokuBoard(difficulty); return(_solverGenerator .Solve(blankboard) .CreateBlankCells()); }
public SudokuGenerator(IRandomizedSudokuSolver s, ISudokuRandom r) { this.solver = s; this.random = r; this.currentPuzzle = null; this.numRemoved = -1; this.numTries = -1; this.isDone = false; this.difficulty = SudokuDifficulty.Easy; this.cellsThatCannotBeRemoved = null; }
/// <summary> /// Creates a new <see cref="SudokuPuzzle"/> and fills it with numbers. /// </summary> /// <param name="size">The number of elements that the new <see cref="SudokuPuzzle"/> can store in each row, column and block.</param> /// <param name="difficulty">The difficulty associated with the <see cref="SudokuPuzzle"/>.</param> /// <returns>A new <see cref="SudokuPuzzle"/> filled with numbers.</returns> /// <exception cref="ArgumentException"><c><paramref name="size"/></c> is not a positive, square integer - or - <c><paramref name="difficulty"/></c> is equal to <see cref="SudokuDifficulty.None"/>.</exception> /// <exception cref="ArgumentOutOfRangeException"><c><paramref name="size"/></c> is less than or equal to 0 or greater than <see cref="SudokuPuzzle.MaximumSupportedSize"/>.</exception> public static SudokuPuzzle AddNumbers(int size, SudokuDifficulty difficulty) { if (difficulty == SudokuDifficulty.None) { throw new ArgumentException(nameof(difficulty)); } SudokuPuzzle sudoku = new SudokuPuzzle(size, difficulty); SudokuGenerator.AddNumbers(sudoku); return(sudoku); }
/// <summary> /// Parses the text representing a single <see cref="SudokuPuzzle"/>. /// </summary> /// <param name="s">The text to parse.</param> /// <returns>A <see cref="SudokuPuzzle"/> representation of <c><paramref name="s"/></c>.</returns> /// <exception cref="ArgumentNullException"><c><paramref name="s"/></c> is <c>null</c>.</exception> /// <exception cref="FormatException"><c><paramref name="s"/></c> is not in the correct format.</exception> public static SudokuPuzzle Deserialize(String s) { if (s is null) { throw new ArgumentNullException(nameof(s)); } String[] split = s.Split(','); if (split.Length != 5) { throw new FormatException(); } try { int size = Int32.Parse(split[0]); int squared = size * size; if (!SudokuPuzzle.VerifySize(size)) { throw new FormatException(); } SudokuDifficulty difficulty = (SudokuDifficulty)Enum.Parse(typeof(SudokuDifficulty), split[1], true); int[] numbers = new int[squared], solutions = new int[squared]; bool[] readOnly = new bool[squared]; if (split[2].Length != squared || split[3].Length != squared || split[4].Length != squared) { throw new FormatException(); } for (int i = 0; i < squared; i++) { numbers[i] = split[2][i] - '0'; solutions[i] = split[3][i] - '0'; readOnly[i] = split[3][i] == '1'; } SudokuPuzzle puzzle = SudokuPuzzle.Parse(size, difficulty, numbers, solutions, readOnly); puzzle.ResetPossible(); return(puzzle); } catch { throw new FormatException(); } }
internal static SudokuPuzzle Parse(int size, SudokuDifficulty difficulty, int[] numbers, int[] solutions, bool[] readOnly) { SudokuPuzzle puzzle = new SudokuPuzzle(size, difficulty); for (int i = 0; i < size; i++) { int row = i * size; for (int j = 0; j < size; j++) { int index = row + j; SudokuCell cell = puzzle.Cells[i, j]; cell.Number = numbers[index]; cell.Solution = solutions[index]; cell.IsReadOnly = readOnly[index]; } } return(puzzle); }
/// <summary> /// Initializes a new instance of the <see cref="SudokuPuzzle"/> class that is empty and has the specified <c><paramref name="size"/></c> and <c><paramref name="difficulty"/></c>. /// </summary> /// <param name="size">The number of elements that the new sudoku can store in each row, column and block.</param> /// <param name="difficulty">The difficulty associated with the <see cref="SudokuPuzzle"/>.</param> /// <exception cref="ArgumentException"><c><paramref name="size"/></c> is not a positive, square integer.</exception> /// <exception cref="ArgumentOutOfRangeException"><c><paramref name="size"/></c> is less than or equal to 0 or greater than <see cref="SudokuPuzzle.MaximumSupportedSize"/>.</exception> public SudokuPuzzle(int size, SudokuDifficulty difficulty) { if (size <= 0 || size > SudokuPuzzle.MaximumSupportedSize) { throw new ArgumentOutOfRangeException(nameof(size)); } if (!MathExtensions.IsSquare((ulong)size)) { throw new ArgumentException(nameof(size)); } this.LockObject = new Object(); this._Changed = null; this.Cells = new SudokuCell[size, size]; this.Difficulty = difficulty; this.DisablePossible = false; int[] numbers = new int[size]; for (int i = 0; i < size; i++) { numbers[i] = i + 1; } for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { this.Cells[i, j] = new SudokuCell(); foreach (int number in numbers) { this.Cells[i, j].AddPossible(number); } } } this.Size = size; this.BlockSize = (int)Math.Sqrt(size); }
/// <summary> /// Converts the string representation to its <see cref="SudokuPuzzle"/> equivalent. /// </summary> /// <param name="s">A string containing a puzzle to convert.</param> /// <param name="difficulty">An optional difficulty to associate with the <see cref="SudokuPuzzle"/>.</param> /// <returns>A <see cref="SudokuPuzzle"/> equivalent to the puzzle contained in <c><paramref name="s"/></c>.</returns> /// <exception cref="ArgumentNullException"><c><paramref name="s"/></c> is <c>null</c>.</exception> /// <exception cref="FormatException"><c><paramref name="s"/></c> is not in the correct format.</exception> public static SudokuPuzzle Parse(String s, SudokuDifficulty difficulty = SudokuDifficulty.None) { if (s is null) { throw new ArgumentNullException(nameof(s)); } s = Regex.Replace(s, @"[^0-9]", ""); int size = (int)Math.Sqrt(s.Length); if (!SudokuPuzzle.VerifySize(size)) { throw new FormatException(); } SudokuPuzzle sudoku; try { sudoku = new SudokuPuzzle(size, difficulty); } catch { throw new FormatException(); } for (int i = 0; i < size; i++) { int currentRow = i * size; for (int j = 0; j < size; j++) { sudoku[i, j] = s[currentRow + j] - '0'; } } return(sudoku); }
private void CheckIfSudokuIsValid(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)) { var inputCells = new bool[9, 9]; var sudoku = new SudokuCell[9, 9]; counter = 0; for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { var element = this.FindName("TextBox" + counter) as TextBox; int number; var isParsed = int.TryParse(element.Text, out number); sudoku[row, col] = new SudokuCell(row, col); if (isParsed && element.IsReadOnly == false) { sudoku[row, col].Value = number; } else { sudoku[row, col].Value = number; inputCells[row, col] = true; } counter++; } } var listWithCellsWithError = sudokuSolver.GetAllCellsWithError(sudoku, inputCells); ColorTheCellsWithError(listWithCellsWithError); MessageBox.Show("You have some errors!"); return; } try { sudokuToSolve = sudokuSolver.SolveSudoku(sudokuToSolve); } catch (ArgumentException) { var inputCells = new bool[9, 9]; var sudoku = new SudokuCell[9, 9]; counter = 0; for (int row = 0; row < 9; row++) { for (int col = 0; col < 9; col++) { var element = this.FindName("TextBox" + counter) as TextBox; int number; var isParsed = int.TryParse(element.Text, out number); sudoku[row, col] = new SudokuCell(row, col); if (isParsed && element.IsReadOnly == false) { sudoku[row, col].Value = number; } else { sudoku[row, col].Value = number; inputCells[row, col] = true; } counter++; } } var listWithCellsWithError = sudokuSolver.GetAllCellsWithError(sudoku, inputCells, false); ColorTheCellsWithError(listWithCellsWithError); MessageBox.Show("You have some errors!"); return; } MessageBox.Show("You are doing great!"); }
public SudokuBoard(IEnumerable <int> values, SudokuDifficulty difficulty = SudokuDifficulty.None) : this(GetCellsFromValues(values), difficulty) { }