*Due by Midnight on (that is, the end of) Wednesday, 1/25*

**This homework must be submitted online.** See the
instructions for submitting online for how to
do this. Put all your answers to this homework in a file named
<tt>hw1.py</tt>.

**Readings.** All problems in this homework can be solved with the subset of
Python 3 introduced in sections 1.2-1.5 of the lecture notes.

**Q1.** Fill in the
following function definition for adding `a` to the absolute value of `b`,
without calling `abs`:

from operator import add, sub def a_plus_abs_b(a, b): """Return a+abs(b), but without calling abs.""" if ____: op = ____ else: op = ____ return op(a, b)

**Q2.** Write a function that takes three positive numbers and returns the sum
of the squares of the two larger numbers. Use only a single expression for the
body of the function:

def two_of_three(a, b, c): """Return x**2 + y**2, where x and y are the two largest of a, b, c.""" return ____

**Q3.** Let's try to write a function that does the same thing as an `if`
statement:

def if_function(condition, true_result, false_result): """Return true_result if condition is a true value, and false_result otherwise.""" if condition: return true_result else: return false_result

This function actually doesn't do the same thing as an `if` statement in all
cases. To prove this fact, write functions `c`, `t`, and `f` such that
one of these functions returns the number `1`, but the other does not:

def with_if_statement(): if c(): return t() else: return f() def with_if_function(): return if_function(c(), t(), f())

**Q4.** Douglas Hofstadter’s Pulitzer-prize-winning book, *Gödel, Escher, Bach*,
poses the following mathematical puzzle.

- Pick a positive number
`n` - If
`n`is even, divide it by 2. - If
`n`is odd, multipy it by 3 and add 1. - Continue this process until
`n`is 1.

The number `n` will travel up and down but eventually end at 1
(at least for all numbers that have ever been tried -- nobody has ever proved
that the sequence will always terminate).

The sequence of values of `n` is often called a Hailstone sequence, because
hailstones also travel up and down in the atmosphere before falling to earth.
Write a function that takes a single argument with formal parameter name `n`,
prints out the hailstone sequence starting at `n`, and returns the number of
steps in the sequence:

def hailstone(n): """Print the hailstone sequence starting at n, returning its length."""

Hailstone sequences can get quite long! Try 27. What's the longest you can find?