As you write programs, use good programming practices:

All functions should have a top-level comment! Please see our function example page if you are confused about writing function comments.

Make sure all programs are saved to your cs21/labs/05 directory! Files outside that directory will not be graded.

The goals for this lab assignment are:

As a first step, in getnumbetween.py you will implement a function named getNumBetween(low, high) that takes two int values represented the low and the high ends of a range of values (inclusive), and returns a value entered by the user that is between that range.

Your function should prompt the user to enter a value between low and high (inclusive) and only return the value entered by the user if it is in the range. If the user enters an invalid value, your function should print out an error message and ask the user to try again until they enter a valid value. It is okay for this lab if your function assumes the user at least enters a valid numeric value. For example, if the user enters hello it is okay if your function doesn’t handle this case and crashes.

Then add a main program, that calls your getNumBetween(low, high) function and prints out the result. Call your function twice from main, passing different values for low and high. For example (and you can use exactly these two calls to getNumBetween in your main function):

Your function does not need to check that the value of the low parameter is less than or equal to the value of the high parameter; you may assume the caller passes values high and low range values that make sense, as in the example calls from main shown above.

Here is an example run from our program (user entered values are in bold):

You should test that your function does the right thing for values in the middle of the range, the ends of the range, and outside the range. You can add more calls to it from main and/or pass different high and low argument values to getNumBetween in main to test.

Run handin21 to submit this part before starting on Part 2.

For this part, you will start with a copy of your getnumbetween.py solution and add more functionality to implement the Five-Six-Seven game in the file fivesixseven.py.

First, let’s copy your getnumbetween.py solution into the fivesixseven.py file to start. There are many ways to do this, but let’s do it in vim:

This will copy the entire contents of the getnumbetween.py file into fivesixseven.py. After this, edit the top-level comment for the Five-Six-Seven game, and you are ready to add more game playing functions.

Then follow these steps, to incrementally add functionality and test as you go:

First, add a function named printWelcome that is passed a string value, which is the player’s name, and prints out a welcome message and the rules of the Five-Six-Seven game (see our sample output as an example.

In the main function prompt the user to enter their name, then call your printWelcome function. You should remove the other code in main that was part of the getnumbetween.py program’s main function.

Here is an example of what a call to your complete program might look like now:

Note that the output from the call to the printWelcome function starts with the line Hi …​.

Next, add a function that will ultimately be called at the end of game. Write a function named printResults with three parameters:

This function should print out a message that includes:

Add some calls to your printResults function from main to test it out. Here is some example output from a program that includes two calls to printResults (printResults(5, 10, name) and printResults(7, 15, name))

After testing and debugging your function, you can remove or comment out the test calls you made in main. This is also a good time to run handin21 to submit what you have so far.

Next, add a function named PlayOneRound that takes the user’s name plays one round of the game 5-6-7, and returns 1 if the user wins the round, and 0 if the computer wins. This is a function that has a few steps, namely:

To test your function, add a call to your PlayOneRound in main and add a debug print statement to print out the value it returns. Run your program a few times to test your function. Make sure the user and the computer choose valid choices, and make sure your function returns the correct value when one or the other wins the round. You may want to put a call to your function and printing out its return value inside a for loop in main to easily test out some repeated calls.

Here is output from a couple calls to the PlayOneRound function might look like when run (note we are only showing program output from this function):

After testing and debugging this function, remove (or comment out) these calls and debug print output from main. This is another good time to run handin21 to submit your work so far.

Next, complete the full game program in main. You may have some debug code in main that you will need to remove.

Here are the main steps:

Here is sample output from a complete program: Sample Output

Remember to run handin21 to turn in your lab files! You may run handin21 as many times as you want. Each time it will turn in any new work. We recommend running handin21 after you complete each program or after you complete significant work on any one program.

When you’re done working in the lab, you should log out of the computer you’re using.

When you are ssh’ed into the CS labs, first quit any applications you are running, like vim, then simply type exit at the prompt in your terminal window to disconnect.

When you are in a CS lab logged into a CS machine. First quit any applications you are running, like the browser and the terminal. Then click on the logout icon ( or ) and choose "log out".

If you plan to leave the lab for just a few minutes, you do not need to log out. It is, however, a good idea to lock your machine while you are gone. You can lock your screen by clicking on the lock icon. PLEASE do not leave a session locked for a long period of time. Power may go out, someone might reboot the machine, etc. You don’t want to lose any work!