using System;

namespace Sudoku

{

    class SudokuSolver

    {

        static void Main(string[] args)

        {

        //  int[,] sudoku = new int[9, 9];

            Console.WriteLine("Welcome to the sudoku-solver!");

            //  Console.WriteLine("please enter the numbers on your sudoko board (instead of an empty cell enter -1), one nember any time, row after row, left to right.");

            //  for (int j = 0; j < 9; j++)

            //  {

            //      for (int i = 0; i < 9; i++)

            //          sudoku[i, j] = int.Parse(Console.ReadLine());

            //  }

            int[,] sudoku = {{5,3,-1,-1,7,-1,-1,-1,-1 },

                {6,-1,-1,1,9,5,-1,-1,-1 },

                {-1,9,8,-1,-1,-1,-1,6,-1 },

                {8,-1,-1,-1,6,-1,-1,-1,3 },

                {4,-1,-1,8,-1,3,-1,-1,1 },

                {7,-1,-1,-1,2,-1,-1,-1,6 },

                {-1,6,-1,-1,-1,-1,2,8,-1 },

                {-1,-1,-1,4,1,9,-1,-1,5 },

                {-1,-1,-1,-1,8,-1,-1,7,9 } };

            sudoku = Solve(sudoku, 0, 0);

            Console.WriteLine("your sudoku's solution:");

            for (int j = 0; j < 9; j++)

            {

                for (int i = 0; i < 9; i++)

                    Console.Write(sudoku[i,j] + " ");

                Console.WriteLine("");

            }

            Console.WriteLine("goodbay, and thanks for using the sudoku-solver! see you soon!");

            Console.WriteLine("(: (: (:");

        }

        public static int[,] Solve(int[,] sudoku, int a, int b)

        {

            int i = a, j = b;

            while (sudoku[i, j] != -1 && !(j == 8 && i == 8))

            {

                if (i == 8)

                {

                    i = 0;

                    j++;

                }

                else

                    i++;

            }

            if (sudoku[i, j] != -1 && i == 8 && j == 8)

                return sudoku;

            int[] options = Options(sudoku, i, j);

            int c = CurrentOption(options, 0);

            // codeBlock1 ? ---

            sudoku[i, j] = c;

            // ---

            // codeBlock1

            if (c == -1)

            {

                if(a == 0)

                {

                    sudoku[8, b - 1] = -1;

                    return sudoku;

                }

                else

                {

                    sudoku[a - 1, b] = -1;

                    return sudoku;

                }

            }

            // end of codeBlock1

            if (i == 8 && j == 8)

                return sudoku;

            else /* codeBlock2 */ if (i == 8)

                sudoku = Solve(sudoku, 0, j + 1);

            else

                sudoku = Solve(sudoku, i + 1, j);

            // end of codeBlock2

            while (sudoku[i, j] == -1)

            {

                options[c - 1] = -1;

                c = CurrentOption(options, c);

                // codeBlock1.0 ? ---

                sudoku[i, j] = c;

                // ---

                // codeBlock1.0

                if (c == -1)

                {

                    if (a == 0)

                    {

                        sudoku[8, b - 1] = -1;

                        return sudoku;

                    }

                    else

                    {

                        sudoku[a - 1, b] = -1;

                        return sudoku;

                    }

                }

                // end of codeBlock1.0

                // codeBlock2

                if (i == 8)

                    sudoku = Solve(sudoku, 0, j + 1);

                else

                    sudoku = Solve(sudoku, i + 1, j);

                // end of codeBlock2

            }

            return sudoku;

        }

​

​

        public static int[] Options(int[,] sudoku, int i, int j)

        {

            int[] options = new int[9];

            int n, k, temporary;

            for (k = 0; k < 9; k++)

                options[k] = k + 1;

            for (n = 0; n < 9; n++)

            {

                temporary = sudoku[i, n];

                if (temporary != -1)

                    options[temporary - 1] = -1;

            }

            for (k = 0; k < 9; k++)

            {

                temporary = sudoku[k, j];

                if (temporary != -1)

                    options[temporary - 1] = -1;

            }

            // it's very annoying, but we have to check the square.

            int x, y;

            x = i / 3;

            y = j / 3;

            for (k = 0; k < 3; k++)

            {

                if (k != j%3)

                {

                    y = y + k;

                    for (n = 0; n < 3; n++)

                    {

                        if (n != i%3)

                        {

                            x = x + n;

                            temporary = sudoku[x, y];

                            if (temporary != -1)

                                options[temporary - 1] = -1;

                        }

                    }

                }

            }

            return options;

        }

​

​

        public static int CurrentOption(int[] options, int c)

        {

            for (int i = c; i < 9 ; i++)

            {

                if (options[i] != -1)

                    return options[i];

            }

            return -1; 

        }

    }

}

​

​