. .

## Card Game - Dealing Cards, Searching for 3-of-a-kind

 ```/************************************************** 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) 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. ***************************************************/ public class CardGame { int[] deck = new int; int[] hand = new int; int last = 0; public CardGame() { 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 System.out.print(x + " : " ); // print successful hand printHand(hand); } } System.out.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 // then moves each card up one position // and subtracts 1 from LAST { int card = deck; 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; 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) { System.out.print(cardName(hand[c])+" "); } System.out.println("\n------------------------"); } boolean threeKind(int[] hand) // check for 3-of-a-kind in hand[] { int a = getRank(hand); int b = getRank(hand); int c = getRank(hand); int d = getRank(hand); int e = getRank(hand); 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; } } public static void main(String[] args) { new CardGame(); } } ```

### Simulation

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:

• represent data (measurements) reliably
• represent behaviors accurately

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.

### Cards

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:

• photographs
• names like "King of clubs"
• Abbreviations like "KC"
• Decimals like 10.3 for the Ten of Hearts
• Integers 1,2,3,...52

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:

• The rank is 2,3,4,...14 (ace)
• The suit is 1,2,3,4
• These are combined into a single integer as:  10*rank + suit

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.

### Behaviors

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.

### Programming Practice

• Download the program and run it.  It should produce a result like 20 hands out of 1000
that have 3-of-a-kind.
• We can get a better estimate of the probability of 3-of-a-kind by repeating this more often.
Try 10,000 trials or 100000.
• Write a method that checks for a pair - 2-of-a-kind.  How often does that happen?
• Which is more likely - dealing a hand with at least 1 pair, or dealing a hand where all the cards
have different ranks?
• Write a method to check whether all 5 cards in a hand have the same suit - that is called a flush.
How often does that occur?
• In BlackJack, you win automatically if you are dealt an Ace (rank 14) and any face card or a ten -
that is rank 10,11,12, or 13.  Write a method to decide whether a hand of 2 cards has 21.
• For hands of 2 cards, 3 cards, 4 cards, etc, answer the question of whether it is more likely
to have all the cards different or have at least a pair.  Which number of cards in a hand makes
it about 50% likely that all the cards are different?