# Homework 1 Solutions

## Solution Files

You can find the solutions in the hw01.py and quiz01.py files.

## Homework Questions

For this set of problems, you must run `ok`

from within the `problems`

directory. Remember that you may choose to work with a partner on homework
questions.

### Question 1

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 = sub else:
f = add return f(a, b)
```

Use OK to test your code:

`python3 ok -q a_plus_abs_b`

We choose the operator `add`

or `sub`

based on the sign of `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
line 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
"""
return max(a*a+b*b, a*a+c*c, b*b+c*c)
return a**2 + b**2 + c**2 - min(a, b, c)**2
```

Use OK to test your code:

`python3 ok -q two_of_three`

We use the fact that if `a>b`

and `b>0`

, then `square(a)>square(b)`

.
So, we can take the `max`

of the sum of squares of all pairs. The
`max`

function can take an arbitrary number of arguments.

### Question 3

Write a function that takes an integer `n`

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

and evenly divides `n`

.

```
def largest_factor(n):
"""Return the largest factor of n that is smaller than n.
>>> largest_factor(15) # factors are 1, 3, 5
5
>>> largest_factor(80) # factors are 1, 2, 4, 5, 8, 10, 16, 20, 40
40
>>> largest_factor(13) # factor is 1 since 13 is prime
1
"""
factor = n - 1
while factor > 0:
if n % factor == 0:
return factor
factor -= 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."

Use OK to test your code:

`python3 ok -q largest_factor`

Iterating from `n-1`

to 1, we return the first integer that evenly divides `n`

.
This is guaranteed to be the largest factor of `n`

.

### Question 4

Let's 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():
return False
def t():
1/0
def f():
return 1
```

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.

Hint: If you are having a hard time identifying how the if statement and if function differ, first try to get them to

The function `with_if_function`

uses a call expression, which
guarantees that all of its operand subexpressions will be evaluated
before `if_function`

is applied to the resulting arguments. Therefore,
even if `c`

returns `False`

, the function `t`

will be called. By
contrast, `with_if_statement`

will never call `t`

if `c`

returns
`False`

.

### 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.

This sequence of values of `n`

is often called a Hailstone sequence,
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
"""
length = 1
while n != 1:
print(n)
if n % 2 == 0:
n = n // 2 # Integer division prevents "1.0" output
else:
n = 3 * n + 1
length = length + 1
print(n) # n is now 1
return length
```

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`

## Quiz Questions

For this set of problems, you must run `ok`

from within the `quiz`

directory.
While homework questions may be completed with a partner, please remember that
**quiz questions must be completed alone.**

### Question 6: Multiple

Write a function that takes in two numbers and returns the smallest number that is a multiple of both.```
def multiple(a, b):
"""Return the smallest number n that is a multiple of both a and b.
>>> multiple(3, 4)
12
>>> multiple(14, 21)
42
"""
n = 1
while True:
if n % a == 0 and n % b == 0:
return n
n += 1
```

Use OK to test your code:

`python3 ok -q multiple`

### Question 7: Unique Digits

Write a function that returns the number of unique digits in a positive integer.```
def unique_digits(n):
"""Return the number of unique digits in positive integer n
>>> unique_digits(8675309) # All are unique
7
>>> unique_digits(1313131) # 1 and 3
2
>>> unique_digits(13173131) # 1, 3, and 7
3
>>> unique_digits(10000) # 0 and 1
2
>>> unique_digits(101) # 0 and 1
2
>>> unique_digits(10) # 0 and 1
2
"""
unique = 0
while n > 0:
last, n = n % 10, n // 10
if not has_digit(n, last):
unique += 1
return unique
# unique = 0
# i = 0
# while i < 10:
# if has_digit(n, i):
# unique += 1
# i += 1
# return unique
def has_digit(n, k):
while n > 0:
last, n = n % 10, n // 10
if last == k:
return True
return False
```

Hint:You may find it helpful to first define a function`has_digit(n, k)`

, which determines whether a number`n`

has digit`k`

.

Use OK to test your code:

`python3 ok -q unique_digits`

We have provided two solutions:

- In one solution, we look at the current digit, and check if the rest of the number contains that digit or not. We only say it's unique if the digit doesn't exist in the rest. We do this for every digit.
- In the other, we loop through the numbers 0-9 and just call
`has_digit`

on each one. If it returns true then we know the entire number contains that digit and we can one to our unique count.