Solution Files

You can find the solutions in the and 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)
    >>> a_plus_abs_b(2, -3)
    if b < 0:
f = sub
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)
    >>> two_of_three(5, 3, 1)
    >>> two_of_three(10, 2, 8)
    >>> two_of_three(5, 5, 5)
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
    >>> largest_factor(80) # factors are 1, 2, 4, 5, 8, 10, 16, 20, 40
    >>> largest_factor(13) # factor is 1 since 13 is prime
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)
    >>> if_function(False, 2, 3)
    >>> if_function(3==2, 3+2, 3-2)
    >>> if_function(3>2, 3+2, 3-2)
    if condition:
        return true_result
        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()
    if c():
        return t()
        return f()

def with_if_function():
    return if_function(c(), t(), f())

def c():
return False
def t():
def f():
return 1

To test your solution, open an interactive interpreter

python3 -i

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 print out different values.

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.

  1. Pick a positive integer n as the start.
  2. If n is even, divide it by 2.
  3. If n is odd, multiply it by 3 and add 1.
  4. 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

    >>> a = hailstone(10)
    >>> a
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)
    >>> multiple(14, 21)
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
    >>> unique_digits(1313131) # 1 and 3
    >>> unique_digits(13173131) # 1, 3, and 7
    >>> unique_digits(10000) # 0 and 1
    >>> unique_digits(101) # 0 and 1
    >>> unique_digits(10) # 0 and 1
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.