`

Implementing a deck of cards

OOD 
阅读更多

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

分享到：
| Binary Trees
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics