random shuffling

[glowfire]

Please, somebody help me with this program!

We have a deck of 52 cards and we shuffle the deck by choosing a
random card out of the deck placing it back in the deck at some random
place. Repeat it 500 times and then consider the deck shuffled. Choose
a hand of 5 cards from the top of the deck. Count the number of hands
which have three-of-a-kind but don't count hands which have
four-of-a-kind. Continue to draw new hands until the deck either needs
reshuffling or until 100 hands have been drawn. Output on one screen
the 100 handswith those having exactly three-of-a-kind. Output also
the total amount of three-of-a-kind hands.

Please I'm really confused. I know that I have to use functions and
the 52 cards are actually an array of 52 elements. But I don't know
how to do the shuffling drawind, the output of the 100 hands and
finally counting the hands wyh exactlu 3-of-a-kind. I can't figure out
a method for testing a hand for exactly 3-of-a-kind. Please help.
Thank you!

[osmium]

"glowfire" writes:

We have a deck of 52 cards and we shuffle the deck by choosing a
random card out of the deck placing it back in the deck at some random
place. Repeat it 500 times and then consider the deck shuffled. Choose
a hand of 5 cards from the top of the deck. Count the number of hands
which have three-of-a-kind but don't count hands which have
four-of-a-kind. Continue to draw new hands until the deck either needs
reshuffling or until 100 hands have been drawn. Output on one screen
the 100 handswith those having exactly three-of-a-kind. Output also
the total amount of three-of-a-kind hands.

Please I'm really confused. I know that I have to use functions and
the 52 cards are actually an array of 52 elements. But I don't know
how to do the shuffling drawind, the output of the 100 hands and
finally counting the hands wyh exactlu 3-of-a-kind. I can't figure out
a method for testing a hand for exactly 3-of-a-kind. Please help.

The first thing you must do is create a deck of 52 cards. The requirement
for three-of-a-kind madates that the card needs to have both a value and
suit. I suggest this structure for a single card.

struct Card
{
int nbr; // 0..51
int suit; // 0..3
int pip; // 0..12
};

Given nbr you can compute suit and pip using the modulo operator.

Try creating the code to create a card deck and post the code. If you do,
someone will probably help you to the next step. You will probably want to
focus on the for statement and the modulo operator.

Later on, you will need to be able to generate random numbers in the range
0..51. There is a lot of guidance on the Web for generating random numbers
and also for shuffling.

[PowerCat]

Check out this nifty program. It does exactly what you are trying to do!!
I'm trying to work with it myself to make a card game.
http://home.comcast.net/~anglewyrm/hat.html

[Ioannis Vranos]

glowfire wrote:

Please, somebody help me with this program!

We have a deck of 52 cards and we shuffle the deck by choosing a
random card out of the deck placing it back in the deck at some random
place. Repeat it 500 times and then consider the deck shuffled. Choose
a hand of 5 cards from the top of the deck. Count the number of hands
which have three-of-a-kind but don't count hands which have
four-of-a-kind. Continue to draw new hands until the deck either needs
reshuffling or until 100 hands have been drawn. Output on one screen
the 100 handswith those having exactly three-of-a-kind. Output also
the total amount of three-of-a-kind hands.

Please I'm really confused. I know that I have to use functions and
the 52 cards are actually an array of 52 elements. But I don't know
how to do the shuffling drawind, the output of the 100 hands and
finally counting the hands wyh exactlu 3-of-a-kind. I can't figure out
a method for testing a hand for exactly 3-of-a-kind. Please help.
Thank you!

I consider the following pseudocode more efficient and with better
shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)
cards[i]= cards[ Random(0,51) ];
Since it is a homework you can figure out how to do the Random(0, 51) by
using rand(), RAND_MAX and at first with a call to srand((time(0)).
Unless the homework requires the silly shuffling that was mentioned.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Clark S. Cox III]

On 2005-02-19 21:53:49 -0500, Ioannis Vranos <iv*@remove.this.grad.com> said:

glowfire wrote:

Please, somebody help me with this program!

