Esempio n. 1
0
        static void Main(string[] args)
        {
            try
            {
                SudokuMapper         sudokuMapper         = new SudokuMapper();
                SudokuStateManger    sudokuStateManger    = new SudokuStateManger();
                SudokuSolverEngine   sudokuSolverEngine   = new SudokuSolverEngine(sudokuStateManger, sudokuMapper);
                SudokuFileReader     sudokuFileReader     = new SudokuFileReader();
                SudokuBoardDisplayer sudokuBoardDisplayer = new SudokuBoardDisplayer();

                Console.WriteLine("Please enter the sudoku file name:");
                var filename = Console.ReadLine();

                var board = sudokuFileReader.ReadFile(filename);
                sudokuBoardDisplayer.Display("Initial State", board);

                bool isSudokuSolved = sudokuSolverEngine.Solve(board);
                sudokuBoardDisplayer.Display("Final State", board);

                Console.WriteLine(isSudokuSolved ? "Success!" : "Cannot solve this sudoku");
            }
            catch (Exception ex)
            {
                Console.WriteLine("{0} : {1}", "Puzzle could not be solved", ex.Message);
            }
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            try
            {
                SudokuMapper sudokuMapper = new SudokuMapper();
                SudokuBoard  sudokuBoard  = new SudokuBoard();
                SudokuEngine sudokuEngine = new SudokuEngine(sudokuBoard, sudokuMapper);
                SudokuReader sudokuReader = new SudokuReader();

                Console.WriteLine("Please enter the Sudoku file name:");
                var filename = Console.ReadLine();

                var sudoku = sudokuReader.ReadFile(filename);
                sudokuBoard.Show(sudoku);

                bool isSudoKuSolved = sudokuEngine.Solve(sudoku);
                sudokuBoard.Show(sudoku);

                Console.WriteLine(isSudoKuSolved
                    ? "Sudoku is solved."
                    : "Unfortunately, current algorithm(s) were not enough to solve the Sudoku.");
            }
            catch (Exception e)
            {
                Console.WriteLine("{0}:{1}", "Something go wrong! ", e.Message);
            }
        }
Esempio n. 3
0
        static void Main(string[] args)
        {
            try
            {
                SudokuTextFileReader  sudokuTextFileReader  = new SudokuTextFileReader();
                SudokuMatrixDisplayer sudokuMatrixDisplayer = new SudokuMatrixDisplayer();
                SudokuMapper          sudokuMapper          = new SudokuMapper();
                SudokuStateManager    sudokuStateManager    = new SudokuStateManager();
                SudokuSolverEngine    sudokuSolverEngine    = new SudokuSolverEngine(sudokuStateManager, sudokuMapper);

                Console.WriteLine("Please enter the filename containing the Sudoku Puzzle:");
                var filename = Console.ReadLine();

                var sudokuMatrix = sudokuTextFileReader.ReadFile(filename);
                sudokuMatrixDisplayer.Display("Initial State", sudokuMatrix);

                bool isSudokuSolved = sudokuSolverEngine.Solve(sudokuMatrix);
                sudokuMatrixDisplayer.Display("Final State", sudokuMatrix);

                Console.WriteLine(isSudokuSolved ? "You have successfully solved this Sudoku Puzzle!"
                                                 : "Unfortunatley, current algorithm(s) were not enough to solve the current Sudoku Puzzle!");
            }

            catch (Exception ex)
            {
                // In real world we would want to log this message
                Console.WriteLine("{0} : {1}", "Sudoku Puzzle cannot be solved because there was an error:", ex.Message);
            }
        }
Esempio n. 4
0
        static void Main(string[] args)
        {
            try
            {
                SudokuMapper            sudokuMapper            = new SudokuMapper();
                SudokuBoardStateManager sudokuBoardStateManager = new SudokuBoardStateManager();
                SudokuSolverEngine      sudokuSolverEngine      = new SudokuSolverEngine(sudokuBoardStateManager, sudokuMapper);
                SudokuFileReader        sudokuFileReader        = new SudokuFileReader();
                SudokuBoardDisplayer    sudokuBoardDisplayer    = new SudokuBoardDisplayer();

                Console.WriteLine("Please Enter The File Name Containing The Sudoku Puzzle:");
                var filename = Console.ReadLine();

                var sudokuBoard = sudokuFileReader.ReadFile(filename);
                sudokuBoardDisplayer.Display("Initial State", sudokuBoard);

                bool IsSudokuSolved = sudokuSolverEngine.Solve(sudokuBoard);
                sudokuBoardDisplayer.Display("Final State", sudokuBoard);

                Console.WriteLine(IsSudokuSolved
                    ? "You Have Successfully Solved This Sudoku Puzzle!"
                    : "Unfortunately, current algorithm(s) were not enough to solve the current Sudoku Puzzle!");
            }
            catch (Exception ex)
            {
                //In Real World I Would Log This Message In A DataBase
                Console.WriteLine("{0} : {1}", "Sudoku Puzzle Cannot Be Solved Because There Was An Error:", ex.Message);
            }
        }
Esempio n. 5
0
        static void Main(string[] args)
        {
            SudokuBoardStateManager sudokuBoardStateManager = new SudokuBoardStateManager();
            SudokuMapper            sudokuMapper            = new SudokuMapper();
            Displayer        displayer        = new Displayer();
            SudokuEngine     sudokuEngine     = new SudokuEngine(sudokuBoardStateManager, sudokuMapper);
            SudokuFileReader sudokuFileReader = new SudokuFileReader();

            string fileName = "SudokuEasy.txt";

            var sudokuBoard = sudokuFileReader.FileReader(fileName);

            displayer.Display("initial", sudokuBoard);

            sudokuEngine.SolveSudoku(sudokuBoard);

            displayer.Display("final", sudokuBoard);

            Console.ReadKey();
        }
 public SudokuSolverEngine(SudokuBoardStateManager sudokuBoardStateManager, SudokuMapper sudokuMapper)
 {
     _sudokuBoardStateManager = sudokuBoardStateManager;
     _sudokuMapper            = sudokuMapper;
 }
 public SimpleMarkUpStrategy(SudokuMapper sudokuMapper)
 {
     _sudokuMapper = sudokuMapper;
 }
Esempio n. 8
0
 public SudokuEngine(SudokuBoard sudokuBoard, SudokuMapper sudokuMapper)
 {
     _sudokuBoard  = sudokuBoard;
     _sudokuMapper = sudokuMapper;
 }
 public NakedPairStrategy(SudokuMapper sudokuMapper)
 {
     this._sudokuMapper = sudokuMapper;
 }
 public SudokuSolverEngine(SudokuStateManager sudokuStateManager, SudokuMapper sudokuMapper)
 {
     this._sudokuMapper       = sudokuMapper;
     this._sudokuStateManager = sudokuStateManager;
 }
Esempio n. 11
0
 public NakedPairsStrategy(SudokuMapper sudokuMapper)
 {
     _sudokuMapper = sudokuMapper;
 }