The goals for this lab assignment are:

Work through the following sections and ask if you have questions!

To generate the first list, write a function make_answers(items). The input parameter items is a list of strings, representing the set of strings/emojis that you wish to match. Each string in items is unique and you need to create a matching pair for each item in items.

You can create a new list of strings by concatenating two lists of strings using the + sign. Note that concatenating two lists of strings generates a new list of strings, not one big string.

Once you have created your list of pairs, you can shuffle it once using the shuffle() function from the random library.

To use shuffle, place the line

at the top of your program, outside the definition of main. To shuffle a list lst, use the syntax shuffle(lst). The shuffle function does not return a new list. Instead, it rearranges and modifies the contents of lst

After making your shuffled list of pairs, return this new list of pairs. Test your make_answers function in main, by calling the function, saving the returned result as a variable and printing the result. Do not continue with the next step until make_answers is working as described. Your function should work with any size list of items, not just the sample list provided in main().

Write a function make_status(answers) that creates and returns an initially blank board to display to the user. The answers parameter is a list of strings, typically created by make_answers and stored in main(). You should not modify the answers list directly. Instead, create a list of ?? strings that is of the same length as the parameter answers and return the newly created list. Recall from above that you can use list concatenation and that ["??"] + ["??"] creates a new list ["??", "??"]. You can also use lst.append("??") multiple times on an initially empty list.

Again, test your make_status function in main() and save the result as a second variable distinct from the answers list.

For your third function, write the function show_status(status) that doesn’t return anything, but prints a display of the current game status. Your function should print the numeric index for each card position in the game and then the current status ?? or a previously matched card after a match has been made. You can test this function in main on both the status list and the answer list. They should print the following:

show_status(status), where status is the current status board, initially blank

show_status(answers), where answers is the initial shuffled set of cards

Your implementation just needs to print two strings. You can use the string accumulator pattern twice to create these strings. First, create a string representing the positions of items in the list. Second, create a string representing the concatenation of the items in the list. You may need to add some spaces in between to get the two rows to line up a little, but the alignment does not need to be perfect.

Before proceeding, ensure that all three functions above are working correctly. Your main` function should have:

You can keep the printing of the answer key in your main function as you continue to develop and test your program. In the real game though, the answer key should not be shown to the user when starting the game.

We provide a is_a_number(txt) in the f23_memory module.

This function has one input parameter, txt, which is a string type. The is_a_number function will return a Boolean value True if there is at least one character in the string, and all the characters in the string txt are digits between 0 and 9`inclusive. Otherwise, the function should return `False.

You will use is_a_number to help get a valid choice as outlined below.

Write a function is_valid(choice, status). This function has two parameters: an string choice and a list of the current board status, status. The function is_valid should return a Boolean True or False. Return True if all of the following conditions are met.

If the current board is as shown below

then the return value of is_valid should be as follows

You should use is_a_number to check if choice is a number before trying to convert it to an int.

Don’t assume that status is always of length 12. Again, try a few tests calls to is_valid in main before continuing.

With is_valid complete, you can now implement get_choice(status). This function takes a list of strings status representing the current game board as input, prompts the user to pick a valid choice, and returns the integer index of the valid choice once the user has picked an appropriate index. You should use is_valid to check if a user response is acceptable. If not, repeatedly prompt the user for a valid choice. Don’t forget to convert a valid response from a string to an integer before returning from get_choice.

In main, make a single call to get_choice and print the returned result. Ensure that get_choice and is_valid are working properly before proceeding. Note you do not need to check is_valid directly in main since get_choice should be calling is_valid.

When a user picks a new card to reveal, you should update the current status list to revel the last picked card. Write a function flip_card(answers, status, n) that can flip a card at an integer position n. The list answers is the list of shuffled strings representing the complete answer key. The list status is the current status, containing a mix of matched pairs and unknown ?? positions. The function flip_card should update the status list at position n to either be revealed or hidden.

If the current board is as shown below

Then flip_card(answers, status, 2) would change the ?? in position 2 to the corresponding answer at position 2, e.g.,

A call to flip_card should modify the list status, but not the list answers. Calling flip_card(answers, status, 2) again after the 🍉 is revealed will hide the status, reverting the status list back to

Because input validation will happen before any call to flip_card, this function can assume that answers and status are the same length, and n is a valid integer index.

Once your game is complete, you can add a call to clear_screen() before taking a turn. The clear_screen function will clear the screen, preventing you from scrolling back and seeing previous turns. This makes the game more interesting, and requires you to rely on your memory. To pause the game at the end of one turn and the beginning of the next, you can use an input statement to prompt the user to press enter to continue, e.g.,

Omitting the clear_screen during your initial development can make it easier to design and debug your solution.

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.

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!