使用数组检查宾果游戏程序中的行

Question

I have this problem of bingo, where I have to check for bingo, line, or nothing, for a given input, where I get the 3 X 3 bingo card, and next 15 numbers extracted. I've wrote some code and I pass the tests for bingo and nothing, but not for line and I don't know why because I think my logic is good.

Here is the input:

1 2 3
4 5 6
7 8 9
1
2
3
4
5
6
7
8
10
11
12
13
14
15
16

I should have the result "line" but I get "nothing" instead. I think that my problem is on CheckLine method and I think this happens because somehow I don't pass correct parameters or maybe I have/or don't have to use ref keyword on some parameters. Can someone tell me what's wrong?

Here is my code:

static void Main()
{
    const int numberOfRows = 3;
    const int numberOfColumnns = 3;
    const int numbersExtracted = 15;
    int[,] bingoCard = ReadBingoCard(numberOfRows, numberOfColumnns);
    int[] numbers = ReadNumbersExtracted(numbersExtracted);
    PrintResult(bingoCard, numbers);
}

static int[,] ReadBingoCard(int rowsNumber, int columnNumber)
{
    int[,] card = new int[rowsNumber, columnNumber];

    for (int i = 0; i < rowsNumber; i++)
    {
        string[] array = Console.ReadLine().Split(' ');

        for (int j = 0; j < columnNumber; j++)
        {
            card[i, j] = Convert.ToInt32(array[j]);
        }
    }

    return card;
}

static int[] ReadNumbersExtracted(int numbersExtracted)
{
    int[] numbers = new int[numbersExtracted];

    for (int i = 0; i < numbersExtracted; i++)
    {
        numbers[i] = Convert.ToInt32(Console.ReadLine());
    }

    return numbers;
}

static void CheckLine(int[,] bingoCard, int nr, int nr2, int[] numbersExtracted, 
    ref int counter, int nr3, ref bool isTrue)
{
    const int rowEnd = 2;
    bool isLine = counter == nr3 && nr2 == rowEnd;

    for (int k = 0; k < numbersExtracted.Length; k++)
    {
        if (bingoCard[nr, nr2] == numbersExtracted[k])
        {
            counter++;

            if (isLine)
            {
                isTrue = true;
                break;
            }
        }
    }
}

static void CheckBingo(int[,] bingoCard, int nr, int nr2, int[] numbersExtracted, 
    ref int counter, int nr3, ref bool isTrue)
{
    for (int k = 0; k < numbersExtracted.Length; k++)
    {
        if (bingoCard[nr, nr2] == numbersExtracted[k])
        {
            counter++;

            if (counter == nr3)
            {
                isTrue = true;
            }
        }
    }
}

static bool CheckForLine(int[,] bingoCard, int[] numbersExtracted)
{
    const int length = 3;
    int count = 0;
    bool isLine = false;

    for (int i = 0; i < bingoCard.GetLength(0); i++)
    {
        for (int j = 0; j < bingoCard.GetLength(0); j++)
        {
            CheckLine(bingoCard, i, j, numbersExtracted, ref count, length, ref isLine);
        }
    }

    return isLine;
}

static bool CheckForBingo(int[,] bingoCard, int[] numbersExtracted)
{
    const int length = 9;
    int count = 0;
    bool isBingo = false;

    for (int i = 0; i < bingoCard.GetLength(0); i++)
    {
        for (int j = 0; j < bingoCard.GetLength(1); j++)
        {
            CheckBingo(bingoCard, i, j, numbersExtracted, ref count, length, ref isBingo);
        }
    }

    return isBingo;
}

static void PrintResult(int[,] bingoCard, int[] numbersExtracted)
{
    if (CheckForBingo(bingoCard, numbersExtracted))
    {
        Console.WriteLine("bingo");
    }
    else if (CheckForLine(bingoCard, numbersExtracted))
    {
        Console.WriteLine("linie");
    }
    else
    {
        Console.WriteLine("nimic");
    }
}

Answer 1

I think part of the problem here is that you're passing program state around to the methods using ref arguments. This can lead to problems because the state is now shared between methods and can easily get out of sync if we're not careful.

Instead we should define methods that take in some information, do some calculation, and return a result. It makes tracking down problems much easier this way.

For example, to determine if there is a "Bingo", we need to check if all items in the bingoCard array are also in the numbers array. This can be done fairly easily with a nested loop, where we:

1. Loop over each row in the bingoCard array
2. For each row we look at each column value.
3. Then we loop over the numbers array to see if there's a match for the value.
   • If there's a match, then we can increment a counter.
   • If, when we're done, the counter equals the number of items in the bingoCard array, then we return true
   • Otherwise return false

For example:

static bool CheckForBingo(int[,] bingoCard, int[] numbers)
{
    int numMatchesFound = 0;

    for (int row = 0; row < bingoCard.GetLength(0); row++)
    {
        for (int col = 0; col < bingoCard.GetLength(1); col++)
        {
            for (int numIndex = 0; numIndex < numbers.Length; numIndex++)
            {
                if (bingoCard[row, col] == numbers[numIndex])
                {
                    // Match found! Increment our counter and break from this loop
                    numMatchesFound++;
                    break;
                }
            }
        }
    }

    // If the number of matches equals the number of items in the card, return 'true'
    return numMatchesFound == bingoCard.Length;
}

Similarly, to check for a "line" we examine each row, and for each row we look at the column value. Then we loop through the numbers array to see if there's a match. If there is, then we increment a counter. If, at the end of the columns loop, our counter matches the total number of columns, then we have a "line" and return true . Otherwise, if we get to the end of the loops, then we return false :

static bool CheckForLine(int[,] bingoCard, int[] numbers)
{
    for (int row = 0; row < bingoCard.GetLength(0); row++)
    {
        // For a 'line', we only need to match all columns in a row, 
        // so create a counter to track that here
        int colMatchesInRow = 0;

        for (int col = 0; col < bingoCard.GetLength(1); col++)
        {
            for (int numIndex = 0; numIndex < numbers.Length; numIndex++)
            {
                if (bingoCard[row, col] == numbers[numIndex])
                {
                    // Match found! Increment our counter and break from this loop
                    colMatchesInRow++;
                    break;
                }
            }
        }

        // If our counter equals the number of columns, return 'true'
        if (colMatchesInRow == bingoCard.GetLength(1)) return true;
    }

    // If we get this far, we never found a 'line', so return 'false'
    return false;
}

Hopefully this helps.