1. and Functions to Simplify Code
Example Using Arrays
Using Top-Down Design
and Functions to Simplify Code
and Create Modules

2. Problem: Dealing Cards
Deal a hand of cards to a player
Write a program that deals a hand of cards to a player assuring that no cards are repeated.
The user must supply the number of cards per hand.

3. Algorithm: Dealing Cards
Print Explanation to user
Get number of cards per hand from user
for each card in the hand
Randomly generate a card
Assure that card hasn’t already been dealt.
Put the new card in the player’s hand
Record this card as a dealt card
Print the suit and value of the cards in the player’s hand

4. Dealing Cards Thinking it through
Draw a card by randomly getting a suit, a number between 0 and 3, inclusive & randomly getting a card value (1 - 13).
Store the cards in a hand by having 4 arrays, one for each suit, that has a 1 as the element at the appropriate index to indicate the card’s presence, 0 its absence.
Keep track of already used cards in 4 arrays (same storage method as hand)

5. Dealing Cards Design & write function prototypes
void PrintExplanation (void) ;
int GetNumPerHand (int min, int max) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ], int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]);
void InitArray (int array[ ], int numElems) ;
int GetRandomSuit (void) ;
int GetRandomValue (void) ;
int AlreadyUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]) ;
void Deal (int suit, int value, int handHearts[ ], int handClubs[ ],
int handDiamonds[ ], int handSpades[ ]);
void RecordAsUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ],
void PrintHand (int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ] );

6. Dealing Cards Write and test PrintExplanation( )
/*****************************************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a player. The number of *
* cards is specified by the user *
\*****************************************************************************************/
#include <stdio.h>
void PrintExplanation (void) ;
int main ( ) {
PrintExplanation ( ) ;
return 0; }
/**************************************************
* PrintExplanation is a procedure that prints the program explanation for the user
* It takes no arguments and returns no values
\*************************************************/
void PrintExplanation (void)
printf (“This program deals a hand of cards to you. You will be asked\n”);
printf (“to enter the number of cards you’d like in the hand.\n\n\n”);

7. Dealing Cards Write and test InitializeArrays( )
/************************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a player. *
* The number of cards is specified by the user. *
\************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ], int dealtSpades[ ]);
void InitArray (int array[ ], int numElems) ;
int main ( ) {
int handHearts[SIZE], handClubs[SIZE], handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE], dealtDiamonds[SIZE], dealtSpades[SIZE] ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs, handDiamonds, handSpades,
dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
return 0; }

8. Dealing Cards Write and test InitializeArrays( )
/*********************************************\
* InitializeArrays initializes all of the arrays passed to it
* to hold all zeros by passing each to the InitArray function.
\*********************************************/
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ], int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]) {
InitArray (handHearts, SIZE) ;
InitArray (handClubs, SIZE) ;
InitArray (handDiamonds, SIZE) ;
InitArray (handSpades, SIZE) ;
InitArray (dealtHearts, SIZE) ;
InitArray (dealtClubs, SIZE) ;
InitArray (dealtDiamonds, SIZE) ;
InitArray (dealtSpades, SIZE) ; }

9. Dealing Cards Write and test InitArray( )
/*********************************************\
* InitArray initializes the array of ints passed to it
* to hold all zeros. The number of elements in the
* array is passed in as numElems
\*********************************************/
void InitArray (int array[ ], int numElems) {
int i ;
for (i = 0 ; i < numElems ; i++)
array [ i ] = 0 ; }

10. Dealing Cards Write and test GetNumPerHand( )
/*****************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a *
* player. The number of cards is specified *
* by the user *
\*****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ],
int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]);
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int main ( ) {
int num, handHearts[SIZE], handClubs[SIZE];
int handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE];
int dealtDiamonds[SIZE], dealtSpades[SIZE] ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs,
handDiamonds, handSpades,
dealtHearts, dealtClubs,
dealtDiamonds, dealtSpades);
num = GetNumPerHand (MIN, MAX) ;
printf (“num = %d\n”, num) ;
return 0; }

11. Dealing Cards Write and test GetNumPerHand ( )
/**************************************************
* GetNumPerHand gets the number of cards per hand from the user and returns it to the
* calling function. It assures that the number of cards is between the minimum amount passed to
* this function and the maximum amount passed to this function.
\*************************************************/
int GetNumPerHand (int min, int max) {
int num ;
printf (“Enter the number of cards per hand : “) ;
scanf (“%d”, &num) ;
/* assure input is between min and max */
while ( num < min || num > max )
printf (“The number of cards per hand must be between %d and %d, inclusive\n”, min, max) ; }
return num ;

