c++ - 如何将用户输入与二维数组中的值进行比较？

Question

我写的这段代码应该要求用户输入 1 到 12 之间的数字，然后要求用户输入一个 1 到 4 之间的数字，乘以用户在 1 到 12 之间选择的数字。然后它应该输出一个 2D数组填充随机数，然后将用户输入与二维数组中的值进行比较，如果我这么说的话，类似于宾果游戏。这是我写的关于我的代码应该如何工作的示例:

Enter a number between 1 and 12: 3
Please enter 3 numbers.
1: Enter a number between 1 and 4: 2
2: Enter a number between 1 and 4: 3
3: Enter a number between 1 and 4: 3
Your numbers:
2 3 3

 1  1  3 
 3  4  2 
 1  4  1 

sorry, no match found

我完全卡住了最后一步，我想比较用户输入的数字，看看他们是否在行或列中匹配，有人知道我如何解决这个问题吗？先感谢您。

这是我到目前为止所做的工作:

#include <iostream>
#include <cstdio>
#include <cstdlib>


using namespace std;

int Atemp = 0;
int Utemp = 0;


void printGrid(int &Umain);

bool compareGrid(int ** BingoArray, int * NumbersArray, int size);


int main(){


    int Umain = 0;

//prompt user to enter a number between 1 and 12.
    while (Umain > 12 || Umain < 1){
        cout << "Please Enter a number between 1 and 12: ";
        cin >> Umain;
    }
    int ** BingoArray = new int*[Umain];
    for (int i=0;i<Umain;i++)
    {
        BingoArray[i] = new int[Umain];
    }


// prompt user to enter a number between 1 and 4 * the number they entered in Umain
    int * UserArray =  new int[Umain];
    for (int i=0;i<Umain;i++)
    {
        int selection = 0;
        while (selection <1 || selection > 4)
        {

            cout<<"Please enter a number between 1 and 4: ";
            cin >> selection;
            if (selection<1 || selection > 4)
            {
                cout<<"Invalid Number";
            }
            else
            {
                UserArray[i] = selection;
            }
        }
    }

    printGrid(Umain);


    compareGrid(BingoArray, UserArray, Atemp);



    return 0;
}


//2D array filled with random numbers and outputs size according to the user
void printGrid(int &Umain){

  cout<<endl;
    cout<<" ";
        int i=1,j;
        for(j = 0; j <= 4*Umain; j++){
            if(j%4==2){
                cout<<" ";
            }
        }

  cout<<endl;
    for(i = 0; i <= 2*Umain; i++){
        for(j = 0; j <= 2*Umain; j++){
            if(i%2==0){
                if(j==0){
                    cout<<" ";
                    }
                if(j%2==0){
                    cout<<" ";
            }else{
                    cout<<"---";
                }
            }else{
                if(j%2==0){
                    cout<<" | ";
                }else cout<< (rand()%4+1);
            }
        }
        if(i%2!=0){
                cout<<" ";
            }
        cout<<endl;
    }
    cout<<" ";

        for(j = 0, i = 1; j <= 4*Umain; j++){
            if(j%4==2){
                cout<< " ";
            }
        }
    cout<<endl;
    }


//Compare selection with rows and columns of 2D array
bool compareGrid(int ** BingoArray, int * NumbersArray, int size) {


  return false;
}

Answer 1

我现在玩那个愚蠢的游戏“几次”，但从未赢过。愚蠢的游戏。

#include <cassert>   // assert()
#include <cstddef>   // std::size_t  a type that is guaranteed to be big enough to
                     // hold all sizes of objects in memory and indexes into them
#include <limits>    // std::numeric_limits<>
#include <vector>    // std::vector<>
#include <iostream>  // std::cin, std::cout
#include <random>    // std::uniform_int_distribution<>, std::mt19937, 
#include <chrono>    // std::chrono::high_resolution_clock
#include <iterator>  // std::ostream_iterator<>

// of course you can keep using std::rand(), std::srand() and std::time() form 
// <cstdlib> and <ctime>, I just don't feel comfortable using these dinosaurs
// in new code any more.

