Thread: "Deal or No Deal" Game

Okay. This is my first project I am doing. I'm creating a simple console app that is not unlike the "Deal or No Deal" television show.

I have two sets of 26 different numbers that I would like to show.

One of them containing the case numbers.

The other containing what is inside the case.

$0.01
$1
$5
$10
$25
$50
$75
$100
$200
$300
$400
$500
$750

(split)


$1,000
$5,000
$10,000
$25,000
$50,000
$75,000
$100,000
$200,000
$300,000
$400,000
$500,000
$750,000
$1,000,000

The plan is to randomly assign one of the 26 cases to one of the 26 values. I am not exactly sure how to do this, and I was wondering if anyone would like to help.

I didn't really understand pointers, but is this where I would use them?

Cheers!

Thanks for the hint. I'll think about it.

Originally Posted by SlyMaelstrom

You can search the FAQs here if you need help using the rand function. Your most difficult task would be figuring out the algorithm you'll be using to decide how much money the bank offers after each round.

Yeah, I'm taking it in steps. I read something about array shuffling.

Here is what I got (well just a part of it)...

Code:

 
 
//--- Shuffle elements by randomly exchanging each with one other.
        for (int i=0; i<26; i++) {
            int r = rand() % 26;  // generate a random position
            int temp = case[i]; case[i] = case[r]; case[r] = temp;

...and then manually, or find a way to automatically, assign each of those case numbers to one of the values. After that, use an algorithm to re-sort the cases.

Scratch that. I'm confusing myself.

Okay, I'm not as confused anymore.

The best way to randomly assign the values to the boxes is to put the values into a container in order, then randomly shuffle the data in the container.

So put each value into a vector (or array). Then call random_shuffle to shuffle the data.

If you can't or don't want to use the random_shuffle function, then you can simulate it yourself. Basically, you start from the end, then randomly pick an index in the vector/array and swap the value at that index with the value at the end. Then you decrement your counter by one and do it again with the smaller range. You keep doing this until you get to the front of the container and it will be completely shuffled. Be careful, it is easy to get the algorithm wrong and not get good randomness, which is why letting random_shuffle do it for you is better. If you do it yourself, feel free to post your attempt so we can help you verify that it is correct.

>> There's really no reason this algorithm should use the back of the array for swapping instead of the front.
That suggestion is for convenience as it makes the code easier to follow IMO.

for reference, this is the shuffle algorithm I used in my poker game(changed to use integers):

Code:

#include <ctime>
#include <cstdlib>

void shuffle()
{
	int tempNum;

	srand( time(NULL) ); // Seeds the random number generator with the current Time
	for(int j = 0; j < size; j++) // loop through the array once
	{
		int k = rand() % size; //Produces a random integer number between 0 and size
		tempNum = yourArray[k];		// Pick an int at random
		yourArray[k] = yourArray[j]; // swaps the random int and the current int in the loop
		yourArray[j] = tempNum;
	}
	return;
}//! End of shufle Definition

Unfortunately, that gives an uneven distribution. Try running it a thousand times times with a size of 5 and see how often each value gets assigned to each spot. They should be roughly even for a good shuffling algorithm.

BTW, I wrote a simple test program to show the uneven distribution compared to random_shuffle which works pretty well:

Code:

#include <iostream>
#include <algorithm>
#include <ctime>
#include <cstdlib>

void shuffle(int data[], int size)
{
    int tempNum;

    for(int j = 0; j < size; j++) // loop through the array once
    {
        int k = std::rand() % size; //Produces a random integer number between 0 and size
        tempNum = data[k];        // Pick an int at random
        data[k] = data[j]; // swaps the random int and the current int in the loop
        data[j] = tempNum;
    }
    return;
}//! End of shufle Definition

void run_test(bool use_random_shuffle)
{
    const int size = 5;
    const int iterations = 100000;
    int tallies[size][size] = { };

    if (use_random_shuffle)
        std::cout << "Using random_shuffle:\n";
    else
        std::cout << "Using shuffle:\n";

    for (int i = 0; i < iterations; ++i)
    {
        int data[size];
        for (int j = 0; j < size; ++j)
            data[j] = j;

        if (use_random_shuffle)
            std::random_shuffle(data, data + size);
        else
            shuffle(data, size);

        for (int j = 0; j < size; ++j)
            ++tallies[j][data[j]];
    }

    for (int i = 0; i < size; ++i)
    {
        std::cout << i << ": ";
        for (int j = 0; j < size; ++j)
        {
            std::cout << tallies[i][j] << ' ';
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}

int main()
{
    std::srand( static_cast<unsigned>(std::time(0)) );

    run_test(true);
    run_test(false);
    run_test(false);
    run_test(true);
}

One example of my output:

Code:

Using random_shuffle:
0: 19941 19970 20079 19976 20034
1: 19985 19953 20130 19981 19951
2: 19828 20213 19943 20145 19871
3: 20207 20018 19859 19977 19939
4: 20039 19846 19989 19921 20205

Using shuffle:
0: 19991 24204 20765 18440 16600
1: 20029 18017 23039 20659 18256
2: 19983 18552 17648 22809 21008
3: 20020 19190 18504 17836 24450
4: 19977 20037 20044 20256 19686

Using shuffle:
0: 19723 24367 21115 18393 16402
1: 19965 17808 23249 20619 18359
2: 20258 18419 17323 22965 21035
3: 19944 19290 18527 17978 24261
4: 20110 20116 19786 20045 19943

Using random_shuffle:
0: 19943 20161 19959 19982 19955
1: 19924 20078 20048 19866 20084
2: 20176 19971 19980 19875 19998
3: 19836 19823 20148 20081 20112
4: 20121 19967 19865 20196 19851

Notice that 4 (the last column) only comes in the 0 slot about 16.5% of the time, but it comes up in the 3 slot over 24% of the time with System_159's version (which is a very common mistake when trying to implement this algorithm). With random_shuffle they all will average about 20%.