APS106 – Lab #6
Welcome to the second half of the APS106 labs. In the first half of this course, we focused on learning
tools that could be used within your programs. Going forward in the second half, we will be more
focused on using these tools to solve more interesting problems.
Because this lets us ask a wider range of questions, many of you will find the labs 6-9 much more
challenging than labs 1-5.
We highly encourage you to read the labs early in the week and attend your practical and tutorial
sessions. These are the best way for you to discuss and get help from your TAs. Remember, these labs
are designed to challenge you and give you the opportunity to learn and your instructors and TAs are
committed to providing you the support you along the way.
Preamble
This week you will practice using loops, lists, and conditionals to implement a simple card game.
Use appropriate variable names and place comments throughout your program.
The name of the source file must be “lab6.py”.
Deliverables
For this lab, you must submit the three functions listed below within a single file named
‘lab6.py’ to MarkUS by the posted deadline.
Functions to implement for this lab:
1. deal_card
2. score_hand
3. play
Two additional functions are provided within the starter code. You may use these functions to
complete and test your code as needed. You are not expected to modify these functions.
• generate_deck
• shuffle
Five test cases are provided on MarkUs to help you prepare your solution. Passing all these test
cases does not guarantee your code is co
ect. You will need to develop your own test cases to
verify your solution works co
ectly. Your programs will be graded using ten secret test cases.
These test cases will be released after the assignment deadline.
IMPORTANT:
• Do not change the file name or function names
• Do not use input() inside your program
Problem
For this lab you will complete a program to play a very simplified version of the card game
cri
age1. The game is played with a standard 52-card deck. During the game, two players are
oth dealt2 five cards from the deck according to the rules (outlined in part 3). The player that
has the hand3 with the most points is the winner.
In this exercise, you will use nested lists to represent cards within the deck and within each
player’s hand. For example, the list:
[['diamonds', 7], ['hearts', 11], ['clubs', 8], ['spades', 5], ['spades', 1]]
would be used to represent a player with a hand containing the 7 of diamonds, the jack of hearts,
the 8 of clubs, the 5 of spades, and the ace of spades. Each card is represented with a two-
element list where the first element is a string specifying the suit and the second element is an
integer representing the card value. The deck and player hands are lists containing these two-
element card lists as elements.
For this lab, you will need to complete 3 functions:
• deal_card(deck,hand)
• score_hand(hand)
• play(shuffled_deck)
Both deal_card and score_hand are helper functions that you will call from within play
to execute the game.
Additionally, you are provided two additional helper functions to help you complete and test
your code:
• generate_deck()
• shuffle(deck)
You do not need to edit these two functions. They are provided to help you test and complete
your code. generate_deck will create and return a list representing a standard 52-card deck.
Each element of the returned list will be a two-element list. The first element containing a string
epresenting the suit (spades, clubs, diamonds, or hearts) and the second element will be an
integer between 1 and 13 inclusive, representing the card value. Values 2-10 represent number
cards, 1 represents an ace, 11 a jack, 12 a queen, and 13 a king. Calling the shuffle function
will return a random permutation of the cards.
We will
eak down how to complete the different functions in the steps below.
1 We’ll provide all the details about the game that you need to complete the lab
2 Dealing a card refers to the act of removing the card cu
ently at the top of the deck and assigning it to one
player’s hand.
3 A player’s hand is the collection of cards dealt to them during the game
https:
en.wikipedia.org/wiki/Standard_52-card_deck
Part 1: Deal Card
For the first part of the lab, you will complete the deal_card function. By completing this
function, you will become more familiar with the concept of aliasing and why you need to be
careful when modifying lists passed as inputs to functions!
This function takes two lists as arguments. The first input list represents the game’s deck of cards
and the second represents a player’s hand. The function should remove the first card from the
deck list and append it to the end of the list representing the player’s hand.
Note this function should return None. That is, your function should not return either of the
modified lists. You may think this is weird, and may be wondering how the modified lists get
passed back to the code that called the function. The answer is that they do not need to be passed
ack and the reason for this lies in the aliasing property of lists. Aliasing is tricky and (spoiler
alert!) this will be an important concept to understand in the remainder of APS106. After
implementing the function, try to explain to yourself how and why this function works. Discuss
it with your TAs and colleagues to see if your understanding is co
ect.
The following code snippet illustrates the behaviour of the function.
deck = [['spades',10],['hearts',2],['clubs',8]] # deck with 3 cards
player_hand = [['diamonds',3]] # list representing a player’s hand,
cu
ently with a single card
print("Deck and hand before deal_hand function call")
print("\tdeck : ",deck)
print("\thand : ",player_hand)
deal_card(deck,player_hand) # Notice no equals sign! Nothing assigned from
the function return
print("\nDeck and hand after deal_hand function call")
print("\tdeck : ",deck)
print("\thand : ",player_hand)
Printed Output
Deck and hand before deal_hand function call
deck : [['spades', 10], ['hearts', 2], ['clubs', 8]]
hand : [['diamonds', 3]]
Deck and hand after deal_hand function call
deck : [['hearts', 2], ['clubs', 8]]
hand : [['diamonds', 3], ['spades', 10]]
Notice that after the function call, the first element from the deck (the 10 of spades) list has been
emoved and has been appended to the end of the hand list. You may assume that the deck list
will always have a minimum of one card.
Part 2: Score Hand
Is this part, you will complete the function score_hand(hand) which calculates the score for
the list of five cards in a player’s hand. The input parameter to this function is a list of five cards
epresenting a player’s hand. You may assume that the list input to the function will always
contain five cards.
The score will be calculated according to the hand scoring rules of cri
age, with very slight
modifications. The score_hand function should calculate points according to the following:
1. Each pair (i.e. same card value) scores 2 points. If a hand contains three or four of a
kind, 2 points are scored for every combination of pairs. So, three of a kind scores 6
points and four of a kind scores 12 points.
2. If all five cards are the same suit, 5 points are scored. If there are only four cards with the
same suit, 4 points are scored.
3. A group of three cards with consecutive values (called a run or straight) scores three
points. The suit of the cards does not matter. A run of four consecutive values scores 4
points and a run of five consecutive values scores 5 points. Other points regarding runs:
a. Points are scored for every unique set of cards that produces a run. For example,
the hand: ace of hearts, ace of spaces, two of diamonds, three of hearts, and three
of spades would score 12 points for runs because the run 1-3 can be constructed
with four distinct sets of cards (note that the total score for the hand would be 16
as there are also two pairs in the hand).
. For the purposes of defining runs aces, jacks, queens, and kings can be interpreted
as the values 1, 11, 12, and 13, respectively.
c. A run cannot wrap around from a king to an ace (i.e. A queen, king, and an ace
would not be considered a run)
d. Points are not awarded for shorter runs within a longer run. For example, in a run
of four cards, no points would be awarded for the two runs of three within the
hand.
4. All combinations of cards that sum to 15 are worth 2 points. When summing card
combinations, aces are counted as one and jacks, queens, and kings are all counted as 10.
5.
Sample test cases:
Hand Points Description
10 of hearts
2 of hearts
3 of hearts
6 of clubs
5 of diamonds
XXXXXXXXXX = 15 => 2 pts
5 + 10 = 15 => 2 pts
9 of hearts
2 of spades
3 of clubs
3 of hearts
4 of hearts
12 Pair of threes => 2 pts
Run of 2, 3 (clubs), 4 => 3 pts
Run of 2, 3 (hearts), 4 => 3 pts
XXXXXXXXXX = 15 => 2 pts
XXXXXXXXXX = 15 => 2 pts
5 of diamonds
Queen of diamonds
King of diamonds
Ace of diamonds
5 of hearts
14 Pair of fives => 2 pts
5 (hearts XXXXXXXXXXqueen) => 2 pts
5 (hearts XXXXXXXXXXking) => 2 pts
5 (diamonds XXXXXXXXXXqueen) => 2 pts
5 (diamonds XXXXXXXXXXking) => 2 pts
Four of same suit (diamonds) => 4 pts
3 of diamonds
4 of diamonds
5 of diamonds
6 of diamonds
7 of diamonds
14 Five of same suit => 5 pts
Run of 3,4,5,6,7 => 5 pts
XXXXXXXXXX = 15 => 2 pts
XXXXXXXXXX = 15 => 2 pts
You can generate additional test cases using this website
(http:
www.bucktheodds.com/cri
age/score). Set the score hand button to ‘Crib’. You can
ignore the distinction between common and hand cards as well as any points awarded for Jacks.
This function is not trivial and will get very messy if you try to write the code without a clear
algorithm plan. It is recommended you spend time trying to think about how to solve this before
trying to code a solution.
Here a couple hints to help you get started:
1. Break the problem into smaller pieces. Try developing a solution for scoring pairs of
cards first. Once you have a solution for this part of the problem, test it until you are
confident it works. Then work on adding to your code to identify other sources of points.
2. One possible strategy for identifying pairs and groups of cards in the same suit is to build
a histogram counting the number cards with a value or suit within the hand. You could
use a list and a for loop to create the histogram.
3. The function combinations from the itertools module will generate all possible
unique combinations of size C from the set of N elements within a list (combinations of
N choose C). You can then convert this into a list of all combinations that you can iterate
through using a for loop. You can experiment with this function using this snippet:
from itertools import combinations
lst = [1,2,3,4,5]
combos_of_two = list(combinations(lst, 2)) # returns list of all n choose 2
combinations
combos_of_three = list(combinations(lst, 3)) # returns list of all n choose 3
combinations
http:
www.bucktheodds.com/cri
age/score
https:
www.mathsisfun.com/data/histograms.html
Note that we wrap the return of combinations in list() because the value returned from
combinations is something slightly different from a list which you have not learned about in
APS106.
Part 3: Implement the Game
For the final part of the lab, you will need to complete the play function which plays a game
etween two people: a "player" and a "dealer". This function should utilize both the functions
you completed in parts 1 and 2. The rules for playing the game are as follows:
1. Deal 5 cards to both