CS 8: Introduction to Computer Science

Fall 2023 Final Project

Due Tuesday, December 12, 11:59PM (California time)

In the game Yahtzee, players try to get particular combinations of five six-sided dice. For

a given turn, they can make up to three rolls: on the first roll, they roll all five dice; on

the second roll, they can choose to re-roll none, any, or all of the dice again; and on the

third roll, they again can choose to re-roll none, any, or all of the dice again. The best

outcome for a given turn is to get what’s called a Yahtzee, in which all five dice have the

same value on them. It doesn’t matter what that value is, just that they are all the same.

Here is an example. For the first roll, say a player gets:

2 4 1 6 4

Let’s say they choose not to re-roll the two dice that were 4’s, but they do re-roll the dice

that were 2, 1, and 6, giving new values for those three dice:

4 3 4

So at this point, after their second roll, the five dice are:

4 4 3 4 4

(Here I’m keeping the dice “in order”: the dice which was previously a 2 is now a 4, the

dice that was previously a 1 is now a 3, and the dice that was previously a 6 is now a 4.

The dice that were previously 4’s stay as 4’s.) For the player’s third roll, they choose to

only re-roll the dice that is a 3, and let’s say it comes up 4. So after the third roll, the

five dice are:

4 4 4 4 4

They all are the same! Yahtzee!

In this final project, you will write Python code to calculate the probability that a player

will get a Yahtzee on a given turn using the following strategy: You always try to get a

Yahtzee with the highest dice value for which you have the largest number of matching

dice. So if your dice are

4 2 4 5 2

you would keep the 4’s, and re-roll the 2’s and the 5.

There is also a related game called Tenzi, in which each player has ten 6-sided dice. On

the first roll, they roll all ten dice. On the second and all subsequent rolls they can choose

1

to re-roll none, any, or all of the dice again. They keep rolling until all ten dice have the

same value on them - a Tenzi! In this final project, you’ll also write Python code to keep

track of how many rolls it takes in order to get a Tenzi.

Please use the following code in order to generate a random integer 1,2,3,4,5, or 6:

import random

def rollDice():

return random.randrange(1,7)

Your main program should prompt the user to either play Yahtzee (by inputting Y), play

Tenzi (by inputting T), or quit (by inputting anything else). This prompt should continue

to be appear until the user quits. If the choice is Y, the user should be prompted to input

the number of trials to simulate for the Monte Carlo simulation and the number of dice

to use. The following should be printed to the shell:

Probability of Yahtzee with X dice: y.yyyy

where X is the number of dice which the user input, and y.yyyy is the probability of

getting a Yahtzee. Use four decimals for printing the probability. If the choice is T, the

user should be prompted to input the number of trials to simulate and the number of dice

to use. The following should be printed to the shell:

Rolls to get a Tenzi with X dice:

{1: Y, 2: Y, 3: Y, 4: Y, 5: Y, 6: Y, 7: Y, 8: Y, 9: Y, 10: Y, ’more than 10’ : Y}

where X is the number of dice which the user input, and the Y’s are the number of times

in the set of trials that it took that many rolls to get a Tenzi.

The following gives an example of running your code:

Note that the numbers you get may differ from these, but this should at least give a good

idea of what you should obtain from your code.

2

You’ll turn in a single Python program called yahtzee.py which includes the code given

above for simulating a dice roll, the main program as described above, and the following functions. Please be sure to include appropriate docstrings and comments for each

function.

• firstRoll : This should take an integer numDice as an input parameter which

tells how many dice you’re using in your game (this will be 5 for Yahtzee and 10

for Tenzi, but your function should be written for a general value for numDice),

and returns a list of length numDice of random integers each obtained by calling

rollDice. For example, the call

firstRoll(5)

will return a list such as

[2,4,1,6,4]

• newRoll : This should take the list diceList and an integer choice as input

parameters. Here diceList is a list of dice rolls, such as [2,4,1,6,4], and choice

