1. Begin by creating a lab06 folder in your cs108 project if you have not already done so.
2. Create a new python file called text_analysis.py
3. Add appropriate documentation at the top of the file.
4. Copy this definition of a list of strings into your program: GreenEggsAndHam.txt

Verify that your definition is usable by adding code that prints out the total number of words in the list. Mark this test in your file with a comment above the test that says "Exercise 6.1".

The functions we write today are intended to work on lists of strings. Go to the top of your file (above your definition of the green eggs and ham list) and create 3 more lists that will be used for testing your functions. Include an empty list (i.e. [] ), a list of 1 element, and a then a list of 3 or 4 elements. Put a comment above these definitions that indicates these are for Exercise 6.2.

1. Write a function called search that implements the linear search algorithm above to search through a list of words looking for a given target word. Put this function below the definition of the green eggs and ham text. Your function should receive a list of strings and a target string from the calling program and return an index at which it finds the target word or -1 if it doesn't find the target word. Be sure to document your function appropriately. Note that this function does not return the indices of all instances of the target word, but rather just the first.
2. To test that your search function is correct, create a function called test_search that will perform several tests of our search function. This function should not receive any inputs, and then print out the results of our tests.
3. Add a couple tests that call the search function using your test lists (created in exercise 6.2) and targets such that the result should be -1 and where the result should give an index in the list. There should be at least 4 calls to the search function in this test function.
4. To actually run your tests, add a call to the test search function at the very bottom of your file (below the computation of the length of green eggs and ham).
5. Finally, create a function for doing the analysis of Green Eggs and Ham. Name this function green_eggs_and_ham_analysis and put it below your definition of test_search(). It should not receive any arguments, and should print out an index for each of the following words:
   • i
   • boat
   • fox
   • thank
   • book
   Call this analysis function at the bottom of your file, after calling the test function.

1. Write an algorithm for a function called longest_and_shortest that receives a list of words and prints the length of the shortest and the longest word in the list. The function does not return anything. Put your algorithm in your code file as a multi-line comment. When you’re satisfied that your algorithm is correct, implement it directly below your algorithm.
2. When you have an implementation, write a test function that calls the function on each of your test lists. Note:
   • The length of the shortest and longest words should be the same for the list of one word.
   • An empty list should print an error message such as "The given list was empty".
3. Finally, add a call to this function in your green_eggs_and_ham_analysis function.

1. Start by copying this definition of a list of stop words: stopWords.txt. Place this definition below your definition of the Green Eggs and Ham list, but before any function definitions.
2. Write an algorithm for a function called count_words_not_present that counts the number of words in one list that are not found in another list. Your function should receive two lists of words and should return the number of words in the first list that are not in the second list. You do not need to keep track of words that you’ve seen before; if a word in the first list occurs more than once, count it multiple times.
   Make use of the search method you implemented in Exercise 6.3 for this algorithm!!!
   As in Exercise 6.4, put your algorithm in a multi-line comment in your code file. When you are confident in your algorithm, implement it and leave your algorithm in place just above the function definition.
3. When you have an implementation, write a test function that calls the function using each of your test lists. Since the function requires two lists as arguments, you will need to use your lists in combination (you may use the stop words lists as you like). Finally, use this function in your green_eggs_and_ham_analysis function to count the number of words in green eggs and ham that are not stop-words.

Write a function that counts the number of unique words in the text. Consider all the words, including stop words. This problem requires that you keep track of the unique words you’ve seen so far. The following algorithm implements this behavior:

1. Given: a list of strings, called str_list.
2. Set count = 0;
3. Create an empty list called unique_words
4. Loop for all words in str_list
   1. If the current word is not already in uniqueWords then
      1. Add the current word to unique_words.
      2. Increment count by 1.
5. Return count.

Notice a couple things about this algorithm before implementing it:

• It uses a local list of unique words to keep track of what it has seen so far as it works through the list.
• It handles an empty or one-word list gracefully (returning 0).

Implement this algorithm in a function called count_unique_words and create an appropriate test function. Document your function in the standard way (not with the algorithm), and add a call to the analysis of green eggs and ham to verify the number of unique words in the text.