1. **article**: Choose the correct article for a given word.

2. **jump_the_five**: Encode all numbers in a given text using a Jump-The-Five algorithm.

3. **picnic**: Manipulate strings and lists based on the number of items present.

4. **wc**: Write a program to count the lines, words, and characters in text.

5. **howler**: Convert all input text to uppercase.

6. **apples_and_bananas**: Substitute vowels in text.

7. **telephone**: Introduce mutations in a string over a given number of iterations.

8. **bottles_of_beer**: Write the "99 Bottles of Beer On The Wall" song.

9. **gashlycrumb**: Retreive a line of text from a file by the first letter.

10. **ransom_note**: Randomly alternate the case of input text to simulate a ransom note.

11. **rhymer**: Substitute alternate consonant prefixes onto a stem to find rhyming "words."

12. **rock_paper_scissors**: Write the "Rock, Paper, Scissors" game.

13. **abuse**: Creating insults by randomly choosing from lists of words.

14. **scrambler**: Randomly shuffle the middle letters of every word in a text leaving the first and last letters in place.

15. **bacronym**: Use dictionaries to organize words by first letter, then randomly choose words to create "meanings" for a given acronym.

16. **wod**: Generate a Workout-Of-the-Day (WOD) from a list of possible exercises.

17. **blackjack**: An abbreviated version of the card game "Blackjack" (AKA "Twenty-One").

18. **family_tree**: Parse a text file containing the description of family trees, visualize the resulting graphs using GraphViz.

19. **gematria**: Numerically encode each word of text by summing the ordinal values of the characters.

20. **histy**: Create a textual histogram showing the frequency of letters in text.

21. **mommys_little_helper**: Find words matching a given pattern to help solve a crossword puzzle. Explores manually finding words and using regular expressions.

22. **kentucky_friar**: Drop the "g" from two-syllable words ending in "-ing"; convert "you" to "y'all."

23. **mad_libs**: Create an interative terminal version of "Mad Libs." Hilarity is sure to ensue.

24. **license_plates**: Find all possible permutations of a licence plate given a confusion matrix. Explore how and verify that regular expressions work.

25. **gibberish**: Use a Markov chain to create new words from a set of training files.

26. **piggy**: Encode text using the Pig Latin algorithm.

27. **soundex_rhymer**: Using the Soundex function to find words ending with a given sound.

28. **tictactoe**: Play a round of Tic-Tac-Toe.

29. **twelve_days_of_christmas**: Write a program that will print the "Twelve Days of Christmas" song up to a given day.

30. **anagram**: Finding anagrams of words.

31. **hangman**: Write an interactive terminal game where the user guesses a word.

32. **first_bank_of_change**: Find all possible combinations of pennies, nickels, dimes, and quarters for an amount between 1 and 100.

33. **pareto**: Model how random events of zero-sum encounters led to inequitable distributions.

34. **runny_babbit**: Introduce Spoonerisms into text by switching the initial consonant sounds of neighboring words.

35. **markov_chain**: Use the Markov chain algorithm to generate novel texts based on training sets.

36. **hamming_chain**: Find paths through words that are separated by a given Hamming distance.

37. **morse**: Encrypt and decrypt text to and from two versions of Morse code.

38. **rot13**: Encode and decode text by rotating the characters through a list.

39. **word_search**: Find all the words hidden in the rows, columns, and diagonals in a block of text.

40. **set**: Find "set" of cards from a deck of 81 where each of 4 attributes can have each of 3 values and a "set" of 3 cards is either the same or entirely different for each of the 4 attributes.

41. **scrabble**: Find all possible words you could make from a random set of seven characters.

I won't necessarily show you beforehand how to write each program. I'll describe what the program should do and provide some discussion about how to write it. I'll also create an appendix with short examples of how to do things like how to use `argparse`, how to read/write from/to a file, how to process all the files in a directory, how to extract k-mers from a string, etc. I'll provide some building blocks, but I want you to figure out how to put the pieces together.

I provide some useful programs in the `bin` directory including one called `new.py` that will help you stub out new Python programs using the `argparse` module to parse the command line arguments and options for your programs. I recommend you start every new program with this program. For example, in the `article` directory the `README.md` wants you to create a program called `article.py`. You should do this:

This will create a new file called `article.py` (that has been made executable with `chmod +x`, if your operating system supports that) that has example code for you to start writing your program.

Your `$PATH` is a list of directories where your operating system will look for programs. To see what your `$PATH` looks like, do:

Probably each directory is separated by a colon (`:`). *The order of the directories matters!* For instance, it's common to have more than one version of Python installed. When you type `python` on the command line, the directories in your `$PATH` are searched in order, and the first `python` found is the one that is used (and it's probably Python version 2!)

You could execute `new.py` by giving the full path to the program, e.g., `$HOME/work/playful_python/bin/new.py`, but that's really tedious. It's best to put `new.py` into one of the directories that is already in your `$PATH` like maybe `/usr/local/bin`. The problem is that you probably need administrator privileges to write to most of the directories that are in your `$PATH`. If you are working on your laptop, this is probably not a problem, but if you are on a shared system, you probably won't be able to copy the program into your `$PATH` directories.

An alternative is to alter your `$PATH` to include the directory where `new.py` is located. E.g., if `new.py` is in `$HOME/work/playful_python/bin/`, then add this directory to your `$PATH` -- probably by editing `.bashrc` or `.bash_profile` located in your `$HOME` directory (if you use `bash`). See the documentation for your shell of choice to understand how to edit and persist your `$PATH`.

For what it's worth, I always create a `$HOME/.local` directory for local installations of software I need, so I add `$HOME/.local/bin` to my `$PATH`. Then I copy programs like `new.py` there and they are available to me anywhere on the system.

Once you have stubbed out your new program, open it in your favorite editor and change the example arguments in `get_args` to suit the needs of your app, then add your code to `main` to accomplish the task described in the README. To run the test suite using `make`, you can type `make test` in the same directory as the `test.py` and `article.py` program. If your system does not have `make` or you just don't want to use it, type `pytest -v test.py`.

Your goal is to pass all the tests. The tests are written in an order designed to guide you in how break the problem down, e.g., often a test will ask you to alter one bit of text from the command line, and this it will ask you to read and alter the text from a file. I would suggest you solve the tests in order. The `make test` target in every Makefile executes `pytest -xv test.py` where the `-x` flag will have `pytest` halt testing after it finds one that fails. There's no point in running every test when one fails, so I think this is less frustrating that seeing perhaps hundreds of lines of failing tests shoot by.

A fair number of the program rely on a dictionary of English words. To be sure that you can reproduce my results, I include a copy of mine in `inputs/words.zip`.

assert os.path.isfile(solution_py)

print('\tSOLUTION')

fh.write('## Solution\n\n')

fh.write('````\n')

numbered = getoutput('cat -n {}'.format(solution_py))

fh.write(numbered)

#fh.write(open(solution_py).read())

fh.write('\n````\n')

fh.write('\n\\newpage\n\n')

if appendix:

for i, dir_name in enumerate(map(str.rstrip, open(appendix)), 1):

print('Appendix {}: {}'.format(i, dir_name))

readme = os.path.join(in_dir, 'appendix', dir_name, 'README.md')

if os.path.isfile(readme):

print('\tREADME')

header = 'Appendix {}: '.format(i)

text = open(readme).read()

text = re.sub(r'^#\s+', '# ' + header, text)

fh.write(text + '\n\\newpage\n\n')