* Use the two rhyming programs (`rhymer` and `soundex_rhymer`) to create a list of words that sound similar that you use for the input to `gibberish.py` to create novel words that (might) sound like the inputs, then use those to create Suess-ish texts.

* Tackel the "Markov Chain" problem where you work at the level of words to generates novel texts.

1. Number (1, 2, 3)

2. Color (Red, Green, Purple)

3. Shading (Solid, Striped, Putlined)

4. Shape (Oval, Squiggle, Diamond)

There are dozens of ways you could chose to solve this, but, in order to pass the test suite, we will have to do a couple of things the same way. For one, we both need to use the same method to sort and shuffle our decks and then select the 12 cards.

To create the deck, you could manually enter all 81 cards, but that way lies madness. I suggest you use `itertools.product` to cross four lists, one for each of the numbered attributes above and each containing their the three values. This returns a `list` of `tuple` values, which seems like a perfect way to model the cards:

However you chose to represent each card, the `list` of cards should be sorted for number color, shading, and shape. Consider making a function called `make_deck` that will create the deck and return it sorted properly. Then add something like this function to run with `pytest`. That is, I chose to use tuples for each card, so I'm checking that the first and last values in the `deck` are my expected tuples:

Think about how you might decide if any three of cards forms a set. I would suggest thinking backwards from this test function which I suggest you include in your program:

````

If you represent your cards as strings, dictionaries, sets, or some other object, you should modify the test to reflect your design decisisons. Still, the ideas are the same. The first test assumes that I pass in 3 identical structures have the same 4 elements, `A`, `B`, `C`, and `D`. That should be a set. In the second test, all 3 structures are entirely different, so that's a set. In the third, the fourth element of the last structure is composed of the values `D`, `D`, and `E`, so that's not a set. Can you write the function `is_set` that will return a `bool` that indicates whether or not the list is a set?

Once you have that function job, you need to examine all possible combinations of 3 cards. I suggest you use `itertools.combinations` for this. Then you can `filter` the combinations for those where `is_set` is `True`.

Print out each set of cards with "Set N" and then the three cards in the set each on a new line. The test suite doesn't card what order the sets are printed, but the cards need to be `sorted`.

There's very little to see in `get_args`, just defining the `-s|--seed` and `-d|--debug` options, the former of which gets passed to `random.seed`. As in many other programs, I set up `logging.basicConfig` to log to a `filename='.log'` (so it will normally be hidden from view) using `filemode='w'` (so it will be overwritten each time it runs), and setting the `level` either to `logging.DEBUG` or `logging.CRITICAL` depending on the presence of the `--debug` flag.

As stated in the introduction, I chose to use the list of tuples returned from `itertools.product`. I also have chosen to include some type annotations by bringing in the `typing` module. This allows me to use the `mypy` tool to check for common errors. It also helps me think about the inputs and return values for my functions. The function `make_deck` has no inputs and returns a list of tuples:

As expected, I get 81 cards from the function. I can use the `test_make_deck` function to do a little more probing.

The next function I tackled was `is_set` that takes 3 cards and looks at the 4 attributes. The order of the attributes is actually not important for this function. That is, we don't care that "number" is first, we only care that all the first elements are exactly the same or entirely different. The data structure that comes to my mind is, not surprisingly, a `set`. If all the elements of the `set` are the same, then the length of the set will be `1`; if they are entirely different, then the length will be `3`.

I can use the `zip` function to group all the first elements together, then all the second elements, and so forth.

And then I want to apple the `set` function to each element in that `list`, so I can use `map`:

These cards do comprise a "set" if the `len` of `all` of the `sets` are either `1` or `3`:

We can put this into a function:

And then test it:

With those functions in place, we can make a deck of cards, shuffle them, randomly sample 12 cards, and then select only those where `is_set` is `True`:

If you copy and paste this code, keep in mind that the `filter` function returns a `filter` *object* which is *lazy*, so if you use, for example, `list` to force the REPL to evaluate and print the filtered sets, you will have exhausted the generation of the results. You can assign `sets` to `list(filter(...))` to get something you can `print` and get the `len` and iterate repeatedly.

Keep in mind that `sets` is a `list` of the 3-tuples of cards that form sets. We still need to iterate over the `sets` and print them out with the cards `sorted`:

I will confess that my first solution was considerably more complicated involving a custom `class` to represent a `Card` and using one-hot encoding and bit-wise addition to find sets. After writing that version and then sleeping on it, I was moved to create a far simpler solution, in part because of these ideas:

A big leap was in thinking of sets as `ABCD` rather than `3 Purple Outlined Squiggle` and then realizing that the `list(tuple)` structure returned by `itertools.product` was the simplest data structure that solved 90% of my design. My first implementation was about 1/3 longer than this final version which I think reads considerably better.

from dataclasses import dataclass

class Pet:

name: str

age: int

print(Pet('Patch', 5))

print(Pet(5, 'Patch'))

from typing import List, Tuple

def make_deck() -> List[Tuple[str, str, str, str]]:

numbers = ('1', '2', '3')

colors = ('Red', 'Purple', 'Green')

shadings = ('Solid', 'Striped', 'Outlined')

shapes = ('Oval', 'Squiggle', 'Diamond')

return sorted(product(numbers, colors, shadings, shapes))

assert deck[0] == ('1', 'Green', 'Outlined', 'Diamond')

assert deck[-1] == ('3', 'Red', 'Striped', 'Squiggle')

def is_set(cards: List[tuple]) -> bool:

sets = map(set, zip(*cards))

return all([len(s) in [1, 3] for s in sets])

assert is_set([tuple('ABCD'), tuple('ABCD'), tuple('ABCD')])

assert is_set([tuple('ABCD'), tuple('EFGH'), tuple('IJKL')])

assert not is_set([tuple('ABCD'), tuple('ABCD'), tuple('ABCE')])

assert is_set([('1', 'Green', 'Outlined', 'Diamond', '1'),

('Green', 'Outlined', 'Squiggle'),

('1', 'Green', 'Outlined', 'Oval')])

assert is_set([('1', 'Green', 'Outlined', 'Diamond'),

('2', 'Red', 'Striped', 'Squiggle'),

('3', 'Purple', 'Solid', 'Oval')])

assert not is_set([('1', 'Green', 'Outlined', 'Diamond'),

('2', 'Red', 'Striped', 'Squiggle'),

('3', 'Green', 'Solid', 'Oval')])

print('\n'.join(sorted(map(' '.join, combo))))