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 `tree_sum` that takes a `binarytree.BinaryTree` of `int`s and returns the sum
of all the `value` properties of the nodes in the tree.
You can access child nodes via the `left` and `right` properties.

Tree Sum

Write a function called `tree_right_bigger` that takes a `binarytree.BinaryTree` of `int`s and returns
the number of nodes in the tree that have both a `left` and a `right` child where the right's value
is larger than the left's.

Tree Right Bigger

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.

Wavy String

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 `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 `count_even` that accepts one list of integers and returns how many
of those integers are even.

Count Even

Write a function called `has_doubled_character` that takes one string and returns whether the
string has (at least) two of the same character in a row.
For example, "free" has two "e" characters in a row, but "eve" does not.

Doubled Character

Write a function called `remove_odd_values` that takes a dictionary of strings to integers
and removes all the entries that have odd values. It should modify the passed dict, not return anything.

Remove Odd Values

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

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 `add_dictionaries` that takes two dictionaries with string keys and int values.
It should return the result of combining the dictionaries, adding the int values together if both
dictionaries have an entry with the same key.
Do not modify either dictionary passed to the function.
For example, given `{'a': 1, 'b': 5}` and `{'a': 3, 'c': 6}`, you would return `{'a': 4, 'b': 5, 'c': 6}`.
Notice how the 1 and 3 values for `'a'` were added together to produce 4.

Add Dictionaries

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

Assume an int variable called `number` has been declared for you.
Print how many of `number`'s digits are odd (when written in base 10 as usual).
For example, if the number is 32, you would print 1 because only one digit (the 3) is odd.
Note that the number may be negative.

Odd Digits

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

Equals 255

Software versions are often written as two numbers - major and minor revision - separated by a dot.
A version with a larger major revision is always higher than a version with a lower major revision.
For example, version 6.1 is higher than version 5.3 because 6 is larger than 5.
Within the same major revision, a larger minor revision indicates a higher version.
For example, version 2.11 is higher than version 2.5 because 11 is larger than 5.

Write a function called `compare_versions` that takes two of these version number strings,
returning 1 if the second version is higher than the first, -1 if the first is higher, and 0 if they are the same.
For example, given `5.3` and `6.1` you would return 1 because 6.1 is a higher version.
You may assume that both strings are in this format.

Compare Version Numbers

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

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 named `largest_adjacent_difference` that accepts a list of integers
and returns the largest difference between any two adjacent elements. For example, given `[4, 5, 2]`
you would return 3 because the difference of 3 (between 5 and 2) is bigger than the difference of 1 (between 4 and 5).

If the list has fewer than 2 elements, return zero.

Largest Adjacent Difference

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.
(This implies that the function's return type is not just a `tuple`.)

Min Max Tuple

"It is like the thirteenth stroke of a crazy clock, which not only is itself discredited
but casts a shade of doubt over all previous assertions." -A. P. Herbert

Write a class called `Clock` with two methods, `chime` and `is_crazy`.
`is_crazy` should return whether `chime` has been called more than 12 times.

Crazy Clock

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

Go Beyond Grading

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

Assume two string variables named `ruler` and `text` have been set for you.
First print `ruler` on its own line.
Then print only as much of `text` as needed to match the length of `ruler`.
If `ruler` is longer than `text`, print extra dots after `text` to match `ruler`'s length.

Print to Same Length

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 named `reverse_complement` that accepts a single string parameter representing a
sequence of DNA bases and returns its reverse complement. The reverse complement is obtained by
changing each base (letter) to its complement and reversing the sequence. A and T are each others'
complements; G and C are complements.

Given the string "A", you would return "T" because T is the complement of A.
Given "AG", you would return "CT" because T is the complement of A, C is the complement of G,
and reversing "TC" produces "CT".

You may assume that the input string contains only capital A, C, G, and T characters.

Reverse Complement

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

Chess pieces are often considered to have a point value for roughly evaluating a position.
Write a function called `material_count` that takes a single string representing all the pieces
a player has (one character per piece) and returns their total material count.
The pieces with a point value are:

* `P` (pawn): 1 point
* `B` (bishop): 3 points
* `N` (knight): 3 points
* `R` (rook): 5 points
* `Q` (queen): 9 points

You may assume that there are no other letters in the string.

For example, given `PNR` you would return 9: 1 from the pawn, 3 from the knight, and 5 from the rook.

Chess Material

Write a function named `is_chessboard_square` that accepts a single string argument and returns
whether that string is the name of a valid chessboard square.
Chessboard squares are exactly two characters long: first a lowercase letter between `a` and `h`,
then a number between `1` and `8`.
For example, "e4" is a valid square, but "i1" (invalid letter) and "f9" (too large number) are not.

You may find it helpful to use the `<` and `>` operators to compare strings.

Chessboard Squares

Write a class named `Accumulator` with a method named `add`.
`add` takes a list of integers and returns the sum of all numbers in the list and lists previously passed to the same `Accumulator`.

List Sum Accumulator

Create a class named `FlipFlop` representing a switch which is initially off.
It should have a method named `flip` that takes no other arguments and only inverts the state of the switch.
When the switch is off, `flip` should turn it on, and vice versa.
`FlipFlop` should also have a method named `is_on` that returns whether the switch is currently on.

Flip Flop Class

Write a function named `between_endpoints` that accepts a list of integers and returns how many of
its entries are *strictly between* the first and the last entry. For example, given `[1, 2, 1, 3]`
you would return 1 because only one entry (2) is between the first and last entries (1 and 3).
Note that the bigger endpoint could either the first or the last entry.
Assume that the list has at least 2 entries.

Between List Endpoints

Write a function named `sum_of_odd` that accepts a list of integers and returns the sum of
only the odd numbers in that list. For example, given `[3, 1, 2, 3]`, you would return 7 (3 + 1 + 3).

Sum of Odd

The Collatz conjecture proposes that the below process will reach 1 regardless of the starting (nonnegative) 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

Camel case is a way of writing phrases without spaces:
turn the first character of each word except the first to uppercase.
For example, "this is a test" is written as "thisIsATest" in camel case.
Write a function named `camel_case` that takes a phrase and return its camel case version.
You may assume that the string contains only lowercase letters and spaces.

Camel Case

Assume that variables `length` and `width` for the dimensions of a rectangle have already been set.
Print the perimeter of the rectangle they describe.

Rectangle Perimeter

Given a string like `ABC`, let's say its *square* is the result of writing it left-to-right
along the top of a square and top-to-bottom along the left of the square, then filling in the
rest of the square with backwards L shapes that connect the top instance of each character with
its corresponding instance on the left. For example, `ABC`'s square is:

```
ABC
BBC
CCC
```

Write a function called `print_square` that takes a (single-line) string and **prints** its square.

Square String

Given a string like "ABC", let's say its *triangle* is the result of printing its
last character on one line, its last two on the next line, and so on until the full length of the string:

```
C
BC
ABC
```

Assume a string variable called `text` has been set for you. Print its triangle.

Triangle String

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

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 class named `Calculator` that keeps track of a running integer total, starting at zero.
It should have three methods: `add`, `multiply`, and `repeat`.
`add` takes an integer and adds it to the running total.
`multiply` also takes an integer, but *multiplies* the running total by it.
`repeat` takes no other parameters, but does the same thing as the *last* `add` or `multiply` call.
If `add` or `multiply` has not been called yet, `repeat` should raise a `ValueError`.
All three methods return the value of the running total after they have done their operation.
The class could be used like this:

```
calc = Calculator()
calc.add(1)       # returns 1  (0 + 1)
calc.add(2)       # returns 3  (1 + 2)
calc.repeat()     # returns 5  (3 + 2)
calc.multiply(3)  # returns 15 (5 * 3)
calc.repeat()     # returns 45 (15 * 3)
```

Repeatable Calculator

Write a function called `character_count` that takes a single string parameter and returns a `dict`
of how many times each character in the string appears.
For example, given "hello" you would return `{'h': 1, 'e': 1, 'l': 2, 'o': 1}`.

Character Count Dictionary

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

Assume a variable named `co2_ppm` has already been set, representing the air's concentration of
carbon dioxide (in parts per million). Based on this value, print a description of the air quality:
"Bad" if the CO2 concentration is *above* 1500 (ppm), "Concerning" if it is *above* 1000 ppm, and "OK"
otherwise.