is an integer corresponding to the dice value that you’re hoping to get a Yahtzee

with, such as 4. This should return a new list for which all dice which are not equal

to choice are re-rolled. For example, the call

newRoll([2,4,1,6,4],4)

will return a list such as

[4,4,3,4,4]

As in the example above, here the dice which was previously a 2 is now a 4, the

dice that was previously a 1 is now a 3, and the dice that was previously a 6 is now

a 4. The dice that were previously 4’s stay as 4’s.

• createDiceDict : This should take the list diceList as an input parameter, and

return a dictionary for which the keys are the possible roll values 1, 2, 3, 4, 5,

and 6, and the values are the number of times that roll value appears in the list.

For example, the call

createDiceDict([2,4,1,6,4])

will return the dictionary

{1:1, 2:1, 3:0, 4:2, 5:0, 6:1}

3

This captures that the value 1 appears once in the list, the value 2 appears once in

the list, the value 4 appears twice in the list, the value 6 appears once in the list,

and the values 3 and 5 don’t appear in the list.

• mostFrequent : This should take diceDict as an input parameter, which is a

dictionary as generated by the function createDiceDict. This should return the

highest dice value for which you have the largest number of matching dice. For

example, the call

mostFrequent({1:1, 2:1, 3:0, 4:2, 5:0, 6:1})

should return the value 4, because the dictionary encodes that the value 4 appeared

most frequently. Note that the call

mostFrequent({1:0, 2:2, 3:0, 4:2, 5:1, 6:0})

should also return the value 4, because we’re using the strategy that you always

try to get a Yahtzee with the highest dice value for which you have the largest

number of matching dice. This would be the dictionary corresponding to the list

[4,2,4,5,2].

• probabilityYahtzee : This should take integers numTrials and numDice as input

parameters. It will perform a Monte Carlo simulation of numTrials turns in which a

player tries to get all of the numDice dice to match. In each turn, the player will do a

first roll, a second roll if needed, and a third roll if needed. It should return the probability of getting all dice to match in one turn, calcuated from the Monte Carlo simulation. Note that in the game Yahtzee there are five dice, but your function should

be general enough to work for any positive integer value for numDice. Your function

should make calls to the functions firstRoll, newRoll, createDiceDict, and

mostFrequent as needed.

• rollsToGetTenzi : This should take integers numTrials and numDice as input

parameters. It will perform a simulation of numTrials trials to keep track of how

many rolls it takes in order for all of the numDice dice to match. It should return a dictionary whose keys are the numbers of rolls that this takes, specifically,

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, and ’more than 10’, and whose values are the

number of times in the numTrials simulations that it took that many rolls. Note

here that if, in a given trial, after 10 rolls the dice do not all match, that trial

should be recorded as ’more than 10’. Note that in Tenzi there are ten dice, but

your function should be general enough to work for any positive integer value for

numDice. Your function should make calls to the functions firstRoll, newRoll,

createDiceDict, and mostFrequent as needed.

The functions firstRoll, newRoll, createDiceDict, and mostFrequent are worth 10

points each. The functions probabilityYahtzee and rollsToGetTenzi, and the main

program are worth 20 points each.

4

Academic Honesty Agreement

This project is open book, open notes. However, all work submitted must be your

own. By submitting these programs, you are asserting that all work on this project is

yours alone; that you did not use ChatGPT, Copilot, or similar AI bots; and that you

will not provide any information to anyone else working on the project. In addition, you

are agreeing that you will not discuss any part of this project with anyone. You are

not allowed to post any information about this project on the internet at any time, either

before or after the due date. Discussing any aspect of this project with anyone constitutes

a violation of the academic integrity agreement for CS8 and would result in an F in the

course.

Please note that you may ask questions about this project to the Professor, the TAs,

and the ULA’s, but we may answer in a limited way because we want to assess your

請加QQ：99515681 或郵箱：99515681@qq.com   WX：codehelp