## Instructions

Download hw07.zip. Inside the archive, you will find starter files for the questions in this homework, 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. Check that you have successfully submitted your code on okpy.org. See this article for more instructions on okpy and submitting assignments.

Readings: This homework relies on following references:

### Question 1: Reduce

Write the recursive version of the function `reduce` which takes

• reducer - a two-argument function that reduces elements to a single value
• s - a sequence of values
• base - the starting value in the reduction. This is usually the identity of the reducer

If you're feeling stuck, think about the parameters of `reduce`.

``````from operator import add, mul

def reduce(reducer, seq, base):
"""Reduce a sequence under a two-argument function starting from a base value.

...     return x + y
>>> def mul(x, y):
...     return x*y
10
>>> reduce(mul, [1,2,3,4], 0)
0
>>> reduce(mul, [1,2,3,4], 1)
24
"""
``````

Use OK to test your code:

``python3 ok -q reduce``

### Question 2: Remove Last from Sequence

Complete the recursive function `remove_last` which creates a new list identical to the input list `s` but with the last element in the sequence that is equal to `x` removed.

``````def remove_last(x, s):
"""Create a new list that is identical to s but with the last
element from the list that is equal to x removed.

>>> remove_last(1,[])
[]
>>> remove_last(1,[1])
[]
>>> remove_last(1,[1,1])
[1]
>>> remove_last(1,[2,1])
[2]
>>> remove_last(1,[3,1,2])
[3, 2]
>>> remove_last(1,[3,1,2,1])
[3, 1, 2]
>>> remove_last(5, [3, 5, 2, 5, 11])
[3, 5, 2, 11]
"""

Illustrated here is a more complete doctest that shows good testing methodology. It is a little cumbersome as documentation, but you'll want to think about it for your projects. Test every condition that might come up. Then you won't be surprised when it does.

Use OK to test your code:

``python3 ok -q remove_last``

### Question 3: Create Number from Lists

Write a recursive function `create_num_from_lsts` that creates a number with the elements from `lst1` and `lst2` as digits in that order.

``````def create_num_from_lsts(lst1, lst2):
""" Create a number with the elements from lst1 and lst2 as digits in that order.

>>> create_num_from_lsts([1, 2, 3], [4, 5, 6])
123456
>>> create_num_from_lsts([5, 4, 2, 4], [1, 7])
542417
>>> create_num_from_lsts([3], [9, 8])
398
"""

Use OK to test your code:

``python3 ok -q create_num_from_lsts``

### Question 4: Count Change

A set of coins makes change for `n` if the sum of the values of the coins is `n`. For example, if you have 1-cent, 2-cent and 4-cent coins, the following sets make change for `7`:

• 7 1-cent coins
• 5 1-cent, 1 2-cent coins
• 3 1-cent, 2 2-cent coins
• 3 1-cent, 1 4-cent coins
• 1 1-cent, 3 2-cent coins
• 1 1-cent, 1 2-cent, 1 4-cent coins

Thus, there are 6 ways to make change for `7`. Write a function `count_change` that takes a positive integer `n` and a list of the coin denominations and returns the number of ways to make change for `n` using these coins (Hint: You will need to use tree recursion):

``````def count_change(amount, denominations):
"""Returns the number of ways to make change for amount.

>>> denominations = [50, 25, 10, 5, 1]
>>> count_change(7, denominations)
2
>>> count_change(100, denominations)
292
>>> denominations = [16, 8, 4, 2, 1]
>>> count_change(7, denominations)
6
>>> count_change(10, denominations)
14
>>> count_change(20, denominations)
60
"""
``python3 ok -q count_change``
``python3 ok --submit``