// clears flags and empties an input stream
void clear(std::istream &is)
{
    is.clear();
    is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
}

// prints the grid data assuming it has columns columns
void print_grid(std::vector<int> const &data, std::size_t columns)
{
    for (std::size_t i{}; i < data.size(); ++i) {
        std::cout << data[i] << ' ';
        if ((i + 1) % columns == 0)  // insert a newline every columns numbers
            std::cout.put('\n');
    }
}

// generate random numbers for the grid, as I said, keep using std::rand() if you
// are more at ease with that.
void fill_grid(std::vector<int> &data, std::mt19937 &rng)
{
    std::uniform_int_distribution<int> dist{ 1, 4 };
    std::generate(std::begin(data), std::end(data), [&]() { return dist(rng); });
}

// compares rows and columns of data to tips
bool compare_grid(std::vector<int> const &data, std::size_t columns, std::vector<int> const &tips)
{
    assert(columns == tips.size());  // make sure the length of the columns is
                                     // the same as the size of tips
    // check the rows:
    for (std::size_t i{}; i < columns * columns; i += columns) {
        bool win = true;  // assume a match at first
        for (std::size_t k{ i }; win && k < i + columns; ++k)
            win = data[k] == tips[k - i];  // and compare inside the loop
        if (win)                           // the loop ends at the first mis-
            return true;                   // match.
    }

    // compare columns:
    for (std::size_t i{}; i < columns; ++i) {
        bool win = true;
        for (std::size_t k{ i }, t{}; win && k < i + columns * columns; k += columns, ++t)
            win = data[k] == tips[t];  // t ... i am too lazy to figure out how to calculate 
                                       // the index for tips with k, i and columns
        if (win)
            return true;
    }
    return false;
}

int main()
{
    std::size_t num_tips;
    while (std::cout << "Enter a number between 1 and 12: ",
           !(std::cin >> num_tips) || num_tips < 1 || 12 < num_tips)
    { // as long as extraction fails or the value is out of range:
        std::cerr << "Input error :(\n\n";
        clear(std::cin);
    }

    std::cout << "\nPlease enter " << num_tips << " numbers.\n";
    std::vector<int> tips(num_tips);
    for (std::size_t i{}; i < num_tips; ++i) {
        while (std::cout << i + 1 << ": Enter a number between 1 and 4: ",
               !(std::cin >> tips[i]) || tips[i] < 1 || 4 < tips[i])
        { // same as above: check if extraction is ok and a range check
            std::cerr << "Input error :(\n\n";
            clear(std::cin);
        }
    }

    std::cout << "Your numbers:\n";
    // displays all numbers in tips:
    std::copy(std::begin(tips), std::end(tips), std::ostream_iterator<int>{ std::cout, " "});
    std::cout << "\n\n";

    // instead of num_tips arrays of num_tips a vector of
    // num_tips * num_tips elements. calculate index with row * num_tips + column
    std::vector<int> bingo(num_tips * num_tips);

    // a random number generator to pass to fill_grid()
    // somewhat similar to the dinosaur std::srand():
    std::mt19937 rng{ static_cast<unsigned>(std::chrono::high_resolution_clock::now().time_since_epoch().count()) };

    // fills the grid with random number 1...4
    fill_grid(bingo, rng);

    // print the grid:
    print_grid(bingo, num_tips);

    // print outcome. if compare_grid() returns true: "You Win! :)\n" if not, the other:
    std::cout << (compare_grid(bingo, num_tips, tips) ? "You Win! :)\n" : "You Lose :(\n");
}

示例“游戏玩法”:

Enter a number between 1 and 12: 5

Please enter 5 numbers.
1: Enter a number between 1 and 4: 2
2: Enter a number between 1 and 4: 4
3: Enter a number between 1 and 4: 1
4: Enter a number between 1 and 4: 3
5: Enter a number between 1 and 4: 2
Your numbers:
2 4 1 3 2

