public void SetAllPossibleValues(int row, int col, SudokuCell cell = null) { var currentCellPossibleValues = this.sudoku[row, col].PossibleValues; var valuesOnRow = GetValuesOnRow(row, cell); var valuesOnCol = GetValuesOnCol(col, cell); var startRow = (row / 3) * 3; var startCol = (col / 3) * 3; var valuesOnBox = GetValuesInBox(startRow, startCol, cell); foreach (var item in valuesOnBox) { currentCellPossibleValues.Remove(item); } foreach (var item in valuesOnCol) { currentCellPossibleValues.Remove(item); } foreach (var item in valuesOnRow) { currentCellPossibleValues.Remove(item); } }
private void InitCells(SudokuGrid grid) { CurrentCell = new SudokuCell(FirstCellRowPosition, FirstCellColPosition); CurrentCellRowIndex = 0; CurrentCellColIndex = 0; const int SudokuDim = SudokuGrid.SudokuDimension; cells = new SudokuCell[SudokuDim, SudokuDim]; int currWindowRowPos = GameWindow.FirstCellRowPosition; int currWindowColPos = GameWindow.FirstCellColPosition; const int RowIncrement = GameWindow.CellPositionRowIncrements; const int ColIncrement = GameWindow.CellPositionColIncrements; for (int row = 0; row < SudokuDim; row++) { for (int col = 0; col < SudokuDim; col++) { cells[row, col] = new SudokuCell(grid[row, col], grid.IsEditable(row, col), currWindowRowPos, currWindowColPos); currWindowColPos += ColIncrement; } currWindowColPos = GameWindow.FirstCellColPosition; currWindowRowPos += RowIncrement; } menuCells = new MenuCell[MenuItemLabels.Length]; for (int item = 0; item < menuCells.Length; item++) { menuCells[item] = new MenuCell(MenuItemsCellRowPosition, MenuItemsCellColPositions[item], MenuItemLabels[item]); } RedrawCells(); }
public SudokuZone() { InitializeComponent(); this._grid = null; this._cells = new SudokuCell[3, 3]; this._row = 0; this._column = 0; StackPanel zoneStackPanel = new StackPanel() { Orientation = Orientation.Vertical }; for (int i = 0; i < 3; i++) { StackPanel rowStackPanel = new StackPanel() { Orientation = Orientation.Horizontal }; for (int j = 0; j < 3; j++) { SudokuCell cell = new SudokuCell(); this._cells[i, j] = cell; rowStackPanel.Children.Add(cell); } zoneStackPanel.Children.Add(rowStackPanel); } this.SudokuCellContainer.Child = zoneStackPanel; }
public SudokuZone(SudokuGrid grid, int row, int col) { InitializeComponent(); this._grid = grid; this._cells = new SudokuCell[grid.Puzzle.Rank, grid.Puzzle.Rank]; this._row = row; this._column = col; StackPanel zoneStackPanel = new StackPanel() { Orientation = Orientation.Vertical }; for (int i = 0; i < grid.Puzzle.Rank; i++) { StackPanel rowStackPanel = new StackPanel() { Orientation = Orientation.Horizontal }; for (int j = 0; j < grid.Puzzle.Rank; j++) { SudokuCell cell = new SudokuCell(this, i, j); this._cells[i, j] = cell; rowStackPanel.Children.Add(cell); } zoneStackPanel.Children.Add(rowStackPanel); } this.SudokuCellContainer.Child = zoneStackPanel; }
private double CalculateDifficulty() { List <int> topN = new List <int>(10); topN.Add(0); for (int rowIndex = 0; rowIndex <= 8; rowIndex++) { for (int colIndex = 0; colIndex <= 8; colIndex++) { SudokuCell cell = sudokuCells[rowIndex][colIndex]; int cellDifficulty = (int)cell.SolvingDifficulty; if (cellDifficulty > topN.Min()) { if (topN.Count < topN.Capacity) { topN.Add(cellDifficulty); } else { topN.Remove(topN.Min()); topN.Add(cellDifficulty); } } } } double topNAverage = topN.Average(); return(topNAverage); }
private void EliminatePossibilitiesFromUnsetCells(SudokuGroup sudokuGroup) { HashSet <int> allNumbersPresentInGroup = new HashSet <int>(); for (int cellIndex = 0; cellIndex <= 8; cellIndex++) { int cellValue = sudokuGroup.Cells[cellIndex].Value; if (cellValue != 0) { allNumbersPresentInGroup.Add(cellValue); } } for (int cellIndex = 0; cellIndex <= 8; cellIndex++) { int cellValue = sudokuGroup.Cells[cellIndex].Value; if (cellValue == 0) { SudokuCell cell = sudokuGroup.Cells[cellIndex]; cell.RemainingPossibilities.ExceptWith(allNumbersPresentInGroup); if (cell.RemainingPossibilities.Count == 1) { cell.Value = cell.RemainingPossibilities.First(); cell.SolvingDifficulty = SolvingDifficulty.Easy; } } } }
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(); }
public bool HasSamePositionAs(SudokuCell other) { if (this.windowRowPosition == other.windowRowPosition && this.windowColPosition == other.windowColPosition) { return(true); } return(false); }
public bool HasSamePositionAs(SudokuCell other) { if (this.windowRowPosition == other.windowRowPosition && this.windowColPosition == other.windowColPosition) { return true; } return false; }
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); }
private HashSet <int> GetValuesOnRow(int row, SudokuCell cell) { var result = new HashSet <int>(); for (int col = 0; col < 9; col++) { if (this.sudoku[row, col].Value != 0 && !this.sudoku[row, col].Equals(cell)) { result.Add(this.sudoku[row, col].Value); } } return(result); }
private Sudoku() { for (int i = 0; i <= 8; i++) { sudokuCells[i] = new SudokuCell[9]; sudokuRows[i] = new SudokuGroup(i); sudokuColumns[i] = new SudokuGroup(i); sudokuBoxes[i] = new SudokuGroup(i); } //1. Initialize Cells and create row view for (int rowIndex = 0; rowIndex <= 8; rowIndex++) { for (int colIndex = 0; colIndex <= 8; colIndex++) { sudokuCells[rowIndex][colIndex] = new SudokuCell(rowIndex, colIndex); sudokuRows[rowIndex].Cells[colIndex] = sudokuCells[rowIndex][colIndex]; sudokuColumns[colIndex].Cells[rowIndex] = sudokuCells[rowIndex][colIndex]; } } //2. create box view //([0] ,[1] , [2]) //([3] ,[4] , [5]) //([6] ,[7] , [8]) for (int boxIndex = 0; boxIndex <= 8; boxIndex++) { for (int cellIndexInABox = 0; cellIndexInABox <= 8; cellIndexInABox++) { //Box,cell 0,0 == Row Col >0,0 //1,0 ==> 0,3 //2,2 ==>0,8 //3,3 ==>4,0 //8,0 ==>6,6 //8,8 ==>8,8 int firtCellRowIndex = (boxIndex - (boxIndex % 3)); int firtCellColIndex = (boxIndex % 3) * 3; int rowIndex = firtCellRowIndex + cellIndexInABox / 3; int colIndex = firtCellColIndex + cellIndexInABox % 3; sudokuBoxes[boxIndex].Cells[cellIndexInABox] = sudokuCells[rowIndex][colIndex]; } } //MessageBox.Show(message); }
private SudokuCell[,] CloneSudoku(SudokuCell[,] sudoku) { var result = new SudokuCell[9, 9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { result[i, j] = new SudokuCell(i, j); result[i, j].Value = sudoku[i, j].Value; } } return(result); }
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) { } }
private HashSet <int> GetValuesInBox(int startRow, int startCol, SudokuCell cell) { var result = new HashSet <int>(); for (int row = startRow; row < startRow + 3; row++) { for (int col = startCol; col < startCol + 3; col++) { if (this.sudoku[row, col].Value != 0 && !this.sudoku[row, col].Equals(cell)) { result.Add(this.sudoku[row, col].Value); } } } return(result); }
public bool CheckIfSudokuIsValid(SudokuCell[,] sudokuToSolve) { if (sudokuToSolve.GetLength(0) != 9 || sudokuToSolve.GetLength(1) != 9) { return(false); } int minimumOfSudokuClues = 17; int countOfClues = 0; InitializeSudoku(); this.fixedSudokuNumbers = new bool[9, 9]; for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { if (sudokuToSolve[i, j] == null) { sudokuToSolve[i, j] = new SudokuCell(i, j); } if (sudokuToSolve[i, j].Value != 0) { this.sudoku[i, j].Value = sudokuToSolve[i, j].Value; this.fixedSudokuNumbers[i, j] = true; countOfClues++; } } } if (countOfClues < minimumOfSudokuClues) { this.sudoku = null; this.fixedSudokuNumbers = null; return(false); } if (!ValidateSudokuNumbers()) { this.sudoku = null; this.fixedSudokuNumbers = null; return(false); } return(true); }
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); }
private void createCells() { for (int i = 0; i < 9; i++) { for (int j = 0; j < 9; j++) { cells[i, j] = new SudokuCell(); cells[i, j].Font = new Font(SystemFonts.DefaultFont.FontFamily, 20); cells[i, j].Size = new Size(60, 60); cells[i, j].ForeColor = SystemColors.ControlDarkDark; cells[i, j].Location = new Point(i * 50, j * 50); cells[i, j].BackColor = ((i / 3) + (j / 3)) % 2 == 0 ? SystemColors.Control : Color.YellowGreen; cells[i, j].FlatStyle = FlatStyle.Flat; cells[i, j].FlatAppearance.BorderColor = Color.Black; cells[i, j].X = i; cells[i, j].Y = j; cells[i, j].KeyPress += cell_keyPressed; panel1.Controls.Add(cells[i, j]); } } }
private void CreateCells() { ExecuteForEvery((i, j) => { // Create 81 cells for with styles and locations based on the index cells[i, j] = new SudokuCell(); cells[i, j].Font = new Font(SystemFonts.DefaultFont.FontFamily, 20); cells[i, j].Size = new Size(40, 40); cells[i, j].Location = new Point(i * 40, j * 40); cells[i, j].BackColor = ((i / 3) + (j / 3)) % 2 == 0 ? SystemColors.Control : Color.LightSeaGreen; cells[i, j].ForeColor = ((i / 3) + (j / 3)) % 2 == 0 ? Color.Black : Color.White; cells[i, j].FlatStyle = FlatStyle.Flat; cells[i, j].FlatAppearance.BorderColor = Color.Teal; cells[i, j].FlatAppearance.BorderSize = 1; cells[i, j].X = i; cells[i, j].Y = j; // Assign key press event for each cells cells[i, j].KeyPress += cell_keyPressed; panel1.Controls.Add(cells[i, j]); }); }
/// <summary> /// Creates a list of Sudoku Cells and determines each cell's sector, /// index, row and column values. List of available integer values /// and the initial value of Value property also set in that function. /// </summary> private void InitSudokuCells() { SudokuCell sudokuCell = null; int row = 0, column = 0, sector = 0, count = 1, startSector = 0; for (int i = 0; i < _gridSize; i++) { sudokuCell = new SudokuCell(_rowSize); if (i % _rowSize == 0 && i > 0) { column = 0; row++; if (row % _sectorRowSize != 0 && count <= _sectorRowSize) sector = startSector; else { startSector = sector; count = 1; } } if (column % _sectorRowSize == 0) sector++; sudokuCell.Value = 0; sudokuCell.Column = column; sudokuCell.Row = row; sudokuCell.Sector = sector; sudokuCell.Index = i; column++; _sudokuCellList.Add(sudokuCell); } }
private bool IfExistsInSector(SudokuCell sudokuCell) { return _sudokuCellList.Count(x => x.Value > 0 && x.Index != sudokuCell.Index && x.Sector == sudokuCell.Sector && x.Value == sudokuCell.Value) > 0; }
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); }
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!"); }
/// <summary> /// Checks sudoku constraints for the Sudoku Cell. /// Constraints are; /// 1. The value must be unique in row /// 2. The value must be unique in sector /// 3. The value must be unique in column /// </summary> /// <param name="sudokuCell"></param> /// <returns></returns> private bool CheckConstraints(SudokuCell sudokuCell) { return !IfExistsInSector(sudokuCell) && !IfExistsInRow(sudokuCell) && !IfExistsInColumn(sudokuCell); }
// construction public Sudoku() { try { m_SudokuArray = new SudokuCell[m_iSize][]; for (int i = 0; i < m_iSize; i++) { SudokuCell[] cells = new SudokuCell[m_iSize]; for (int j = 0; j < m_iSize; j++) { //cells[j] = new SudokuCell(i, j); cells[j] = new SudokuCell(); } m_SudokuArray[i] = cells; } } catch (Exception e) { Trace.WriteLine(e.Message); } }
/// <summary> /// A recursive function to genarete random values for each cell. /// In each recall, it is called with the previous SudokuCell in sudokuCellList. /// This function uses BackTrack Algorithm to fill each cell when a conflict occurs. /// </summary> /// <param name="sudokuCell">When NextIndex is null, current cell. Otherwise previous element that points to current cell</param> /// <param name="NextIndex">When this function is called recursively, NextIndex points the current cell's index.</param> private void GenerateRandomValue(SudokuCell sudokuCell, int? NextIndex = null) { do { if (sudokuCell.AvaliableIntList.Count(x => !x.Deleted) == 0) { //We need a reset for the current cell because we used all available numbers sudokuCell.Reset(); if (sudokuCell.Index == 0) // Worst case; we are starting to fill each cell from the beginning GenerateRandomValue(_sudokuCellList[0], 1); else GenerateRandomValue(_sudokuCellList[sudokuCell.Index - 1], sudokuCell.Index); } sudokuCell.Value = PickNextAvailableValue(sudokuCell.AvaliableIntList); } while (!CheckConstraints(sudokuCell) || sudokuCell.Value == 0); }
private void EliminatePreemptiveSetsInAGroup(SudokuGroup sudokuGroup) { int remainingPossibitySizeMax = 0; for (int cellIndex = 0; cellIndex <= 8; cellIndex++) { if (sudokuGroup.Cells[cellIndex].Value == 0) { remainingPossibitySizeMax++; } } for (int remainingPossibitySize = 2; remainingPossibitySize <= remainingPossibitySizeMax; remainingPossibitySize++) { { //1. Adjust possibilities for a Column HashSet <int> preemptiveSet = new HashSet <int>(); HashSet <int> cellsWithCommonPossilities = new HashSet <int>(); for (int cellIndex = 0; cellIndex <= 8; cellIndex++) { var remainingPossibilitiesSet = sudokuGroup.Cells[cellIndex].RemainingPossibilities; if (sudokuGroup.Cells[cellIndex].Value == 0 && remainingPossibilitiesSet.Count <= remainingPossibitySize) { var tempSet = new HashSet <int>(remainingPossibilitiesSet); tempSet.UnionWith(preemptiveSet); if (tempSet.Count <= remainingPossibitySize) { cellsWithCommonPossilities.Add(cellIndex); preemptiveSet.UnionWith(remainingPossibilitiesSet); } if (cellsWithCommonPossilities.Count == preemptiveSet.Count) { break; } } } if (cellsWithCommonPossilities.Count == preemptiveSet.Count && preemptiveSet.Count > 0) { for (int cellIndex = 0; cellIndex <= 8; cellIndex++) { SudokuCell cell = sudokuGroup.Cells[cellIndex]; if (cell.Value == 0 && !cellsWithCommonPossilities.Contains(cellIndex)) { //Reduce the possibilities. cell.RemainingPossibilities.ExceptWith(preemptiveSet); if (cell.RemainingPossibilities.Count == 1) { cell.Value = cell.RemainingPossibilities.First(); // Logger.WriteLine($"Solved a cell by preemptive Set. {cell.ColIndex},{cell.RowIndex}={cell.Value}"); if (preemptiveSet.Count == 2) { cell.SolvingDifficulty = SolvingDifficulty.Medium; } if (preemptiveSet.Count == 3) { cell.SolvingDifficulty = SolvingDifficulty.Hard; } if (preemptiveSet.Count == 4) { cell.SolvingDifficulty = SolvingDifficulty.MaxDifficulty; } } } } } } remainingPossibitySize++; } }
private bool IfExistsInColumn(SudokuCell sudokuCell) { return _sudokuCellList.Count(x => x.Value > 0 && x.Index != sudokuCell.Index && x.Column == sudokuCell.Column && x.Value == sudokuCell.Value) > 0; }
private bool IfExistsInRow(SudokuCell sudokuCell) { return _sudokuCellList.Count(x => x.Value > 0 && x.Index != sudokuCell.Index && x.Row == sudokuCell.Row && x.Value == sudokuCell.Value) > 0; }
private void InitCells(SudokuGrid grid) { //Initialize and set highlighted cell. CurrentCell = new SudokuCell(FirstCellRowPosition, FirstCellColPosition); CurrentCellRowIndex = 0; CurrentCellColIndex = 0; //Initialize other number fields. const int SudokuDim = SudokuGrid.SudokuDimension; cells = new SudokuCell[SudokuDim,SudokuDim]; int currWindowRowPos = GameWindow.FirstCellRowPosition; int currWindowColPos = GameWindow.FirstCellColPosition; const int RowIncrement = GameWindow.CellPositionRowIncrements; const int ColIncrement = GameWindow.CellPositionColIncrements; for (int row = 0; row < SudokuDim; row++) { for (int col = 0; col < SudokuDim; col++) { cells[row, col] = new SudokuCell(grid[row, col], grid.IsEditable(row, col), currWindowRowPos, currWindowColPos); currWindowColPos += ColIncrement; } currWindowColPos = GameWindow.FirstCellColPosition; currWindowRowPos += RowIncrement; } //Initialize menu items menuCells = new MenuCell[MenuItemLabels.Length]; for (int item = 0; item < menuCells.Length; item++) { menuCells[item] = new MenuCell(MenuItemsCellRowPosition, MenuItemsCellColPositions[item], MenuItemLabels[item]); } RedrawCells(); }