在宾果游戏中跟踪选定的数字

Question

I have to create a class that keeps tracks of numbers that were already selected in the process of generating a board and selecting numbers during the game.

The 3 classes I need:

1) A "reset" class that initalizses the class once the card is filled with numbers, so that the array can be used again to keep track of the numbers selected during the game

2) A "isNumberUsed" class that is given the random integer and checks whether the random number is in the numbersList array or not

3) A "setUsedNumber" class that adds the unique random number generated to the numbersList array.

I have been working on this and would love any feedback. Thank you!

public class SelectedNumbersListType
{
    private int[] numbersList;
    private int position;

    public SelectedNumbersListType()
    {
        numbersList = new int[76];
        position = 0;


    }
    public void reset()
    {
        // position = numbersList[0];
        // position++;
        for (position = 0; position < numbersList.Length; position++)
        {
            numbersList[position] = 0;

            if (position == numbersList.Length)
            {
                position = numbersList[0];
            }
        }
       // reset();
        }
    public bool isNumberUsed(int rn)
    {
        position = numbersList[0];
        position++;
        if (numbersList[position] == rn)
        {

            return true;
        }
        return false;
    }

    public bool setUsedNumber(int rn)
    {

        if (numbersList.Contains(rn))
        {
            Array.Resize(ref numbersList, numbersList.Length+1);
            numbersList[numbersList.Length + 1] = rn;

        }
        return false;
    }

}   

}

Answer 1

I think it makes sense to step back here and start from the beginning. As @ThomasWeller points out, object-oriented analysis starts with identifying the nouns in your problem space, and then the verbs that act upon those nouns.

When I look at your bingo problem, I only see one noun, the BingoGame . So, I'm going to have a class BingoGame . From the caller's point of view, there are two main actions (verbs) that act upon that noun: DrawNumber and RestartGame . In addition, I think it's useful to be able to get the list of numbers drawn in the game, both in draw order and in sorted order. As a result, I see two more verbs GetDrawnNumbers and GetDrawnNumbersSorted .

In C-family languages, it always makes more sense to start counting at 0 rather than at 1. So, I'm going to work with numbers in the range 0-74, not 1-75. Whenever I display a number, I'll prepend it with the appropriate letter (one of B, I, N, G, or O) and add one. So, I created a private function to do this: GetBingoNumberFromNumber .

In order to draw a number, I need a source of random-ness. The framework provides one (System.Random) - it's not the best random number generator (don't use it to start a casino), but it's good enough here.

I also need a way to retain what numbers have been drawn (both for display, and to reject any duplicate numbers in a game). I'll keep track of these in a List<int> . Finally, I need to know what the letters are in "BINGO", so I'll keept an array of those letters (I could have treated the string "BINGO" as an array of characters, but I thought an array of characters was more obvious. As a result, my class starts with:

 public class BingoGame
 {
     private readonly List<int> _drawnNumbers = new List<int>();
     private readonly Random _random = new Random();
     //the indexes for this array are (naturally) 0 through 4
     private static readonly char[] BingoChars = {'B', 'I', 'N', 'G', 'O'};
 }

Now I need to add functionality. Starting the game simply means taking previously drawn numbers and putting them back in the drum. In our case, it means clearing the list of previously drawn numbers:

 public void StartGame()
 {
     _drawnNumbers.Clear();
 }

To draw a number, we'll rely on Random.Next , pulling numbers between 0 and 74. However, we need to take care of the case where a duplicate number is pulled during single game. If that happens, we'll throw away the newly drawn number and get another one. We'll look in the list of previously drawn numbers to decide if a number has been previously drawn:

 public string DrawNumber()
 {
     int nextNum;
     do
     {
         nextNum = _random.Next(0, 75); //this will return a number between 0 & 74

     } while (_drawnNumbers.Contains(nextNum));
     _drawnNumbers.Add(nextNum);
     return GetBingoNumberFromNumber(nextNum);
 }

Here's the first time we've had to translate one of our 0-74 numbers to something that makes sense in Bingo. Let's do that function:

 private string GetBingoNumberFromNumber(int num)
 {
     //this will result in a number in the 0-4 range
     var bingoIndex = num / 15;
     return $"{BingoChars[bingoIndex]}-{num + 1}";
 }

It's important to understand integer division when reading that function. Dividing any integer between 0 and 14 by the integer 15 will yield zero. Similarly, any number between 15 and 29 when divided by 15 will yield 1. And so on.

Finally, we need to get the "numbers" for the current game. We'll just return the list of drawn numbers, transformed using GetBingoNumberFromNumber . The easiest way to transform a collection is to use LINQ, so:

 public IEnumerable<string> GetDrawnNumbers()
 {
     return from num in _drawnNumbers
         select GetBingoNumberFromNumber(num);
 }

And, LINQ is good at sorting, so we'll just return the sorted list in nearly the same way:

 public IEnumerable<string> GetDrawnNumbersSorted()
 {
     return from num in _drawnNumbers
         orderby num
         select GetBingoNumberFromNumber(num);
 }

To test this, I threw together a simple WinForms app with two buttons ( StartGameBtn and DrawNumberBtn ) and two skinny listboxes ( NumbersList and SortedList ). After wiring up the Click handlers, it looked like:

public partial class Form1 : Form
{
    private readonly BingoGame _game = new BingoGame();
    public Form1()
    {
        InitializeComponent();
        _game.StartGame();
    }

    private void StartGameBtn_Click(object sender, EventArgs e)
    {
        _game.StartGame();
        NumbersList.Items.Clear();
        SortedList.Items.Clear();
    }

    private void DrawNumberBtn_Click(object sender, EventArgs e)
    {
        _game.DrawNumber();
        SetListboxItems(NumbersList, _game.GetDrawnNumbers());
        SetListboxItems(SortedList, _game.GetDrawnNumbersSorted());
    }

    private void SetListboxItems(ListBox listbox, IEnumerable<string> numbers)
    {
        listbox.Items.Clear();
        foreach (var item in numbers)
        {
            listbox.Items.Add(item);
        }
    }
}