4 1 3 3 1
4 2 2 4 2
3 3 4 4 4
4 1 2 1 1
2 2 3 3 2
You Lose :(

总结一下:默认结果是“你输了:(”。:(

如果您更喜欢“2d” vector :

// ...

    std::vector<std::vector<int>> bingo(num_tips);  // a vector of vectors with
    for (size_t i{}; i < num_tips; ++i)             // num_tips rows
        bingo[i].resize(num_tips);  // for every row resize the row-vector to num_tips
                                    // items

    fill_grid(bingo, rng);
    print_grid(bingo, num_tips);  // no need to pass columns because that information
                                  // is contained within bingo ... bingo.size()
    std::cout << (compare_grid(bingo, tips) ? "You Win! :)\n" : "You Lose :(\n");
}

与

void print_grid(std::vector<std::vector<int>> const &data, std::size_t columns)
{
    for (auto &row : data) {
        for (auto col : row)
            std::cout << col << ' ';
        std::cout.put('\n');
    }
}

void fill_grid(std::vector<std::vector<int>> &data, std::mt19937 &rng)
{
    std::uniform_int_distribution<int> dist{ 1, 4 };
    for(auto &row : data)  // generate random numbers for every row:
        std::generate(std::begin(row), std::end(row), [&]() { return dist(rng); });
}

bool compare_grid(std::vector<std::vector<int>> const &data, std::vector<int> const &tips)
{
    assert(data.size() == tips.size());

    for (std::size_t i{}; i < data.size(); ++i) {
        bool win = true;
        for (std::size_t k{}; win && k < data.size(); ++k)
            win = data[i][k] == tips[k];
        if (win)
            return true;
    }
    for (std::size_t i{}; i < data.size(); ++i) {
        bool win = true;
        for (std::size_t k{}; win && k < data.size(); ++k)
            win = data[k][i] == tips[k];  // just switch the indexes to compare
        if (win)                          // columns instead of rows.
            return true;
    }
    return false;
}

使用手动内存管理:(哎哟)

// ...

    std::cout << "\nPlease enter " << num_tips << " numbers.\n";

    int *tips = new int[num_tips];

    for (std::size_t i{}; i < num_tips; ++i) {
        while (std::cout << i + 1 << ": Enter a number between 1 and 4: ",
            !(std::cin >> tips[i]) || tips[i] < 1 || 4 < tips[i])
        {
            std::cerr << "Input error :(\n\n";
            clear(std::cin);
        }
    }

    std::cout << "Your numbers:\n";
    for (std::size_t i{}; i < num_tips; ++i)
        std::cout << tips[i] << ' ';
    std::cout << "\n\n";

    int **bingo = new int*[num_tips];
    for (size_t i{}; i < num_tips; ++i) {
        bingo[i] = new int[num_tips];
    }

    fill_grid(bingo, num_tips, rng);
    print_grid(bingo, num_tips);
    std::cout << (compare_grid(bingo, tips, num_tips) ? "You Win! :)\n" : "You Lose :(\n");

    // cleanup:
    delete[] tips;

    for (size_t i{}; i < num_tips; ++i)
        delete[] bingo[i];
    delete[] bingo;
}

与

void print_grid(int **data, std::size_t columns)
{
    for (std::size_t row{}; row < columns; ++row) {
        for (std::size_t col{}; col < columns; ++col)
            std::cout << data[row][col] << ' ';
        std::cout.put('\n');
    }
}

void fill_grid(int **data, std::size_t columns, std::mt19937 &rng)
{
    std::uniform_int_distribution<int> dist{ 1, 4 };
    for (std::size_t row{}; row < columns; ++row)
        std::generate(&data[row][0], &data[row][columns], [&]() { return dist(rng); });
}

bool compare_grid(int **data, int *tips, std::size_t num_tips)
{
    for (std::size_t i{}; i < num_tips; ++i) {
        bool win = true;
        for (std::size_t k{}; win && k < num_tips; ++k)
            win = data[i][k] == tips[k];
        if (win)
            return true;
    }
    for (std::size_t i{}; i < num_tips; ++i) {
        bool win = true;
        for (std::size_t k{}; win && k < num_tips; ++k)
            win = data[k][i] == tips[k];
        if (win)
            return true;
    }
    return false;
}