Implementing a deck of cards

A deck of playing cards
- What a deck of playing cards looks like for real:

Representing a deck of cards

To represent a deck of cards, we need 52 Card objects

A possible representation:

   public class DeckOfCards
   {
      private Card c1;                
      private Card c2;
      ...
      private Card c52;
      // 52 Card variables !!!
   }

A much better representation is to use an array of Card objects:
public class DeckOfCards { private Card[] deckOfCards; // Used to store all 52 cards }
We can use a constructor method to initialize the deck of card to contain the right cards.

Constructor method(s) for a deck of cards

We will have a constructor method to create a deck of cards containing:

The constructor method:

   public class DeckOfCards
   {
      public static final int NCARDS = 52;
    
      private Card[] deckOfCards;         // Contains all 52 cards
    
      /* ---------------------------------------------------
         The constructor method: make 52 cards in a deck
	 --------------------------------------------------- */
      public DeckOfCards( )
      {
         /* =================================================================   
            First: create the array                                             
            ================================================================= */
   	 deckOfCards = new Card[ NCARDS ];   // Very important !!!              
                                             // We must crate the array first ! 

         /* =================================================================
            Next: initialize all 52 card objects in the newly created array
            ================================================================= */
   	 int i = 0;
    
   	 for ( int suit = Card.DIAMOND; suit <= Card.SPADE; suit++ )           
   	    for ( int rank = 1; rank <= 13; rank++ )
   		deckOfCards[i++] = new Card(suit, rank);  // Put card in
                                                          // position i
      }
   }

Explanation:

The variable suit will go through the values Card.DIAMOND (= 1) upto and including Card.SPADE (= 4)
The variable rank will go through the values 1 upto and including 13
So we will create 4×13 = 52 cards
The variable i is incremented by 1 so each new card will be stored in a different array element deckOfCards[i].

Converting a "deck of card" to String: toString()

We will make a toString() method that return a String of the cards stored inside the array deckOfCards[].
We will return 13 cards on 1 line

(We use the newline character \n to separate the lines)

The toString() method:

   public String toString()
   {
      String s = "";
      int k;

      k = 0;
      for ( int i = 0; i < 4; i++ )
      {
         for ( int j = 1; j <= 13; j++ )
             s += ( deckOfCards[k++] + " " );                

         s += "\n";   // Add NEWLINE after 13 cards
      }
      return ( s );
   }

Operations on a deck of cards
- What can you do with a deck of playing cards:
  
  Shuffle up and... Deal !!!

Simulating "dealing cards" from a deck of cards

Fact:
A computer program cannot deal cards --- at least not physically
Simulation:
In a computer simulation, we only aim to achieve the same result
What is the result of dealing some cards:

Result = information about what cards has been dealt

We can represent this hand (= a collection of cards) in a computer program with the following 5 simulated card objects (= information):
3h 6c 8h Js Jh
Furthermore:
When a card is dealt from the deck (of cards), the same card cannot be dealt again !!!
How do we simulate this ???

Answer:
More information is necessary....

Recall that we has stored a deck of cards as an array of Card objects:

The definition of the DeckOfCards class

