编写一个应用程序来确定数独方块是否有效

Question

编写一个应用程序来确定数独方块是否有效。该代码现在运行良好。

示例：

对于输入数据：

9 1 8  5 7 2  6 4 3
7 5 3  6 9 4  1 8 2
2 6 4  1 8 3  7 9 5

1 9 6  4 2 8  5 3 7
3 8 2  7 5 6  9 1 4
5 4 7  9 3 1  8 2 6

4 7 9  2 1 5  3 6 8
8 2 5  3 6 9  4 7 1
6 3 1  8 4 7  2 5 9

控制台会显示：

True

建议1：

第一步是从键盘读取数独方块。

注意：您应该在正方形的一行上的元素之间允许空行和多个 space，以便您可以以更易读的形式对数字进行分组（例如正方形格式作为问题中的示例）。

如果一行包含多于或少于 9 个元素、非数字值、小于 1 或大于 9 的数字，程序将 return 为假。

阅读完整的购物车后，我们检查输入的配置是否有效。为此，我们依次获取帧的每一列、行和 3x3 块，并检查从 1 到 9 的每个元素是否恰好出现一次。

这是我的代码：

using System;

namespace Sudoku
{
    class Program
    {
        const int SudokuBoardSize = 9;
        const int SudokuBlockSize = 3;

        static void Main()
        {
            byte[,] sudokuBoard = new byte[SudokuBoardSize, SudokuBoardSize];
            Console.WriteLine(ReadSudokuBoard(sudokuBoard) && IsValidSudokuBoard(sudokuBoard));
            Console.Read();
        }

        static bool IsValidSudokuBoard(byte[,] sudokuBoard)
        {
            for (int i = 0; i < SudokuBoardSize; i++)
            {
                if (!IsValidSudokuItem(sudokuBoard, "line", i) ||
                    !IsValidSudokuItem(sudokuBoard, "column", i) ||
                    !IsValidSudokuItem(sudokuBoard, "block", i))
                {
                    return false;
                }
            }

            return true;
        }

        static bool IsValidSudokuItem(byte[,] sudokuBoard, string itemType, int itemIndex)
        {
            byte[] sudokuValuesCount = new byte[SudokuBoardSize];

            for (int i = 0; i < SudokuBoardSize; i++)
            {
                byte sudokuValue = GetSudokuValue(sudokuBoard, itemType, itemIndex, i);
                sudokuValuesCount[sudokuValue - 1]++;
                if (sudokuValuesCount[sudokuValue - 1] > 1)
                {
                    return false;
                }
            }

            return true;
        }

        static byte GetSudokuValue(byte[,] sudokuBoard, string itemType, int itemIndex, int position)
        {
            switch (itemType)
            {
                case "line":
                    return sudokuBoard[itemIndex, position];
                case "column":
                    return sudokuBoard[position, itemIndex];
                case "block":
                    int line = itemIndex / SudokuBlockSize * SudokuBlockSize + position / SudokuBlockSize;
                    int column = itemIndex % SudokuBlockSize * SudokuBlockSize + position % SudokuBlockSize;
                    return sudokuBoard[line, column];
            }

            return 0;
        }

        static bool ReadSudokuBoard(byte[,] sudokuBoard)
        {
            for (int i = 0; i < SudokuBoardSize; i++)
            {
                string[] lineValues = ReadLineValues();
                if (lineValues.Length != SudokuBoardSize)
                {
                    return false;
                }

                for (int j = 0; j < SudokuBoardSize; j++)
                {
                    if (!IsValidSudokuValue(lineValues[j], out int value))
                    {
                        return false;
                    }

                    sudokuBoard[i, j] = (byte)value;
                }
            }

            return true;
        }

        static string[] ReadLineValues()
        {
            string line;
            do
            {
                line = Console.ReadLine();
            }
            while (line == "");

            return line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
        }

        static bool IsValidSudokuValue(string stringValue, out int value)
        {
            if (!int.TryParse(stringValue, out value))
            {
                return false;
            }

            if (value < 1 || value > SudokuBoardSize)
            {
                return false;
            }

            return true;
        }
    }
}

