public void ButtonClicked() { GameObject selectedObject = EventSystem.current.currentSelectedGameObject; if (selectedObject != null) { //Selektovali smo dugme Debug.Log("Clicked on : " + selectedObject.name); if (selectedObject.tag == "SudokuButton") { selectedField = selectedObject; } else if (selectedObject.tag == "NumericButton") { selectedNumber = selectedObject; //Logika if (selectedField != null) { int number; SudokuField fieldInfo = selectedField.GetComponent <SudokuField>(); bool parseOk = int.TryParse(selectedNumber.name, out number); if (parseOk) { sudoku.SetNewNumber(fieldInfo.rowIndex, fieldInfo.columnIndex, number); } } } } }
public SudokuPuzzle Deserialize() { var sudokufields = new SudokuField[9, 9]; fields.ForEach(x => sudokufields[x.row, x.column] = new SudokuField(x.value)); return(new SudokuPuzzle(sudokufields)); }
private void button1_Click(object sender, EventArgs e) { byte[] nums = ParseNums(); long ctr1 = 0, ctr2 = 0, freq = 0; Utils.QueryPerformanceFrequency(ref freq); if (Utils.QueryPerformanceCounter(ref ctr1) != 0) // Begin timing. { var solves = new SudokuField().Solve(nums).Take(100).ToList(); Utils.QueryPerformanceCounter(ref ctr2); // Finish timing. if (solves.Count >= 100) { textBox2.Text = solves[0]; label1.Text = $"Всего решений более{solves.Count} за {(ctr2 - ctr1) * 1.0 / freq:0.0000}"; } else if (solves.Count > 0) { textBox2.Text = solves[0]; label1.Text = $"Всего решений {solves.Count} за {(ctr2 - ctr1) * 1.0 / freq:0.0000}"; } else { textBox2.Text = ""; label1.Text = $"Решений нет за {(ctr2 - ctr1) * 1.0 / freq:0.0000}"; } } }
private Result Analyze(SudokuField sudokuField, KeyValuePair <Position, SudokuElement> entry) { var row = entry.Key.Row; var column = entry.Key.Column; var result = base.Process(sudokuField, row, column); if (result != Result.None) { return(result); } HashSet <int> existngNumbers = GetNumbersFromSudokuSection(sudokuField, row, column); if (AddUniqueFromExisting(sudokuField.GetRow(row), entry.Value, existngNumbers)) { return(Result.Added); } if (AddUniqueFromExisting(sudokuField.GetColumn(column), entry.Value, existngNumbers)) { return(Result.Added); } if (AddUniqueFromExisting(sudokuField.GetSection(row, column), entry.Value, existngNumbers)) { return(Result.Added); } return(Result.None); }
public void Load(TextReader reader) { Status("Saving puzzle"); field = new SudokuField(); field.LoadNewPuzzle(reader); Status("Puzzle saved"); }
public void CreateNewSudoku(int rows, int columns) { Status("Creating puzzle"); field = SudokuField.CreateNewField(rows, columns); DataBind(); Status("Puzzle created"); }
protected SudokuPuzzle guessNextField(SudokuPuzzle sudoku, SudokuField field) { SudokuPuzzle result = null; foreach (int value in field.GetPossibleValues().Shuffle()) { // make copy of sudoku and try out possibility var copy = (SudokuPuzzle)sudoku.Clone(); copy.Fields[field.RowIndex, field.ColumnIndex].SetValue(value); if (copy.IsValid()) { // go to next recursion level result = solveSudokuRecursive(copy); // pass correct solution to lower recursion levels if (result != null) { break; } } } return(result); }
private static void CheckCollision(SudokuField sudoku) { if (Validator.IsCollision(sudoku)) { throw new SudokuCollisionNumberException("There are the same numbers in row/column/section"); } }
static void Main(string[] args) { SudokuField sudoku = new SudokuField(); MainSolver solver = new MainSolver(); sudoku = solver.Process(sudoku); Console.WriteLine(sudoku); }
private SudokuElement FindFirstEmpty(SudokuField sudokuField) { return(sudokuField.Field .Select(n => n.Value) .Where(n => n.Number == Data.Empty) .DefaultIfEmpty(null) .FirstOrDefault()); }
public HashSet <int> GetNumbersFromSudokuSection(SudokuField sudokuField, int row, int column) { return(sudokuField.GetSudokuSection(row, column) .Select(n => n.Value) .Select(n => n.Number) .Where(n => n != Data.Empty) .ToHashSet()); }
static void Main(string[] args) { Console.Clear(); SudokuField field = new SudokuField(Difficulty.Easy); Console.WriteLine(field.Solved); Console.WriteLine(field.ToString()); }
private Result SolveElement(SudokuField sudokuField, KeyValuePair <Position, SudokuElement> entry) // SudokuElement sudokuElement) { if (entry.Value.Number == Data.Empty) { return(Analyze(sudokuField, entry)); } return(Result.None); }
public new SolverResult Process(SudokuField sudokuField) { _sudokuFieldCopy = sudokuField; Stack <StackElement> stackElements = new Stack <StackElement>(); StackElement stackElement; Result result = Result.None; int index; while (true) { switch (result) { case Result.FullFilled: return(new SolverResult(Result.FullFilled, _sudokuFieldCopy)); case Result.Error: bool loop = true; do { if (stackElements.Count == 0) { return(new SolverResult(Result.Error)); } stackElement = stackElements.Pop(); index = stackElement.Index + 1; if (index < stackElement.GetCandidateSize()) { _sudokuFieldCopy = stackElement.SudokuField; _sudokuElement = stackElement.SudokuElement; if (PutOnStack(stackElements, index) == Result.Error) { return(new SolverResult(Result.Error)); } loop = false; } else { loop = true; } } while (loop); break; default: _sudokuElement = FindFirstEmpty(_sudokuFieldCopy); if (PutOnStack(stackElements, 0) == Result.Error) { return(new SolverResult(Result.Error)); } break; } result = base.Process(_sudokuFieldCopy); } }
protected Result Process(SudokuField sudokuField, int row, int column) { SudokuElement sudokuElement = sudokuField.GetSudokuElement(row, column); HashSet <int> existingNumbers = GetNumbersFromSudokuSection(sudokuField, row, column); foreach (int number in existingNumbers) { _ = sudokuElement.RemoveCandidate(number); } return(AddNumber(sudokuElement)); }
protected bool isFieldDetermined(SudokuPuzzle sudoku, SudokuPuzzle solution, SudokuField field) { // get value from the first solution int solutionValue = solution.Fields[field.RowIndex, field.ColumnIndex].Value; // try to solve the sudoku again, but now without the value from the first solution field.Possibilities[solutionValue - 1] = false; var secondSolution = guessNextField(sudoku, field); // if there is no second solution, the sudoku has definitely a unique solution return(secondSolution == null || solution.Equals(secondSolution)); }
public void HandlePuzzleLoading(SudokuField field) { Status("loading puzzle"); this.ContentType = field.ContentType; this._rows = field.NumRows; this._columns = field.NumColumns; field.AutoOutput = true; LayoutRoot.Children.Clear(); InitCanvas(field.NumRows, field.NumColumns); DataBind(); ShowValues(); field.Updated += new SudokuField.UpdateEvent(field_Updated); this.Height = field.NumRows * (cellHeight + CellSpacing) + CellSpacing; this.Width = field.NumColumns * (cellWidth + CellSpacing) + CellSpacing; Status("Puzzle loaded"); }
private bool removeField(SudokuPuzzle sudoku, SudokuPuzzle solution) { foreach (SudokuField field in sudoku.GetSetFields().Shuffle()) { // clone sudoku and set the field value to 0 SudokuPuzzle temp = (SudokuPuzzle)sudoku.Clone(); SudokuField tempField = temp.Fields[field.RowIndex, field.ColumnIndex]; tempField.SetValue(0); if (HasSudokuUniqueSolution(temp)) { field.SetValue(0); return(true); } } return(false); }
private Result PutOnStack(Stack <StackElement> stack, int index) { StackElement stackElement = new StackElement(_sudokuFieldCopy, _sudokuElement, index); stack.Push(stackElement); _sudokuFieldCopy = _sudokuFieldCopy.DeepCopy(); _sudokuElement = FindFirstEmpty(_sudokuFieldCopy); if (_sudokuElement == null) { return(Result.Error); } int number = _sudokuElement.GetCandidate(index); _sudokuElement.Number = number; _sudokuElement.FontColor = Data.BackTrackColor; return(Result.None); }
public SudokuField Process(SudokuField sudoku) { CheckCollision(sudoku); _ = _solverUnique.Process(sudoku); if (_solverUnique.Process(sudoku) != Result.FullFilled) { SolverResult solverResult = _solverBackTrack.Process(sudoku); if (solverResult.Result == Result.Error) { throw new SudokuUnsolvableException("There is no solution for this Sudoku."); } else { sudoku = solverResult.Sudoku; } } return(sudoku); }
private void button2_Click(object sender, EventArgs e) { byte[] nums = ParseNums(); long ctr1 = 0, ctr2 = 0, freq = 0; Utils.QueryPerformanceFrequency(ref freq); if (Utils.QueryPerformanceCounter(ref ctr1) != 0) // Begin timing. { var solve = new SudokuField().Solve(nums).FirstOrDefault(); Utils.QueryPerformanceCounter(ref ctr2); // Finish timing. if (solve != null) { textBox2.Text = solve; label1.Text = $"Всего решений 1 за {(ctr2 - ctr1) * 1.0 / freq:0.0000}"; } else { textBox2.Text = ""; label1.Text = $"Решений нет за {(ctr2 - ctr1) * 1.0 / freq:0.0000}"; } } }
public Result Process(SudokuField sudokuField) { bool loop; do { loop = false; foreach (KeyValuePair <Position, SudokuElement> entry in sudokuField.Field) //.Values) { Result result = SolveElement(sudokuField, entry); switch (result) { case Result.Error: return(Result.Error); case Result.Added: loop = true; break; } } } while (loop); return(Validator.IsFilled(sudokuField) ? Result.FullFilled : Result.None); }
public StackElement(SudokuField sudokuField, SudokuElement sudokuElement, int index) { SudokuField = sudokuField; SudokuElement = sudokuElement; Index = index; }
public void LoadNewPuzzle(string path) { field = new SudokuField(); field.LoadNewPuzzle(path); HandlePuzzleLoading(field); }
public void LoadNewPuzzle(TextReader reader) { field = new SudokuField(); field.LoadNewPuzzle(reader); HandlePuzzleLoading(field); }
public SolverResult(Result result, SudokuField sudokuField) { Result = result; Sudoku = sudokuField; }