12. Dealing Cards Write and test GetRandomSuit( ) & GetRandomValue( )
/*****************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a *
* player. The number of cards is specified *
* by the user *
\*****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ],
int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]);
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int main ( ) {
int i, num, handHearts[SIZE], handClubs[SIZE];
int handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE];
int dealtDiamonds[SIZE], dealtSpades[SIZE] ;
int suit, value ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs,
handDiamonds, handSpades,
dealtHearts, dealtClubs,
dealtDiamonds, dealtSpades);
num = GetNumPerHand (MIN, MAX) ;
for ( i = 0 ; i < num ; i++ )
suit = GetRandomSuit ( ) ;
value = GetRandomValue ( ) ;
printf (“%d: %d of %d\n”, i, value, suit) ; }
return 0;

13. Dealing Cards Write and test GetRandomSuit( ) & GetRandomValue( )
/**************************************************
* GetRandomSuit gets a random number between 0 and 3 to indicate the suit of the drawn card.
\*************************************************/
int GetRandomSuit (void) {
int suit ;
suit = rand ( ) % 4 ;
return suit ; }
* GetRandomValue gets a random number between 1 and 13, the value of the drawn card.
int GetRandomValue (void)
int value ;
value = rand ( ) % ;
return value ;

14. Dealing Cards Write and test AlreadyUsed( )
/*****************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a *
* player. The number of cards is specified *
* by the user *
\*****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ],
int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ],
int dealtDiamonds[ ], int dealtSpades[ ]);
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int AlreadyUsed (int suit, int value, int dealtHearts[ ],
int dealtClubs[ ], int dealtDiamonds[ ],
int dealtSpades[ ]) ;
int main ( ) {
int i, num, handHearts[SIZE], handClubs[SIZE];
int handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE];
int dealtDiamonds[SIZE], dealtSpades[SIZE] ;
int suit, value ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs,
handDiamonds, handSpades,
dealtHearts, dealtClubs,
dealtDiamonds, dealtSpades);
num = GetNumPerHand (MIN, MAX) ;
for ( i = 0 ; i < num ; i++ )
suit = GetRandomSuit ( ) ;
value = GetRandomValue ( ) ;
while (AlreadyUsed (suit, value, dealtHearts,
dealtClubs, dealtDiamonds,
dealtSpades) ) }
return 0;

15. Dealing Cards - Write and test AlreadyUsed( )
/**************************************************
* AlreadyUsed returns true if a card has already been dealt and false if it hasn’t been dealt yet.
* The function takes the suit and value of the card to be checked and the four arrays of dealt
* cards, dealtHearts, dealtClubs, dealtDiamonds, and dealtSpades as arguments.
\*************************************************/
int AlreadyUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ],
int dealtSpades[ ]) {
int used;
switch (suit)
case HEARTS : used = dealtHearts [value] ;
break;
case CLUBS : used = dealtClubs [value] ;
case DIAMONDS : used = dealtDiamonds [value] ;
case SPADES : used = dealtSpades [value] ;
default : printf (“Error in suit in AlreadyUsed\n”) ;
used = -1 ; }
return used ;

16. Dealing Cards Write and test Deal( ) & RecordAsUsed( )
/**********************************************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a player. The number of *
* cards is specified by the user *
\**********************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ], int dealtSpades[ ]) ;
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int AlreadyUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ],
int dealtSpades[ ]) ;
void Deal (int suit, int value, int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ]) ;

17. Dealing Cards Write and test Deal( ) & RecordAsUsed( )
int main ( ) {
int i, num, suit, value ;
int handHearts[SIZE], handClubs[SIZE], handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE], dealtDiamonds[SIZE], dealtSpades[SIZE] ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs, handDiamonds, handSpades,
dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
num = GetNumPerHand (MIN, MAX) ;
for ( i = 0 ; i < num ; i++ )
suit = GetRandomSuit ( ) ;
value = GetRandomValue ( ) ;
while (AlreadyUsed (suit, value, dealtHearts, dealtClubs, dealtDiamonds, dealtSpades ) ) }
Deal (handHearts, handClubs, handDiamonds, handSpades) ;
RecordAsUsed (dealtHearts, dealtClubs, dealtDiamonds, dealtSpades) ;
return 0 ;

18. Dealing Cards Write and test Deal( )
/**************************************************
* Deal takes the suit and value of a card and the four arrays of cards representing the player’s
* hand, handHearts, handClubs, handDiamonds, and handSpades as arguments. The element of
* the appropriate array is changed to 1 to indicate that the card is in the hand.
\*************************************************/
void Deal (int suit, int value, int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ]) {
switch (suit)
case HEARTS : handHearts [value] = 1 ;
break ;
case CLUBS : handClubs [value] = 1 ;
break ;;
case DIAMONDS : handDiamonds [value] = 1 ;
case SPADES : handSpades [value] = 1 ;
default : printf ( “ Error in suit in Deal \n ” ) ; }

19. Dealing Cards Write and test RecordAsUsed( )
/**************************************************
* RecordAsUsed takes the suit and value of a card and the four arrays of dealt cards, dealtHearts,
* dealtClubs, dealtDiamonds, and dealtSpades as arguments. The element of the appropriate
* array is changed to 1 to indicate that the card has been dealt.
\*************************************************/
void RecordAsUsed ( int suit, int value, int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ] ,
int dealtSpades[ ] ) {
switch (suit)
case HEARTS : dealtHearts [value] = 1 ;
break ;
case CLUBS : dealtClubs [value] = 1 ;
case DIAMONDS : dealtDiamonds [value] = 1 ;
case SPADES : dealtSpades [value] = 1 ;
default : printf (“Error in suit in RecordAsUsed\n”) ; }

