Write a function called `add` that takes two `int` parameters and returns their sum,
but the second argument is optional and defaults to 0.

Add Default Argument

Write a function called `add_one` that takes a single `int` argument and returns the result of adding 1 to it.

Add One

Write a function called `add_or_subtract` that takes three parameters:
a number for the left side, a number for the right side, and a bool that specifies whether to subtract.
If the bool is true, return the left number minus the right number.
Otherwise, return the left number *plus* the right number.

Add Or Subtract

The Collatz conjecture proposes that the below process will reach 1 regardless of the starting number:

* If the current number is even, divide it by 2.
* Otherwise, multiply the current number by 3 and add 1.

For example, starting with 5, it takes five steps to reach 1:

* 5 is odd, so multiply it by 3 and add 1 to get 16.
* 16 is even, so divide it by 2 to get 8.
* 8 is even, so divide it by 2 to get 4.
* 4 is even, so divide it by 2 to get 2.
* 2 is even, so divide it by 2 to get 1.

Write a function `collatz` that takes an `int` parameter and returns how many steps of the Collatz process
are required to get from it to 1. Assume that the parameter is always positive.

Collatz

Write a class called `Counter` whose initializer takes an `int` parameter and assigns it to an instance field called `count`.
Also give the `Counter` class an instance method called `increment` that increases the `count` field by 1 but does not return anything.

Counter Class

Write a function called `equals255` that takes a number and returns whether it is equal to 255.

Equals 255

Let's call a string *excited* if it contains more exclamation points than periods.
For example, "Great work!" is excited but "I see. OK!" is not.
Write a function called `excited` that takes one `str` and returns whether that string is excited.

Excited Strings

Modify the code below so that it prints "Go beyond grading!"

Go Beyond Grading

Write a print statement to print "Hello, *[name]*!" where *[name]* is the value of the `name` variable,
which has already been set for you. For example, if `name` is "Grace", you would print "Hello, Grace!"

Greet Statement

Write a function called `how_many_bigger` that takes two parameters: a list of numbers and an individual number.
It returns how many numbers in the list are strictly larger than the individual number.

How Many Bigger

Write a function called `min_max` that takes a list of numbers.
It returns a tuple of the list's minimum value and maximum value, in that order.
(You are encouraged to use built-in Python functions to find the extreme values!)
If the list is empty, return `None` rather than a tuple.

Min Max Tuple

The classic Fibonacci sequence starts with 0 and 1, after which each term is the sum of the previous two.
Let's generalize this to the *N*-bonacci sequence, where the first *N* terms are 0, 1, ..., *N* - 1
and each later term is the sum of the *N* previous terms.

Write a function called `nbonacci` which takes two `int` parameters, *N* and the zero-based term index.
*N* will always be positive and the term index will always be nonnegative.

For example, `nbonacci(2, 4)` should return 3 because the 2-bonacci sequence
(which is the classic Fibonacci sequence) begins 0, 1, (0 + 1) = 1, (1 + 1) = 2, (1 + 2) = **3**. 
`nbonacci(3, 5)` should return 11 because the 3-bonacci sequence begins 0, 1, 2, (0 + 1 + 2) = 3, (1 + 2 + 3) = 6, (2 + 3 + 6) = 11.

N-bonacci

Write a function called `on_axis` that takes two `int` parameters for the X and Y coordinates of a point.
It returns whether the point is on either the X axis or the Y axis, *but not* at the origin.
That is, exactly one of the coordinates must be zero.

On Axis

Write a function called `print_every_other` that takes a list of strings and prints every other entry,
starting with the first, on its own line. For example, given `['A', 'B', 'C']`, you would print "A" and "C".

Print Every Other

Write a function called `print_smallest` which takes three numbers and prints the smallest one.
You can use a built-in Python function to help you find the smallest of the numbers!

Print Smallest

Write a function called `sort_colors` that takes a list of strings and returns a new list of those strings,
sorted in rainbow order: first `red`, then `orange`, `yellow`, `green`, `blue`, and finally `purple`.

If an item in the list is not one of those six colors (case-sensitive), raise a `ValueError`.
Note that the input may contain duplicate colors and you should preserve them.
For example, given `['blue', 'red', 'blue']`, you would return `['red', 'blue', 'blue']`.

Sort Colors

Write a function called `space` that takes one string parameter and returns the result of
adding a space between each pair of characters in the original string.
Note that you should not add a space at the beginning or end.
For example, given "space" you would return "s p a c e".

String Space

Write a function named `make_subtractor` that takes one `int`, the *minuend*.
It should return *another function* that takes one `int`, the *subtrahend*,
and returns the result of subtracting the minuend from the subtrahend.

Note that calling `make_subtractor` again must not change the behavior of functions it previously returned.

Subtractor Function Factory

Write a function called `print_many` that accepts any number of `str` arguments and prints each on its own line.

Variable Arguments Print

Write a function called `wavy` that takes one `str` parameter and returns that string converted to *wavy case*.
In wavy case, characters alternate between lowercase and uppercase, with the first letter being lowercase.
You can assume that the input string contains only English letters.