Пример #1
0
        private IEnumerable <GuessGrid> IterateStrategies(Grid[,] grids, int bombCount)
        {
            var currBoard      = new StrategyBoard(grids, bombCount);
            var currGuesses    = RunStrategies(currBoard);
            var currConfirmeds = currGuesses.Where(t => t.Confidence >= 1).ToArray();

            var currBombs = currConfirmeds.Where(t => t.Value == GuessValue.Bomb).Select(t => t.Point).Distinct().ToArray();

            if (currBombs.Any() == false)
            {
                return(currGuesses);
            }

            Console.WriteLine("Iterate strategies");

            var nextGrids = (Grid[, ])grids.Clone();

            foreach (var currBomb in currBombs)
            {
                var nextGridValue = nextGrids[currBomb.X, currBomb.Y];
                if (nextGridValue != Grid.Raw)
                {
                    throw new InvalidOperationException();
                }

                nextGrids[currBomb.X, currBomb.Y] = Grid.Flag;
            }
            var nextBombCount = bombCount - currBombs.Count();
            var nextGuesses   = IterateStrategies(nextGrids, nextBombCount).ToArray();

            var nextConfirmeds = nextGuesses.Where(t => t.Confidence >= 1);

            if (nextConfirmeds.Any() == false)
            {
                return(currGuesses);
            }

            return(currConfirmeds.Concat(nextConfirmeds));
        }
Пример #2
0
        private IEnumerable <GuessGrid> RunStrategies(StrategyBoard board)
        {
            var progress = 1 - (float)board.RawCount / (board.Size.Width * board.Size.Height);

            if (progress >= .1)
            {
                var countStrategy = new CountStrategy(board);
                Console.WriteLine("Run count strategy");

                var countGuesses = countStrategy.Guess().ToArray();
                if (countGuesses.Any())
                {
                    return(countGuesses);
                }
            }

            if (progress >= .4)
            {
                var bruteForceStrategy = new BruteForceStrategy(board, progress < .7 ? 5 : 8);
                Console.WriteLine("Run brute-force strategy");

                var bruteForceGuesses = bruteForceStrategy.Guess().ToArray();
                if (bruteForceGuesses.Any())
                {
                    var confirmedBruteForceGuesses = bruteForceGuesses.Where(t => t.Confidence >= 1).ToArray();
                    if (confirmedBruteForceGuesses.Any())
                    {
                        return(confirmedBruteForceGuesses);
                    }

                    var probableBruteForceGuesses = bruteForceGuesses.OrderByDescending(t => t.Confidence).First();
                    return(new[] { probableBruteForceGuesses });
                }
            }

            if (progress <= .1)
            {
                var startCount = (int)((float)board.RawCount / board.BombCount * 3);

                var startStrategy = new RandomStrategy(board);
                Console.WriteLine("Run start strategy");

                var startGuesses = startStrategy.Guess().Take(startCount).ToArray();
                if (startGuesses.Any())
                {
                    return(startGuesses);
                }
            }

            var randomStrategy = new RandomStrategy(board);

            Console.WriteLine("Run random strategy");

            var randomGuesses = randomStrategy.Guess();

            if (randomGuesses.Any())
            {
                var probableRandomGuesses = randomGuesses.OrderByDescending(t => t.Confidence).First();
                return(new[] { probableRandomGuesses });
            }

            return(new GuessGrid[0]);
        }