20. Dealing Cards - Write and test PrintHand( )
/**********************************************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a player. The number of *
* cards is specified by the user *
\**********************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ], int dealtSpades[ ]) ;
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int AlreadyUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ],
int dealtSpades[ ]) ;
void Deal (int suit, int value, int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ]) ;
void PrintHand (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ] ) ;

21. Dealing Cards Write and test PrintHand( )
int main ( ) {
int i, num, suit, value ;
int handHearts[SIZE], handClubs[SIZE], handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE], dealtDiamonds[SIZE], dealtSpades[SIZE] ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs, handDiamonds, handSpades,
dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
num = GetNumPerHand (MIN, MAX) ;
for ( i = 0 ; i < num ; i++ )
suit = GetRandomSuit ( ) ;
value = GetRandomValue ( ) ;
while (AlreadyUsed (suit, value, dealtHearts, dealtClubs, dealtDiamonds, dealtSpades ) ) }
Deal (handHearts, handClubs, handDiamonds, handSpades) ;
RecordAsUsed (dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
PrintHand (handHearts, handClubs, handDiamonds, handSpades ) ;
return 0;

22. Dealing Cards - Write and test PrintHand( )
/**************************************************
* PrintHand takes the number of cards in the hand and the four arrays of cards representing the
* player’s hand, handHearts, handClubs, handDiamonds, and handSpades as arguments. The
* values and suits of each card held in the hand is printed.
\*************************************************/
void PrintHand (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ] ) {
int i ;
for ( i = 1 ; i < SIZE ; i++ )
if (handHearts [ i ] == 1)
printf (“%d of Hearts\n”, i ) ; }
if (handClubs [ i ] == 1)
printf (“%d of Clubs\n”, i ) ;

23. Dealing Cards Write and test PrintHand( ) (continued)
for ( i = 1 ; i < SIZE ; i++ ) {
if (handDiamonds [ i ] == 1)
printf (“%d of Diamonds\n”, i ) ; }
if (handSpades [ i ] == 1)
printf (“%d of Spades\n”, i ) ;
} /* end of PrintHand Function */

24. Dealing Cards - Final Version
/**********************************************************************************************\
* Filename: cards.c *
* Author: *
* Description: This program deals a hand of cards to a player. The number of *
* cards is specified by the user *
\**********************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define HEARTS
#define CLUBS
#define DIAMONDS 2
#define SPADES
#define SIZE
#define MIN
#define MAX
void PrintExplanation (void) ;
void InitializeArrays (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ],
int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ], int dealtSpades[ ]) ;
void InitArray (int array[ ], int numElems) ;
int GetNumPerHand (int min, int max) ;
int AlreadyUsed (int suit, int value, int dealtHearts[ ], int dealtClubs[ ], int dealtDiamonds[ ],
int dealtSpades[ ]) ;
void Deal (int suit, int value, int handHearts[ ], int handClubs[ ], int handDiamonds[ ],
int handSpades[ ]) ;
void PrintHand (int handHearts[ ], int handClubs[ ], int handDiamonds[ ], int handSpades[ ] ) ;

25. Dealing Cards - Final Version
int main ( ) {
int i, num, suit, value ;
int handHearts[SIZE], handClubs[SIZE], handDiamonds[SIZE], handSpades[SIZE] ;
int dealtHearts[SIZE], dealtClubs[SIZE], dealtDiamonds[SIZE], dealtSpades[SIZE] ;
PrintExplanation ( ) ;
InitializeArrays (handHearts, handClubs, handDiamonds, handSpades,
dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
srand ( time (0) ) ;
num = GetNumPerHand (MIN, MAX) ;
/* Deal a hand of cards making sure that each card hasn’t already been dealt */
for ( i = 0 ; i < num ; i++ )
suit = GetRandomSuit ( ) ;
value = GetRandomValue ( ) ;
while (AlreadyUsed (suit, value, dealtHearts, dealtClubs, dealtDiamonds, dealtSpades ) ) }
Deal (suit, handHearts, handClubs, handDiamonds, handSpades) ;
RecordAsUsed (value, dealtHearts, dealtClubs, dealtDiamonds, dealtSpades);
PrintHand (handHearts, handClubs, handDiamonds, handSpades ) ;
return 0;

26. Further Improvements ? We have a design error !
We should have realized that Deal and RecordAsUsed would have same exact code.
We could have had one function called AddCard that would have the same code as Deal or RecordAsUsed and passed in the arrays for the hand when dealing and the arrays for dealt when recording a used card.
Wouldn’t this have been easier to handle if we had spotted it sooner ?
We should rewrite PrintHand( ) so that it prints Jack, Queen and King instead of 11, 12, & 13.
Anything else ?