We have a deck of 52 cards and we shuffle the deck by choosing a
random card out of the deck placing it back in the deck at some random
place. Repeat it 500 times and then consider the deck shuffled. Choose
a hand of 5 cards from the top of the deck. Count the number of hands
which have three-of-a-kind but don't count hands which have
four-of-a-kind. Continue to draw new hands until the deck either needs
reshuffling or until 100 hands have been drawn. Output on one screen
the 100 handswith those having exactly three-of-a-kind. Output also
the total amount of three-of-a-kind hands.

Please I'm really confused. I know that I have to use functions and
the 52 cards are actually an array of 52 elements. But I don't know
how to do the shuffling drawind, the output of the 100 hands and
finally counting the hands wyh exactlu 3-of-a-kind. I can't figure out
a method for testing a hand for exactly 3-of-a-kind. Please help.
Thank you!

I consider the following pseudocode more efficient and with better shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)
cards[i]= cards[ Random(0,51) ];

Very bad idea, you can get copies of the same card in multiple places
in the array, and lose other cards. I'd recommend using
std::random_shuffle() instead.

--
Clark S. Cox, III
cl*******@gmail.com

[Ioannis Vranos]

Ioannis Vranos wrote:
More clearly what I meant:

I consider the following pseudocode more efficient and with better
shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)\

{
random_index= Random(0,51);

temp= cards[i];

cards[i]= cards[ random_index ];

cards[ random_index ]= temp;
}


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Clark S. Cox III wrote:

Very bad idea, you can get copies of the same card in multiple places in
the array, and lose other cards. I'd recommend using
std::random_shuffle() instead.

I posted as a reply to my message what I meant in more detail.
BTW your message looks strange in my newsreader with Japanese encoding.

Unless you are also posting to Japanese groups, a good idea would be to
switch to Western(ISO) as the default.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[osmium]

"Ioannis Vranos" wrote:

Ioannis Vranos wrote:
More clearly what I meant:

I consider the following pseudocode more efficient and with better
shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)\

{
random_index= Random(0,51);

temp= cards[i];

cards[i]= cards[ random_index ];

cards[ random_index ]= temp;
}

No matter what you meant, it is still a very bad idea. Very few instructors
like being told that their way is stupid, and that is what both of the two
solutions in this thread imply. He especially will not like it coming from
a struggling student, and the OP is clearly struggling. He should do what he
has been told to do!!! By the *instructor*.

Clearly, the instructor has some intuitive notions of randomness that are
flawed. So be it, even so his way will still work pretty well and *he* is
the one who is going to give a grade.

If he had wanted a canned routine such as shuffle he would have permitted
it. He clearly excluded it. Some people actually learn something from
writing code that has already been written. I think the instructor had this
in mind.

To the OP: BTW, if you post again tell us whether you are supposed to use
classes or not. The assignment can be completed either way and we have no
way of knowing what the instructor expects. If you have a choice I think
without classes is easier. It is certainly less typing. Note that easier
does not mean better.

[Gary Labowitz]

"osmium" <r1********@comcast.net> wrote in message
news:37*************@individual.net...

"Ioannis Vranos" wrote:

Ioannis Vranos wrote:
More clearly what I meant:

I consider the following pseudocode more efficient and with better
shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)\ {
random_index= Random(0,51);

temp= cards[i];

cards[i]= cards[ random_index ];

cards[ random_index ]= temp;
}

No matter what you meant, it is still a very bad idea. Very few

instructors like being told that their way is stupid, and that is what both of the two
solutions in this thread imply. He especially will not like it coming

from
<<snip>>

If I recall, this is exactly what the sort algorithm implements. I know for
a fact it is the one in Java (except it only does i from 0 to 51). I'll take
a peek at the g++ sort and see.
--
Gary

[Gary Labowitz]

"Gary Labowitz" <gl*******@comcast.net> wrote in message
news:nJ********************@comcast.com...

"osmium" <r1********@comcast.net> wrote in message

The description from dinkumware for random_shuffle is
The first template function evaluates swap(*(first + N), *(first + M)) once
for each N in the range [1, last - first), where M is a value from some
uniform random distribution over the range [0, N]. Thus, the function
randomly shuffles the order of elements in the sequence.

This would appear to be the same as the Java implementation. In the STL the
sort is implemented with iterators, of course. In stl_algo.h (g++ 3.4.2) we
find