Answer 1

这里是你的代码，用于去除空格并将 SUDOKU 矩阵的完整行作为输入：

static void Main(string[] args)
{
    

    int[][] matrix = new int[9][];
    for (int i = 0; i < 9; i++)
    {
        Console.WriteLine($"Enter line {i}:");

        string input = Console.ReadLine();
        
        string input_removed_spaces = input.Replace(" ", "");
        // if you want to remove all whitespaces, you can use Regex for example:
        // input_removed_all_whitespaces = Regex.Replace(input, @"\s+", "");

        //Before setting the matrix, obviously you need additional checks, for example if the user enters invalid inputs
        matrix[i] = Array.ConvertAll(input_removed_spaces.ToCharArray(), c => (int)Char.GetNumericValue(c));
    }

    // do stuff with your matrix here
}

正如所写，您将必须实施额外的检查（如果用户输入字母，什么都不输入，到很多数字，......）但这应该让您开始

Answer 2

如果想在读取矩阵的时候忽略空格，可以参考下面的代码：

static void Main(string[] args)
    {
        int[,] matrix = new int[9, 9];
        Console.WriteLine("input:");
        for (int i = 0; i < 9; i++)
        {
            string str = Console.ReadLine();
            string newstr = Regex.Replace(str, @"\s", "");
            if (newstr == "")
            { 
                i--;
            }
            else
            {
                for (int j = 0; j < 9; j++)
                {
                    matrix[i, j] = Convert.ToInt32(newstr[j]) - 48;
                }
            }
        }
    }

下面的代码可以判断一个数独方块是否有效：

class Program
{
    static void Main(string[] args)
    {
        int[,] matrix = new int[9, 9];
        Console.WriteLine("input:");
        for (int i = 0; i < 9; i++)
        {
            string str = Console.ReadLine();
            string newstr = Regex.Replace(str, @"\s", "");
            if (newstr == "")
            { 
                i--;
            }
            else
            {
                for (int j = 0; j < 9; j++)
                {
                    matrix[i, j] = Convert.ToInt32(newstr[j]) - 48;
                }
            }
        }
        if (isValidSudoku(matrix))
        {
            Console.WriteLine("True");
        }
        else
        {
            Console.WriteLine("False");
        }
    }
    static int N = 9;
    static bool isinRange(int[,] matrix)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (matrix[i, j] <= 0 ||matrix[i, j] > 9)
                {
                    return false;
                }
            }
        }
        return true;
    }
    static bool isValidSudoku(int[,] matrix)
    {
        if (isinRange(matrix) == false)
        {
            return false;
        }
        bool[] unique = new bool[N + 1];
        for (int i = 0; i < N; i++)
        {
            Array.Fill(unique, false);
            for (int j = 0; j < N; j++)
            {
                int Z = matrix[i, j];
                if (unique[Z])
                {
                    return false;
                }
                unique[Z] = true;
            }
        }
        for (int i = 0; i < N; i++)
        {
            Array.Fill(unique, false);
            for (int j = 0; j < N; j++)
            {
                int Z = matrix[j, i];
                if (unique[Z])
                {
                    return false;
                }
                unique[Z] = true;
            }
        }
        for (int i = 0; i < N - 2; i += 3)
        {
            for (int j = 0; j < N - 2; j += 3)
            {
                Array.Fill(unique, false);
                for (int k = 0; k < 3; k++)
                {
                    for (int l = 0; l < 3; l++)
                    {
                        int X = i + k;
                        int Y = j + l;
                        int Z = matrix[X, Y];
                        if (unique[Z])
                        {
                            return false;
                        }
                        unique[Z] = true;
                    }
                }
            }
        }
        return true;
    }
}

这是我测试的截图。

编写一个应用程序来确定数独方块是否有效

Write an application that determines whether a Sudoku square is valid

c#

boolean

matrix

sudoku

visual-studio