12.9. Chapter Exercises

The code below is supposed to roll an 8 sided die (sides numbered 1-8) 10000 times and after it is done, print out how many times 1 was rolled.

Move the correct blocks from the left to the right and indent them properly. You will not need to use all of the blocks. Make sure to put import random first.

        import random
---
numberOfOnes = 0
---
for roll in range(10000):
---
    randValue = random.randrange(1, 9)
---
    randValue = random.randrange(1, 8) #paired
---
    randValue = random.randrange(0, 8) #paired
---
    randValue = random.randrange(0, 9) #paired
---
    if randValue == 1:
---
        numberOfOnes = numberOfOnes + 1
---
print(numberOfOnes)
        

The code below is supposed to “flip a coin” 100 times by making a random number that is 0 (heads) or 1 (tails) and keep track of the longest streak of heads that we see. It will do so by first updating the headsInARow counter (like the sample from the Building a Simulation page). If the headsInARow increased (but not if it was reset to 0), we will check and see if it is bigger than longestStreak. If so, we will update the longestStreak to match headsInARow. After all 100 flips are done we will print out the longestStreak.

Move the correct blocks from the left to the right and indent them properly. You will use all of the blocks. Make sure to put import random first.

        import random
---
headsInARow = 0
longestStreak = 0
---
for i in range(100):
---
    flip = random.randrange(0, 2)
---
    if flip == 0: #got a heads
---
        headsInARow = headsInARow + 1
---
        if headsInARow > longestStreak:
---
            longestStreak = headsInARow
---
    else: #got a tails
---
        headsInARow = 0
---
print(longestStreak)
        

Using the code below, write a program that simulates rolling a pair of six-sided dice (1-6) 10000 times and counting up the number of times that an eight is rolled (the two dice add to 8).

Make sure to generate two separate numbers between 1-6 for each roll. Then add those two numbers up and if they make eight, increment the numEights counter.

If you have troubles, try reducing the range to something like 10 or 20 rolls and printing out what you roll for each of the dice and the total them make.

Warning There is no autograder for this problem. It is up to you to decide if your program is working. For 10000 trials you should usually get an answer between 1300 and 1500. You may occasionally get a result outside that range if you are really unlucky or really lucky.

import random numEights = 0 # While testing, you may want to change this loop to only to 10 trials # To pass tests make sure to do 10000 trials and do not print anything inside the loop for roll in range(10000): # YOUR CODE HERE # Make two random numbers 1-6 (optionally, print them out to make sure code works) # If they add to 8, add one to numEights # Optionally, print numEights out to see the change # print number of eights rolled when loop is done print("Number of eights was", numEights)

A friend of yours likes a game that involves rolling dice to create their characters.

Finish the program below to simulate rolling three dice (with sides 1-6) 6 different times and keeping track of the highest total that you saw.

For example: Roll 1, 3, 5 - total is 9. The highest roll so far is now 9 Roll 4, 6, 3 - total is 13. The highest roll so far is now 3 Roll 2, 1, 5 - total is 8. The highest roll so far is still 13 Roll 6, 5, 5 - total is 16. The highest roll so far is now 16 Roll 3, 2, 5 - total is 10. The highest roll so far is still 16 Roll 4, 4, 3 - total is 11. The highest roll so far is still 16

Warning There is no autograder for this problem. It is up to you to decide if your program is working.

import random highestRoll = 0 for roll in range(6): # YOUR CODE HERE # Make three random numbers that are 1-6 (optionally, print them out to make sure code works) # Total them up # If the total is more than the highestRoll, change highestRoll to match the total # Optionally, print highestRoll to see if it looks correct # print the highest roll when done with loop print("highestRoll was", highestRoll)

This program currently makes a pink dot that is 50 pixels across and is centered at 0, 0.

Modify the program so that the size of the dot is a random value between 50 and 200 and the location it draws it is a random location where both x and y are random numbers between -100 and 100.

The automatic tests will make sure you generate appropriate values, but it won’t necessarily verify you used the random numbers you make in the correct spots. You are responsible for checking that yourself!

Turtle procedures

from turtle import * import random drew = Turtle() drew.shape("circle") #set starting location drew.penup() drew.goto(0, 0) drew.pendown() #set up the color and size drew.pensize(50) drew.color("#ffc8c8") #draw the dot drew.forward(0) ===== from unittest.gui import TestCaseGui class myTests(TestCaseGui): def testOne(self): self.assertRegex(self.getEditorText(), r"random.randrange\(\s*-100,\s*10[01]\s*\)", "Testing that you make a random number between -100 and 100.") self.assertRegex(self.getEditorText(), r"random.randrange\(\s*50,\s*20[01]\s*\)", "Testing that you make a random number between 50 and 200.") myTests().main()

Challenge.

Finish the function getOddsFor. It should determine the odds of rolling targetNumber when rolling two six-sided dice (1-6). It should do so by using a loop to repeat TRIALS number of times rolling two dice and seeing how many times targetNumber is the total of the two dice. Then return that number divided by TRIALS.

This is very similar to exercise 3 above… Just make sure to check if the total you “roll” is the same as the targetNumber as opposed to always checking against 8.

Make sure to return your answer from the function, don’t print it in the function!

import random def getOddsFor(targetNumber): # matches will hold the number of times you "roll" the targetNumber matches = 0 # TODO # 10000 times: # make two random numbers 1-6 # if they add to targetNumber, increase matches by 1 # calculate and return percent of time roll matched targetNumber return matches / 10000 # main program print("Testing 8's, expect 0.13889", getOddsFor(8)) print("Testing 5's, expect 0.1111", getOddsFor(5)) print("Testing 12's, expect 0.0277", getOddsFor(12)) ===== from unittest.gui import TestCaseGui class myTests(TestCaseGui): def testOne(self): self.assertAlmostEqual(getOddsFor(8), 0.13888, 2, "Testing that you got about the right answer for 8.") self.assertAlmostEqual(getOddsFor(5), 0.11111, 2, "Testing that you got about the right answer for 5.") self.assertAlmostEqual(getOddsFor(12), 0.02777, 2, "Testing that you got about the right answer for 12.") myTests().main()

You have attempted of activities on this page