Я написал этот код, который должен запрашивать у пользователя число от 1 до 12, а затем просить пользователя ввести число от 1 до 4-кратного числа, которое пользователь выбрал от 1 до 12. Затем он должен вывести 2D-массив, заполненный случайные числа, а затем сравните вводимые пользователем значения со значениями в 2D-массиве, как в Bingo, если я так скажу. Вот пример того, как должен работать мой код:

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;
}
0
Jake Blazer 29 Ноя 2018 в 22:27

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":

// ...

    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;
}
1
Swordfish 29 Ноя 2018 в 21:57