    public class DeckOfCards
    {
       private Card[] deckOfCards;         // Used to store all 52 cards     
    }

Depicted graphically (make things clearer):

We can simulate "dealing" a card from a deck using an "current card" index variable:

How to simulate "dealing a card":

Initial state: (a fresh deck)

Suppose no card has been dealt yet.
The next card that will be dealt is the card store at the variable deckOfCard[0]

We initilize: currentCard = 0

Graphical depiction of the initial state:

Deal a card:

First, we return the Card object stored at the currentCard position
(In this example, the Card object that will be returned is Ac (Ace of Club)
Then, we advance the currentCard position to the next Card object:
currentCard++;
Result:

The updated definition of the DeckOfCards class

We need to add one more piece of information (namely: currentCard) to simulate dealing cards from a deck:

   public class DeckOfCards
   {
      public static final int NCARDS = 52;
    
      private Card[] deckOfCards;         // Contains all 52 cards
      private int currentCard;            // deal THIS card in deck      
    
      public DeckOfCards( )
      {
   	 deckOfCards = new Card[ NCARDS ];
    
   	 int i = 0;
    
   	 for ( int suit = Card.SPADE; suit <= Card.DIAMOND; suit++ )
   	    for ( int rank = 1; rank <= 13; rank++ )
   		deckOfCards[i++] = new Card(suit, rank);
    
   	 currentCard = 0;         // Fresh deck of card...
      }
    
      public String toString()
      {
   	 String s = "";
   	 int k;
    
   	 k = 0;
   	 for ( int i = 0; i < 4; i++ )
   	 {
   	    for ( int j = 1; j <= 13; j++ )
   		s += (deckOfCards[k++] + " ");
    
   	    s += "\n";
   	 }
   	 return ( s );
      }
   }

OK, we are now ready to implement the desired operations on a deck of cards
Let's shuffle up and deal !!!!

Dealing a card from the deck

Name of the "deal a card" method:
Let's pick this name: deal
Input parameters:
Dealing the next card does not require any additional information
Therefore: no input parameters necessary

Output value:

Dealing the next card must return the current card in the deck
Therefore: the method deal must return a Card object

Therefore, the header of the deal method is as follows:

    // No parameters
    // Returns a "Card" object
    public Card deal()                  
    {
       ....
    }

What must the deal method do:

From the above discussion (see: click here):

First, we return the Card object stored at the currentCard position
Then, we advance the currentCard position to the next Card object

The deal() method:

   public class DeckOfCards
   {
      public static final int NCARDS = 52;
    
      private Card[] deckOfCards;         // Contains all 52 cards
      private int currentCard;            // deal THIS card in deck      
    
      public DeckOfCards( )
      {
   	 deckOfCards = new Card[ NCARDS ];
    
   	 int i = 0;
    
   	 for ( int suit = Card.SPADE; suit <= Card.DIAMOND; suit++ )
   	    for ( int rank = 1; rank <= 13; rank++ )
   		deckOfCards[i++] = new Card(suit, rank);
    
   	 currentCard = 0;         // Fresh deck of card...
      }

      /* ---------------------------------------------------------
         deal(): deal the next card in the deck
	    i.e. deal deckOfCards[currentCard] out
	 --------------------------------------------------------- */
      public Card deal()
      {
   	 if ( currentCard < NCARDS )
   	 {
   	    return ( deckOfCards[ currentCard++ ] );
   	 }
   	 else
   	 {
   	    System.out.println("Out of cards error");
   	    return ( null );  // Error;
   	 }
      }

      public String toString()
      {
   	 String s = "";
   	 int k;
    
   	 k = 0;
   	 for ( int i = 0; i < 4; i++ )
   	 {
   	    for ( int j = 1; j <= 13; j++ )
   		s += (deckOfCards[k++] + " ");
    
   	    s += "\n";
   	 }
   	 return ( s );
      }
   }

Note:

In the deal() method, we make use of the fact that currentCard++ evaluates to the old value
So the Card object that is return is the one pointed to by the old value of currentCard before the increment operation !!!

Shuffling a deck of cards

The effect of shuffling a deck of cards:

The order of the cards in the deck becomes random
After shuffling, we start dealing card from the top of the deck
(I.e., currentCard is reset to 0 (zero)).

The classic solution (a well-known trick in Computer Science) used to shuffle objects stored an array is the following algorithm:

     repeat for many times
     {
        select 2 random object in the array                
	exchange the selected objects
     }

Example: (shuffling an array of integers)

Initial array of 10 integers:

    1   2   3   4   5   6   7   8   9   10

Pick 2 elements randomly and exchange them:

    1   2   3   4   5   6   7   8   9   10       

 Result:
    1   2   9   4   5   6   7   8   3   10

Pick 2 elements randomly and exchange them:

    1   2   9   4   5   6   7   8   3   10       

 Result:
    1   2   9   4   7   6   5   8   3   10

And so on.... (the elements will become more and more random)

The shuffle method

Name the method... let's pick this name:
shuffle

Input parameters:

We can tell the shuffle method the number pair exchanges that it needs to perform.
Therefore: parameter n = number of "exchanges" performed (i.e., how "long" it needs to shuffle)

Output value:

Shuffling a deck of cards does not return any value
(It only has effect of the state of the cards in the deck)

Therefore: the method shuffle return a void type

Therefore, the header of the shuffle method is as follows:

    // Input: n = # exchange operations performed
    // Returns nothing....
    public void shuffle(int n)                  
    {
       ....
    }

What must the deal method do:

Pseudo code:

    // Input: n = # exchange operations performed
    // Returns nothing....
    public void shuffle(int n)                  
    {
       for ( k = 1, 2, 3, ..., n )
       {
          i = a random integer number between [0 .. 51];
          j = another random integer number between [0 .. 51];       

	  exchange: deckOfCard[i] and deckOfCard[j];
       }
    }

We need to solve 2 problems:
How to pick a random integer number between 0 .. 51.

How to exchange 2 cards in an array.

Picking a random integer number between [0 .. 51]

The method Math.random() returns a random number betweem [0 .. 1):

  static double random()

      Returns a double value with a positive sign, 
      greater than or equal to 0.0 and less than 1.0.         

  (See Java's API doc: click here)

Therefore:

         0.0   ≤   Math.random()   <   1.0                  

    ⇒   0.0   ≤  52×Math.random() <  52.0

    ⇒   0   ≤  (int) (52×Math.random()) <  52

The integers that are ≥ 0 and < 52 are:

0, 1, 2, 3, ...., 50, 51

Exchanging 2 elements in an array:

We have seen this problem before in the Selection Sort Algorithm --- See: click here
The classic algorithm used to exchange the values of 2 variables is the 3-way exchange algorithm:

Exchange: deckOfCard[i] and deckOfCard[j]

   Card help;

   help = deckOfCard[i];
   deckOfCard[i] = deckOfCard[j];           
   deckOfCard[j] = help;

The shuffle() method:

   /* ------------------------------------------------
      shuffle(n): shuffle the deck using n exchanges
      ------------------------------------------------ */
   public void shuffle(int n)
   {
      int i, j, k;

      for ( k = 0; k < n; k++ )
      {
          i = (int) ( NCARDS * Math.random() );  // Pick 2 random cards      
          j = (int) ( NCARDS * Math.random() );  // in the deck

          /* ---------------------------------
             Swap these randomly picked cards
             --------------------------------- */
          Card tmp = deckOfCards[i];
          deckOfCards[i] = deckOfCards[j];
          deckOfCards[j] = tmp;
      }

      currentCard = 0;   // Reset current card to deal from top of deck
   }

The DeckOfCard Class

This is the complete definition of the DeckOfCard class

It can simulate a deck of 52 playing cards:

You can shuffle the deck of cards
You can deal a card to a player.
(A deck of "computer cards" can only perform these 2 operations !!!)

The DeckOfCards class definition:

   /* -----------------------------------------------------
      Deck: a deck of cards
      ----------------------------------------------------- */
    
   public class DeckOfCards
   {
      public static final int NCARDS = 52;
    
      private Card[] deckOfCards;         // Contains all 52 cards
      private int currentCard;            // deal THIS card in deck           
    
      public DeckOfCards( )    // Constructor
      {
   	 deckOfCards = new Card[ NCARDS ];
    
   	 int i = 0;
    
   	 for ( int suit = Card.SPADE; suit <= Card.DIAMOND; suit++ )
   	    for ( int rank = 1; rank <= 13; rank++ )
   		deckOfCards[i++] = new Card(suit, rank);
    
   	 currentCard = 0;
      }
    
      /* ---------------------------------
   	 shuffle(n): shuffle the deck
   	 --------------------------------- */
      public void shuffle(int n)
      {
   	 int i, j, k;
    
   	 for ( k = 0; k < n; k++ )
   	 {
   	     i = (int) ( NCARDS * Math.random() );  // Pick 2 random cards
   	     j = (int) ( NCARDS * Math.random() );  // in the deck
    
   	     /* ---------------------------------
   		swap these randomly picked cards
   		--------------------------------- */
   	     Card tmp = deckOfCards[i];
   	     deckOfCards[i] = deckOfCards[j];
   	     deckOfCards[j] = tmp;;
   	 }
    
   	 currentCard = 0;   // Reset current card to deal
      }
      /* -------------------------------------------
   	 deal(): deal deckOfCards[currentCard] out
   	 ------------------------------------------- */
      public Card deal()
      {
   	 if ( currentCard < NCARDS )
   	 {
   	    return ( deckOfCards[ currentCard++ ] );
   	 }
   	 else
   	 {
   	    System.out.println("Out of cards error");
   	    return ( null );  // Error;
   	 }
      }
    
      public String toString()
      {
   	 String s = "";
   	 int k;
    
   	 k = 0;
   	 for ( int i = 0; i < 4; i++ )
   	 {
   	    for ( int j = 1; j <= 13; j++ )
   		s += (deckOfCards[k++] + " ");
    
   	    s += "\n";
   	 }
   	 return ( s );
      }
   }

Reference:

http://www.mathcs.emory.edu/~cheung/Courses/170/Syllabus/10/deck-of-cards.html

Shuffle up and...	Deal !!!

Implementing a deck of cards

Implementing a deck of cards

猜你喜欢