How to compare user input with the values in the 2D array? - c++

Question

I wrote this code that should ask the user for a number between 1 and 12 and then ask the user to enter a number between 1 and 4 x times the number the user chose between 1 and 12. It then should output a 2D array filled with random numbers and then compare the users input with the values in the 2D array, similar to Bingo if I do say so. Here is a sample I wrote of how my code should work:
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
I got one last step that I am just completely stuck at, I want to compare the numbers the user entered to see if they got a match in row or columns, does anybody have any clue how might I work that out? thank you in advance.
Here is what I worked on up till now:
#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

I played that stupid game a "few" times now and never won. Stupid game.
#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");
}
Sample "Gameplay":
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 :(
To sum it up: Default outcome is "You Lose :(". :(
If you'd rather have a "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");
}
with
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;
}
Using manual memory management: (ouch)
// ...
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;
}
with
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;
}