if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));

Which is the same algorithm. Looks like everyone is doing it.

I have my students program it exactly that way in Java class.
--
Gary

[Ioannis Vranos]

Gary Labowitz wrote:

The description from dinkumware for random_shuffle is
The first template function evaluates swap(*(first + N), *(first + M)) once
for each N in the range [1, last - first), where M is a value from some
uniform random distribution over the range [0, N]. Thus, the function
randomly shuffles the order of elements in the sequence.

This would appear to be the same as the Java implementation. In the STL the
sort is implemented with iterators, of course. In stl_algo.h (g++ 3.4.2) we
find

if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));

Which is the same algorithm. Looks like everyone is doing it.

I have my students program it exactly that way in Java class.

random_shuffle can be used in such shuffle cases.

BTW osmium is right, the OP should stick with his assignment requirements.
The one you are providing above, is an implementation of random_shuffle?


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Gary Labowitz]

"Ioannis Vranos" <iv*@remove.this.grad.com> wrote in message
news:1108954230.35731@athnrd02...

Gary Labowitz wrote: <<snip>> The one you are providing above, is an implementation of random_shuffle?

Yes, this is out of random_shuffle on g++ library.
--
Gary

[Ioannis Vranos]

Gary Labowitz wrote:

Yes, this is out of random_shuffle on g++ library.

OK, in any case an implementer may choose whatever implementation he wants.


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Gary Labowitz wrote:

This would appear to be the same as the Java implementation. In the STL the
sort is implemented with iterators, of course. In stl_algo.h (g++ 3.4.2) we
find

if (__first != __last)
for (_RandomAccessIterator __i = __first + 1; __i != __last; ++__i)
std::iter_swap(__i, __first + (std::rand() % ((__i - __first) + 1)));

Which is the same algorithm. Looks like everyone is doing it.

I have my students program it exactly that way in Java class.

Actually I think it is not exactly the same algorithm with what I
provided, I begin from the [0] element while the above from the [1].


--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Risto Lankinen]

"Ioannis Vranos" <iv*@remove.this.grad.com> wrote in message
news:1108868048.258131@athnrd02...

glowfire wrote:

I consider the following pseudocode more efficient and with better
shuffling.
// One pass shuffling
for(unsigned i=0; i<52; ++i)
cards[i]= cards[ Random(0,51) ];

After each assignment you have two copies of the same "card" in
two array positions [except occasionally when Random(0,51)==i].
That is not what I understand the word "shuffling" usually means.

- Risto -

[Martijn Mulder]

unshuffled, alas
#include <iostream>
#include <string>

int main()
{
string suits = "\x5\x4\x3\x6";
string cards = "23456789TJQKA";
for(int a=0;a<suits.size();a++)
{
for(int b=0;b<cards.size();b++)
{
cout<<cards[b];
cout<<suits[a];
cout<<' ';
}
cout<<endl;
}
return 0;
}

[Martijn Mulder]

//shuffled, dealt and sorted per hand

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

int main()
{
vector<string>deck;
vector<string>north;
vector<string>east;
vector<string>south;
vector<string>west;
string suits="\x5\x4\x3\x6";
string cards="23456789TJQKA";
for(int a=0;a<cards.size();a++)
for(int b=0;b<suits.size();b++)
{
string c;
c+=suits[b];
c+=cards[a];
deck.push_back(c);
}
random_shuffle(deck.begin(),deck.end());
while(deck.size()>0)
{
north.push_back(deck.back());deck.pop_back();
east.push_back(deck.back());deck.pop_back();
south.push_back(deck.back());deck.pop_back();
west.push_back(deck.back());deck.pop_back();
}
sort(north.begin(),north.end());
sort(east.begin(),east.end());
sort(south.begin(),south.end());
sort(west.begin(),west.end());
copy(north.begin(),north.end(),ostream_iterator<st ring>(cout," "));
cout<<endl;
copy(east.begin(),east.end(),ostream_iterator<stri ng>(cout," "));
cout<<endl;
copy(south.begin(),south.end(),ostream_iterator<st ring>(cout," "));
cout<<endl;
copy(west.begin(),west.end(),ostream_iterator<stri ng>(cout," "));
cout<<endl;
return 0;
}