// returns whether this board is solved or not
        public bool Solve(int[,] sudokuBoard)
        {
            // list of all the strategies
            List <ISudokuStrategy> strategies = new List <ISudokuStrategy>()
            {
                new SimpleMarkUpStrategy(_sudokuMapper),
                new NakedPairStrategy(_sudokuMapper)
            };

            // has the state of the board
            var currentState = _boardStateManager.GenerateState(sudokuBoard);
            var nextState    = _boardStateManager.GenerateState(strategies.First().Solve(sudokuBoard));

            // continue solving with all the strategies unil its solved
            while (!_boardStateManager.IsSolved(sudokuBoard) && currentState != nextState)
            {
                // move state to next state to make sure the board is updated
                currentState = nextState;

                foreach (var strategy in strategies)
                {
                    nextState = _boardStateManager.GenerateState(strategy.Solve(sudokuBoard));
                }
            }

            return(_boardStateManager.IsSolved(sudokuBoard));
        }
        public bool Solve(int [,] sudokuBoard)
        {
            // Lijst met strategieën
            List <IStrategy> strategies = new List <IStrategy>()
            {
                new SimpleMarkUpStrategy(_mapper),
                new NakedPairStrategy(_mapper),
            };

            // Huidige staat van het bord bepalen
            var curState = _boardStateManager.GenerateState(sudokuBoard);

            // Staat van het bord bepalen na het toepassen van de eerste strategie
            var nextState = _boardStateManager.GenerateState(strategies.First().Solve(sudokuBoard));

            // Zolang het bord niet is opgelost ENde huidige staat niet gelijk is aan de volgende staat
            // (want dan doen de strategieën niks en kan het spel niet worden opgelost)
            while (!_boardStateManager.IsSolved(sudokuBoard) && curState != nextState)
            {
                // Huidige staat is de oude volgende staat
                curState = nextState;
                foreach (var strategy in strategies)
                {
                    // Voor elke strategie de solve functie aanroepen en kijken of dat een verandering oplevert, anders kan het spel niet worden opgelost
                    nextState = _boardStateManager.GenerateState(strategy.Solve(sudokuBoard));
                }
            }
            // if (curState != nextState): false; // geen oplossing
            // if (_boardStateManager.IsSolved(sudokuBoard)): true; spel is opgelost
            return(_boardStateManager.IsSolved(sudokuBoard));
        }
Example #3
0
        public bool Solve(int[,] sudokuBoard)
        {
            var strategies = new List <ISudokuStrategy>()
            {
                new SimpleMarkupStrategy(sudokuMapper),
                new NakedPairsStrategy(sudokuMapper)
            };

            var currentState = boardStateManager.GenerateState(sudokuBoard);
            var nextState    = boardStateManager.GenerateState(strategies.First().Solve(sudokuBoard));

            while (!boardStateManager.IsSolved(sudokuBoard) && currentState != nextState)
            {
                currentState = nextState;
                foreach (var strategy in strategies)
                {
                    nextState = boardStateManager.GenerateState(strategy.Solve(sudokuBoard));
                }
            }

            return(boardStateManager.IsSolved(sudokuBoard));
        }