# Homework 1

*Due by 11:59pm on Wednesday, 9/2*

## Instructions

Download hw01.zip. Inside the archive, you will find a file called hw01.py, along with a copy of the OK autograder.

**Submission:** When you are done, submit with ```
python3 ok
--submit
```

. You may submit more than once before the deadline; only the
final submission will be scored. See Lab 1 for instructions on submitting
assignments.

**Using OK:** If you have any questions about using OK, please
refer to this guide.

**Readings:** You might find the following references
useful:

## Required questions

### Question 1

We've seen that we can give new names to existing functions. Fill in
the blanks 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.
>>> a_plus_abs_b(2, 3)
5
>>> a_plus_abs_b(2, -3)
5
"""
if b < 0:
f = _____
else:
f = _____
return f(a, b)
```

Use OK to test your code:

`python3 ok -q a_plus_abs_b`

### Question 2

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

```
def two_of_three(a, b, c):
"""Return x*x + y*y, where x and y are the two largest members of the
positive numbers a, b, and c.
>>> two_of_three(1, 2, 3)
13
>>> two_of_three(5, 3, 1)
34
>>> two_of_three(10, 2, 8)
164
>>> two_of_three(5, 5, 5)
50
"""
"*** YOUR CODE HERE ***"
```

Use OK to test your code:

`python3 ok -q two_of_three`

### Question 3

Write a function that takes an integer `n`

**greater than 1** and returns the
largest integer smaller than `n`

that evenly divides `n*n-1`

.

*Hint*: To check if `b`

evenly divides `a`

, you can use the expression ```
a % b
== 0
```

, which can be read as, "the remainder of dividing `a`

by `b`

is 0."
However, it is possible to solve this problem without any `if`

or `while`

statements.

```
def largest_factor(n):
"""Return the largest factor of n*n-1 that is smaller than n.
>>> largest_factor(4) # n*n-1 is 15; factors are 1, 3, 5, 15
3
>>> largest_factor(9) # n*n-1 is 80; factors are 1, 2, 4, 5, 8, 10, ...
8
"""
"*** YOUR CODE HERE ***"
```

Use OK to test your code:

`python3 ok -q largest_factor`

### Question 4

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_function(True, 2, 3)
2
>>> if_function(False, 2, 3)
3
>>> if_function(3==2, 3+2, 3-2)
1
>>> if_function(3>2, 3+2, 3-2)
5
"""
if condition:
return true_result
else:
return false_result
```

Despite the doctests above, this function actually does *not* do the
same thing as an `if`

statement in all cases. To prove this fact,
write functions `c`

, `t`

, and `f`

such that `with_if_statement`

returns the number `1`

, but `with_if_function`

does not (it can do
*anything* else):

```
def with_if_statement():
"""
>>> with_if_statement()
1
"""
if c():
return t()
else:
return f()
def with_if_function():
return if_function(c(), t(), f())
def c():
"*** YOUR CODE HERE ***"
def t():
"*** YOUR CODE HERE ***"
def f():
"*** YOUR CODE HERE ***"
```

To test your solution, open an interactive interpreter

` python3 -i hw01.py`

and try calling `with_if_function`

and `with_if_statement`

to check that one
returns 1 and the other doesn't.

### Question 5

Douglas Hofstadter's Pulitzer-prize-winning book, *GĂ¶del, Escher,
Bach*, poses the following mathematical puzzle.

- Pick a positive integer
`n`

as the start. - If
`n`

is even, divide it by 2. - If
`n`

is odd, multiply 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 terminate). Analogously, a hailstone
travels up and down in the atmosphere before eventually landing on
earth.

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 and return its
length.
>>> a = hailstone(10)
10
5
16
8
4
2
1
>>> a
7
"""
"*** YOUR CODE HERE ***"
```

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

Use OK to test your code:

`python3 ok -q hailstone`

## Extra questions

Extra questions are not worth extra credit and are entirely optional. They are designed to challenge you to think creatively!

### Question 6

Write a one-line program that prints itself, using only the following features of the Python language:

- Number literals
- Assignment statements
- String literals that can be expressed using single or double quotes
- The arithmetic operators
`+`

,`-`

,`*`

, and`/`

- The built-in
`print`

function - The built-in
`eval`

function, which evaluates a string as a Python expression - The built-in
`repr`

function, which returns an expression that evaluates to its argument

You can concatenate two strings by adding them together with `+`

and repeat a
string by multipying it by an integer. Semicolons can be used to separate
multiple statements on the same line. E.g.,

```
>>> c='c';print('a');print('b' + c * 2)
a
bcc
```

Hint: Explore the relationship between single quotes, double quotes, and the
`repr`

function applied to strings.

Place your solution in the multi-line string named `challenge_question_program`

.

*Note*: No tests will be run on your solution to this problem.