/**************************************************
A card game can be SIMULATED by a computer program.
We must decide how to REPRESENT a single card,
as well as how to STORE a whole deck of cards.
This program stores each card as an int number, like this:
card = rank * 10 + suit , e.g. 114 = Jack of Spades, 31 = 3 of Clubs
where rank is between 2 and 14, and suit is 1,2,3 or 4.
The deck is an ARRAY of ints. The shuffle method mixes up
the cards. The takeCard method returns the first card (deck[0])
and then moves each card up one position.
The program shuffles a new deck and then "deals" a hand of 5 cards.
It checks whether the hand contains "3 of a kind" - that is,
3 cards with the same rank. It repeats 1000 times and counts
the number of times that 3 of a kind occurs. The result of about
20-254 occurences in 1000 hands gives an idea of the probability
of dealing a hand with 3 of a kind.
***************************************************/
int[] deck = new int[52];
int[] hand = new int[5];
int last = 0;
void setup()
{
int count=0;
for(int x=0; x < 1000; x=x+1) // dealing 1000 hands
{
makeCards(); // create 52 cards
shuffle(); // shuffle the deck
hand = take5(); // deal a 5-card hand
if(threeKind(hand)==true) // check for 3-of-a-kind
{
count++; // count successful hands
print(x + " : " ); // print successful hand
printHand(hand);
}
}
println(count);
}
void makeCards() // make all 52 cards
{
int pos = 0;
for(int suit = 1; suit <= 4; suit = suit + 1) // all 4 suits
{
for(int rank = 2; rank <= 14; rank = rank + 1) // all ranks
{
deck[pos] = 10*rank + suit;
pos++;
}
}
last = 51;
}
void shuffle()
// shuffle the deck by selecting 2 positions at random
// and then switching these 2 card codes, repeat 1000 times
{
for(int x = 0; x < 1000; x++)
{
int a = (int)(Math.random()*last);
int b = (int)(Math.random()*last);
int temp = deck[a];
deck[a] = deck[b];
deck[b] = temp;
}
}
String cardName(int c) // produce a 2-character code for a card
{
String[] suits = { "?", "c", "d", "h", "s" };
String[] ranks = { "*", "*", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A"};
int suit = getSuit(c);
int rank = getRank(c);
return ranks[rank] + suits[suit];
}
int getRank(int c) // extract rand from int c
{
return c / 10;
}
int getSuit(int c) // extract the suit from int c
{
return c % 10;
}
int takeCard()
// returns the card from deck[0]
// then moves each card up one position
// and subtracts 1 from LAST
{
int card = deck[0];
for(int c = 0; c < last; c = c+1)
{
deck[c] = deck[c+1];
}
deck[last] = 0;
last = last - 1;
return card;
}
int[] take5() // take the first 5 cards from deck
{
int[] result = new int[5];
for(int x = 0; x < 5; x = x+1)
{
result[x] = takeCard();
}
return result;
}
void printHand(int[] hand) // print the 5 cards from hand[]
{
for(int c = 0; c < 5; c=c+1)
{
print(cardName(hand[c])+" ");
}
println("\n------------------------");
}
boolean threeKind(int[] hand) // check for 3-of-a-kind in hand[]
{
int a = getRank(hand[0]);
int b = getRank(hand[1]);
int c = getRank(hand[2]);
int d = getRank(hand[3]);
int e = getRank(hand[4]);
if( a==b && a==c
|| a==b && a==d
|| a==b && a==e
|| a==c && a==d
|| a==c && a==e
|| a==d && a==e
|| b==c && b==d
|| b==c && b==e
|| b==d && b==e
|| c==d && c==e
)
{ return true; }
else
{ return false; }
}
|
A simulation is a program (or computer system) that attempts to behave
realistically. The purpose of a simulation
is to create a system where we can do experiments and check the
results. This is hopefully faster or easier or safer
that do the experiments in reality. You have probably used
simulations - a video game is usually a simulation
of some realistic environment. The biggest difference between games
and simulations is that simulations have
a serious, scientific purpose, whereas the main purpose of a game is to
have fun. Simulations must be as
realistic as possible.
Simulations must do two major things:
Most data is represented as a measurement, so representing data is
accurately is usually simple enough.
Representing behaviors is
generally a lot more difficult. Behaviors might involve natural
laws.
Even worse, behaviors might represent human preferences and decisions, and
these are very difficult to simulate.
This program does a relatively simple simulation - it simulates a card
game with a standard deck of 52 cards.
The first question is how to represent the data. In this case, how
should we represent the cards?
Here are some possibilities:
The integer solution is attractive because it is simple, but it makes it
difficult to determine the suit or the rank.
For example, when looking for a pair, which numbers match with which?
The author decided to do it this way:
So the Ace of Spades is 144 = 14*10 + 4.
Having cards stored as simple int values makes it easy to manipulate
them, for things like shuffling and dealing.
We can still display text by converting the number to the corresponding
text - done by the cardName
method.
The behaviors for cards are things like moving around in the array when
we shuffle, or moving from
the deck into a hand when we deal.
Shuffling is done by choosing two random cards and then exchanging their
positions. This is not the
way that "real" shuffling actually works. But we hope it is
equivalent and arranges the cards in a random order.
The program creates a new deck, shuffles it, and then deals the top 5
cards into a "hand". It checks whether there
are 3-of-a-kind, that is 3 cards with the same rank. Then it does
this all again with a new deck, shuffling and taking
the top 5 cards. It repeats this 1000 times and counts how often it
gets 3-of-a-kind. This behavior is not realistic -
no real human being would do this. But it is hopefully
equivalent to what happens in reality, producing a realistic
estimate of the probability of dealing a hand with 3-of-a-kind.