Пример #1
0
        private SolvedSudokuGrid RecursivelySolve(SudokuGrid sudokuGrid, int row, int col)
        {
            var currentGrid = new SudokuGrid(sudokuGrid);
            var gridValue   = currentGrid.GetGridValue(row, col);

            currentGrid.UpdateCandidateValues(row, col, gridValue.Value);
            var coords = currentGrid.GetSmallestCandidateValuesCellCoordinates();

            var values = currentGrid.GetCandidateValues(coords.Item1, coords.Item2);

            if (values.Count == 0)
            {
                if (IsSolved(currentGrid))
                {
                    return(new SolvedSudokuGrid(currentGrid, true, true));
                }
                return(new SolvedSudokuGrid(currentGrid, true, false));
            }

            SolvedSudokuGrid previouslySolvedGrid = null;

            foreach (var value in values.ToList())
            {
                currentGrid.SetGridValue(coords.Item1, coords.Item2, value);
                var solvedGrid = RecursivelySolve(currentGrid, coords.Item1, coords.Item2);

                if (solvedGrid.Solvable && (solvedGrid.Unique == false || previouslySolvedGrid != null))
                {
                    return(new SolvedSudokuGrid(solvedGrid.SolvedGrid, false, true));
                }
                if (solvedGrid.Solvable && previouslySolvedGrid == null)
                {
                    previouslySolvedGrid = new SolvedSudokuGrid(solvedGrid.SolvedGrid, true, true);
                }
            }

            if (previouslySolvedGrid != null)
            {
                return(new SolvedSudokuGrid(previouslySolvedGrid.SolvedGrid, previouslySolvedGrid.Unique, true));
            }

            return(new SolvedSudokuGrid(currentGrid, true, false));
        }
Пример #2
0
        public SudokuGrid GenerateGrid(GameType gameType)
        {
            var  grid = new SudokuGrid();
            bool unique;
            var  count = 0;

            while (true)
            {
                while (count < 22)
                {
                    var row    = new Random().Next(0, 9);
                    var column = new Random().Next(0, 9);
                    var value  = new Random().Next(1, 10);

                    if (grid.GetGridValue(row, column).Value == 0)
                    {
                        if (SudokuSolver.IsValidMove(row, column, value, grid))
                        {
                            grid.SetGridValue(row, column, value, true);
                            count++;
                        }
                    }
                }

                var solvedGrid = SudokuSolver.Solve(new SudokuGrid(grid));

                if (solvedGrid.Solvable)
                {
                    unique = solvedGrid.Unique;
                    break;
                }

                grid  = new SudokuGrid();
                count = 0;
            }

            while (unique == false)
            {
                var row    = new Random().Next(0, 9);
                var column = new Random().Next(0, 9);
                var value  = new Random().Next(1, 10);

                if (grid.GetGridValue(row, column).Value == 0)
                {
                    if (SudokuSolver.IsValidMove(row, column, value, grid))
                    {
                        grid.SetGridValue(row, column, value, true);
                        var solvedGrid = SudokuSolver.Solve(new SudokuGrid(grid));

                        if (solvedGrid.Solvable == false)
                        {
                            grid.SetGridValue(row, column, 0, false);
                        }
                        else
                        {
                            unique = solvedGrid.Unique;
                        }
                    }
                }
            }

            return(grid);
        }