JamCoders

๐Ÿ’พ Download
In [1]:
%config InteractiveShell.ast_node_interactivity="none"
import base64

def f(globals, locals):
    CODE = ("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", "def make_pretty_assert():
    import sys
    import IPython
    import ast
    import inspect
    import io
    import itertools
    
    global make_pretty_assert
    del make_pretty_assert

    if IPython.__version__ == "5.5.0":
        # colab TODO
        def get_assert_line(frame):
            return frame.f_back.f_back.f_locals["node"]
        def at_top_level(frame):
            code = frame.f_back.f_back.f_code
            return code.co_filename.endswith("IPython/core/interactiveshell.py")
        def can_annotate(frame):
            return False

    elif IPython.__version__ == "8.4.0":
        # lab computers
        def get_assert_line(frame):
            return frame.f_back.f_back.f_locals["node"]
        def at_top_level(frame):
            code = frame.f_back.f_back.f_code
            return code.co_filename.endswith("IPython/core/interactiveshell.py") and code.co_name == "run_ast_nodes"
        def can_annotate(frame):
            return at_top_level(frame) and False

    def is_literal(a):
        try:
            ast.literal_eval(a)
            return True
        except ValueError:
            return False
        return False


    def annotate_call(frame):
        if not can_annotate(frame):
            return
        
        expr: ast.Expr = get_assert_line(frame)
        for kwarg in expr.value.keywords:
            if kwarg.arg == "got":
                got = kwarg.value

        if isinstance(got, ast.Call):
            if not isinstance(got.func, ast.Name):
                return
            name = got.func.id
            func = frame.f_locals[name]
            if not hasattr(func, DEBUGGABLE_ARGS):
                return
            args = getattr(func, DEBUGGABLE_ARGS)
            kwargs = getattr(func, DEBUGGABLE_KWARGS)
            boundargs = inspect.signature(func).bind(*args, **kwargs)

            result = io.StringIO()
            pos = result.write(name)
            pos += result.write("(")

            sep = ', '
            arg_tuples = []  # (ast_arg_str, evaluated_arg, start, limit)

            # Use an iterator here. If a boundarg is not consumed here,
            # it may be consumed later by a pos+kw arg.
            boundargs_iter = iter(boundargs.args)
            for ast_arg, arg in zip(got.args, boundargs_iter):
                ast_arg_str = ast.unparse(ast_arg)
                arg_tuples.append((ast_arg_str, arg, pos, pos + len(ast_arg_str)))
                pos += len(ast_arg_str) + len(sep)

            for ast_kwarg, kwarg in itertools.zip_longest(got.keywords, boundargs_iter):
                ast_arg_str = ast.unparse(ast_kwarg)
                arg_tuples.append((ast_arg_str, kwarg, pos + len(ast_kwarg.arg) + len('='), pos + len(ast_arg_str)))
                pos += len(ast_arg_str) + len(sep)

            pos -= len(sep)
            result.write(sep.join(t[0] for t in arg_tuples))
            result.write(')')
            result_str = result.getvalue()

            yield result_str

            nonliterals = []  # (evaluated_arg, result_str, start, limit)
            for _, evaluated_arg, start, limit in arg_tuples:
                if not is_literal(result_str[start:limit]):
                    nonliterals.append((evaluated_arg, result_str[start:limit], start, limit))

            underlines = io.StringIO()
            pos = 0
            for _, _, start, limit in nonliterals:
                if (limit - start) < 3:
                    pos += underlines.write(' ' * (start - pos))
                    pos += underlines.write('↑')
                    pos += underlines.write('↑' * (limit - pos))
                    continue
                idx = start + (limit - start) // 2
                pos += underlines.write(' ' * (start - pos))
                #pos += underlines.write('╙')
                pos += underlines.write('↑' * (idx - pos))
                pos += underlines.write('↑')
                pos += underlines.write('↑' * (limit - pos))
                #pos += underlines.write('╜')
            yield underlines.getvalue()

            def make_bars_buf(nonliterals, end, evaled):
                buf = io.StringIO()
                pos = 0
                for i in range(len(nonliterals) - 1):
                    _, _, start, limit = nonliterals[i]
                    if (limit - start) < 3:
                        idx = start
                    else:
                        idx = start + (limit - start) // 2
                    pos += buf.write(' ' * (idx - pos))
                    pos += buf.write('│')
                    pos += buf.write(' ' * (limit - pos))

                _, result_str, start, limit = nonliterals[-1]
                if (limit - start) < 3:
                    idx = start
                else:
                    idx = start + (limit - start) // 2                
                pos += buf.write(' ' * (idx - pos))
                pos += buf.write('└')
                pos += buf.write('─' * (end - 1 - pos))
                pos += buf.write('╴')
                pos += buf.write(result_str)
                pos += buf.write(' ≔ ')
                pos += buf.write(str(evaled))

                return buf, pos

            while nonliterals:
                buf, pos = make_bars_buf(nonliterals, len(result_str) + 4, nonliterals[-1][0])
                yield buf.getvalue()
                last = nonliterals.pop()

    def assert_equal(*, want, got, out=sys.stdout):
        if want == got:
            print("Test case passed.")
            return

        frame = inspect.currentframe().f_back

        box_padding = 2
        header = " Test case failed. "
        want_line = f"{box_padding * ' '}Want: {repr(want)} (type: {type(want).__name__})"
        got_line = f"{box_padding * ' '}Got:  {repr(got)} (type: {type(got).__name__})"
        
        if can_annotate(frame):
            assert_line = f"{box_padding * ' '}>>> {ast.unparse(get_assert_line(frame))}"
        else:
            assert_line = ""
            
        debug_lines = list(annotate_call(frame))
        if debug_lines:
            got_line += " ← "
            padding = len(got_line)
            got_line += debug_lines[0]

        padded_debug_lines = []
        for i, line in enumerate(debug_lines):
                if i == 0:
                    continue
                padded_debug_lines.append(' ' * padding + line)
                
        line_max_len = max(len(l) + box_padding for l in (assert_line, want_line, got_line, *padded_debug_lines))
        line_max_len = max(32, line_max_len)
        header_dashes = line_max_len - len(header)


        print(file=out)
        print('-' * (header_dashes // 2), end="", file=out)
        print(header, end="", file=out)
        print('-' * ((header_dashes + 1) // 2), end="", file=out)
        print(file=out)
        print(file=out)

        
        if assert_line:
            print(assert_line, file=out)
            print(file=out)

        print(want_line, file=out)
        print(got_line, file=out)
        for line in padded_debug_lines:
            print(line, file=out)
        
        print(file=out)
        print('-' * line_max_len, file=out)
        print(file=out)
        
    DEBUGGABLE_ARGS = "_debuggable_args"
    DEBUGGABLE_KWARGS = "_debuggable_kwargs"

    def debuggable(f):
        import functools
        @functools.wraps(f)
        def g(*args, **kwargs):
            result = f(*args, **kwargs)
            setattr(g, DEBUGGABLE_ARGS, args)
            setattr(g, DEBUGGABLE_KWARGS, kwargs)
            return result
        return g
    
    return assert_equal, debuggable

assert_equal, debuggable = make_pretty_assert()
")
    for code in CODE:
        exec(base64.b64decode(code), globals, locals)
f(globals(), locals())
del f

def uh(b64):
    return eval(base64.b64decode(b64))

Day 16, Lab A: Memoization

1 Coin Change

We saw, in lecture, the coin change problem: given a set of coin denominations and a target coin value, find the smallest number of coins that add up to that value. For example, what is the smallest set of coins you need to get J\$75, using the Jamacian coins J\$1, J\$5, J\$10, J\$20? (5 coins: J\$20 + J\$20 + J\$20 + J\$10 + J\$5).

We want to create an algorithm that, given any set of coin denominations and a target value, finds the smallest set of coins for us.

1.1 Pot of Greed

The first idea that might come to mind is to be greedy. That is, keep choosing the largest coin that doesn't make your total larger than the target value. This works for some sets of coin denominations. For example, a greedy algorithm always will find the smallest combination of coins when you use the Jamacian coins (J\$1, J\$5, J\$10, J\$20).

Using the greedy algorithm, what Jamaican coins would you choose that add up to J\$34?

In [ ]:
# What Jamaican coins would the greedy algorithm use to add up to J$34?
# Write your answer in the array below as integers.
# For example, [20, 20, 20, 10, 5] would represent J$20 + J$20 + J$20 + J$10 + J$5.

coins =    # YOUR ANSWER HERE

assert_equal(want=uh("WzIwLCAxMCwgMSwgMSwgMSwgMV0="), got=sorted(coins, reverse=True))

Using the greedy algorithm, what US coins would you choose that add up to 30ยข? Recall that the US coin denominations are 1ยข, 5ยข, 10ยข, and 25ยข.

In [ ]:
# What US coins would would the greedy algorithm use to add up to 30ยข?
# The US coins are 1ยข, 5ยข, 10ยข, and 25ยข.
# Write your answer in the array below as integers.
# For example, [25, 25, 25] would represent 25ยข + 25ยข + 25ยข.

coins =    # YOUR ANSWER HERE

assert_equal(want=uh("WzI1LCA1XSA="), got=sorted(coins, reverse=True))

What if we weren't allowed to use the 5ยข coin? What coins would the greedy algorithm choose?

In [ ]:
# What US coins would the greedy algorithm use to add up to 30ยข, without the 5ยข coin?
# Use the coins 1ยข, 10ยข, and 25ยข. 

coins =    # YOUR ANSWER HERE

assert_equal(want=uh("WzI1LCAxLCAxLCAxLCAxLCAxXQ=="), got=sorted(coins, reverse=True))

Is this the least number of coins? Can you do better?

In [ ]:
# What US coins would *you* use to make 30ยข?
# Use the coins 1ยข, 10ยข, and 25ยข. 

coins =    # YOUR ANSWER HERE

assert_equal(want=uh("WzEwLCAxMCwgMTBd"), got=sorted(coins, reverse=True))

Why doesn't greedy work? Think, then run the code below for our answer.

In [ ]:
exec(base64.b64decode("aW1wb3J0IHRleHR3cmFwCgp0ZXh0ID0gJ0dyZWVkeSBhbGdvcml0aG1zIGFsd2F5cyB0YWtlIHRoZSAiYmVzdCIgY3VycmVudCBvcHRpb24uIEJ1dCBzb21ldGltZXMgaXRcJ3MgZ29vZCB0byBsb29rIGFoZWFkOiB0aGUgc2hvcnQgdGVybSBiZXN0IG9wdGlvbiBpcyBub3QgYWx3YXlzIHRoZSBsb25nIHRlcm0gYmVzdCBvcHRpb24uIEEgc21hbGwgc2FjcmlmaWNlIG5vdyAodGFraW5nIHRoZSAxMMKiIGluc3RlYWQgb2YgdGhlIDI1wqIpIGNhbiB0cmFuc2xhdGUgaW50byBhIGJpZyB3aW4gaW4gdGhlIGZ1dHVyZS4nCnByaW50KCdcbicuam9pbih0ZXh0d3JhcC53cmFwKHRleHQsIDgwKSkp"))

1.2 Greed isn't good

If greedy doesn't work, how can we proceed? We can always use brute force.

For the first coin, we know we must choose one of the coins in our set. Why not try all of them?

Let's try the above problem again: we want to make 30ยข out of 1ยข, 10ยข, and 25ยข coins. We can try each one:

$$ \texttt{coin_change(30)} \\ \begin{align*} 30ยข& - 1ยข &=\;&29ยข \\ 30ยข& - 10ยข &=\;&20ยข \\ 30ยข& - 25ยข &=\;&5ยข \\ \end{align*} $$

Notice that after choosing one coin, we now have a coin change problem for a smaller value. How do we find coins that add up to that value? We can recursively call ourselves, of course, and take the minimum. For example, here are the recursive calls for coin_change(30):

$$ \texttt{coin_change(30)} \\ \begin{align*} 30ยข& - 1ยข &=\;&29ยข &\rightarrow \texttt{coin_change(29)} \\ 30ยข& - 10ยข &=\;&20ยข &\rightarrow \texttt{coin_change(20)} \\ 30ยข& - 25ยข &=\;&5ยข &\rightarrow \texttt{coin_change(5)} \\ \end{align*} $$

Fill in the skeleton for coin_change below.

In [ ]:
@debuggable
def coin_change(target, coins):
    """Finds a list of coins with smallest size that adds up to target.
    
    Arguments:
        target: The value to reach.
        coins: The allowed (positive) denominations of coins.
        
    Returns (list or None):
        The smallest list of coins that add up to `target`.
        If there is no possible way to add to `target`, returns None.
    """
    # Base cases.
    if ________________:                  # YOUR CODE HERE
        return ________________           # YOUR CODE HERE
    
    if ________________:                  # YOUR CODE HERE
        return ________________
    
    # Recursive case.
    best = None
    for coin in coins:
        result = ______________________   # YOUR CODE HERE
        if result is None:
            continue
        
        if best is None or ___________ < ___________:   # YOUR CODE HERE
            best = [coin] + result
        
    return best


assert_equal(want=[10, 10, 10], got=coin_change(30, [1, 10, 25]))
assert_equal(want=[5, 1, 1, 1], got=coin_change(8, [1, 5, 10, 20]))
assert_equal(want=[10, 5, 1, 1], got=coin_change(17, [20, 10, 5, 1]))
assert_equal(want=[4, 4], got=coin_change(8, [20, 10, 5, 4, 1]))
assert_equal(want=[5, 4], got=coin_change(9, [1, 4, 5, 10, 20]))
assert_equal(want=[], got=coin_change(0, [20, 10, 5, 1]))

1.3 coin_change allows me to create FOUR MORE CALLS

Try running your coin_change operation on larger values of target. How long does it take?

If your code runs for too long because target was too big, you can press the stop button in Jupyter (โน).

In [ ]:
# Try running coin_change below.

for i in (10, 20, 30, 40, 50, 60, 70, 80, 90, 100):
    print(i, end="\t")
    repeats = 7 if i < 50 else 1
    get_ipython().run_line_magic('timeit', f'-r {repeats} coin_change(i, [1, 5, 10, 20])')

Why is coin_change taking so long? The call to coin_change(50) creates four new recursive calls to coin_change(49), coin_change(45), coin_change(40), and coin_change(30). Each one of those creates four new recursive calls as well, and so on. The total amount of work done is exponential; $\mathcal{O}(b^n)$ (where $b$ is some base that depends on the coins that are passed in).

Exponential growth is extremely fast. Here are the running times for coin_change from my laptop:

target time multiplier from previous
10 0.0000171s
20 0.000379s x22.1
30 0.00816s x21.6
40 0.176s x21.5
50 3.78s x21.5
60 81.6s x21.6
70 29m 50s x21.9
80 10h 53m (estimate) x21.9
90 9d 22h (estimate) x21.9
100 217d 12h (estimate) x21.9

But clearly we can do better. It doesn't take a cashier 9 days to give you J\$90 in coins!

How can we make coin_change run faster? Below is coin_change_count, which counts how many times coin_change calls itself on a particular target value:

In [ ]:
# Don't worry about understanding this code.
@debuggable
def coin_change_count(target, coins, count_target):
    # Replace the global coin_change with our own function...
    global coin_change
    # Save the real coin change function so we can restore it later.
    real_coin_change = coin_change
    counter = 0
    def counting_coin_change(t, c):
        # Need nonlocal to write to the counter in the parent scope.
        nonlocal counter
        if t == count_target:
            counter += 1
        return real_coin_change(t, c)
    coin_change = counting_coin_change

    # Call our counting_coin_change function.
    coin_change(target, coins)
    
    # Restore the real coin change function.
    coin_change = real_coin_change
    
    return counter


# How many times do we recursively call coin_change(10) in for each of
# coin_change(10), coin_change(20), ..., coin_change(60)?
assert_equal(want=1, got=coin_change_count(10, [1, 5, 10, 20], count_target=10))
assert_equal(want=9, got=coin_change_count(20, [1, 5, 10, 20], count_target=10))
assert_equal(want=198, got=coin_change_count(30, [1, 5, 10, 20], count_target=10))
assert_equal(want=4287, got=coin_change_count(40, [1, 5, 10, 20], count_target=10))
assert_equal(want=92249, got=coin_change_count(50, [1, 5, 10, 20], count_target=10))
assert_equal(want=1984369, got=coin_change_count(60, [1, 5, 10, 20], count_target=10))

We're repeating the call to coin_change(10) many thousands of times. Why? coin_change(10) is called by coin_change(11), coin_change(15), coin_change(20), and coin_change(30), which are themselves called many times. But we know that each time they are called, they return the same thing. What if we remembered the result for each call, and returned it instead of recomputing the result?

2 Memoization

2.1 Fibonacci

Let's take a detour and return to the Fibonacci numbers. Recall that the Fibonacci sequence is defined recursively, with $f_0 = 0$, $f_1 = 1$, and $f_n = f_{n-1} + f_{n-2}$ for all $n \geq 2$. Below is an implementation:

In [ ]:
@debuggable
def fib(n):
    if n == 0:
        return 0
    if n == 1:
        return 1
    
    return fib(n - 1) + fib(n - 2)

%timeit fib(30)

What is the running time of fib(n)? Let's observe two things.

  1. First, whenever we call fib, we are either returning the result of two subcalls, or returning a base case. The only "numbers" that appear in fib's definition are 0 and 1 in the base cases. We can imagine that the only time we "add one" to the result of fib(n) is thus whenever we arrive at some call to fib(1) in some chain of recursive subcalls. So the running time of fib(n) is at least the number of subcalls to fib(1), which is equal to the number returned by fib(n) ($f_n$).
  2. $f_n$ grows exponentially large. We can observe this by comparing the ratios between successive Fibonacci numbers:
In [3]:
print(fib(11) / fib(10))
print(fib(21) / fib(20))
print(fib(31) / fib(30))
1.6181818181818182
1.6180339985218033
1.6180339887505408

We see that $f_{n+1} \approx f_{n} \times 1.618$. Combined with observation 1, this implies that fib(n) itself takes exponential running time. And, as we saw emperically above, even fib(30) is already fairly slow (~1 second!). How can we speed this up?

Again, fib(1) is being called many many times. Why? Because fib(2) and fib(3) are themselves being called many many times. And those are being called by fib(3), fib(4), and fib(5) many many times. And so on.

What if we "remembered" the result of calls to all fib(i) so they are only computed once? We'd be a lot faster! This technique is known as memoization.

In [ ]:
def fib_memo(n, mem):
    if mem[n] is not None:
        return mem[n]
    
    mem[n] = fib_memo(n - 1, mem) + fib_memo(n - 2, mem)
    return mem[n]
    
    
def fib_fast(n):
    mem = [None] * (n + 1)
    # Instead of defining base cases in fib_memo,
    # we can instead populate the cache for 0 and 1.
    mem[0] = 0
    mem[1] = 1
    return fib_memo(n, mem)

How fast is fib(30) on the memoized version? Instant! (A ยตs, pronounced "microsecond", is 1/1,000,000'th of a second).

In [ ]:
print(fib_fast(30))

%timeit fib_fast(30)

We can also compute $f_{500}$ nearly instantly. This would have taken $1 \text{ second} \times (1.618)^{(500 - 30)} = 5.258 \times 10^{90} \text{ years}$ with fib. That's ($3.8 \times 10^{80}$ times longer than the universe has been alive!

In [ ]:
print(fib_fast(500))

%timeit fib_fast(500)

What is the running time of fib_fast? Because we only call fib_memo(i) on every $0 \leq i \leq n$ once, we make linearly many calls to fib_memo (instead of exponentially many calls to fib). Assuming constant-time addition, fib_fast thus takes $\mathcal{O}(n)$ time.

2.2 Coin Change, Fast

Write coin_change_fast and coin_change_memo. For the body of coin_change_memo, copy the body of coin_change above, except surround the body with logic that checks the mem cache for whether we have seen that recursive call before. Also, add results to the cache after it is computed for the first time.

coin_change_fast should create a mem array and pass that to coin_change_memo.

In [ ]:
def coin_change_memo(n, coins, memo):
    # Check memo for cached value.
    if _________________:                    # YOUR CODE HERE
        return _________________             # YOUR CODE HERE
    
    # REPLACE WITH coin_change BODY
    
    # Add the result to the memo cache
    _____________________                    # YOUR CODE HERE
    
def coin_change_fast(n, coins):
    # How large does the cache need to be?
    memo = _________________                 # YOUR CODE HERE
    
    return  ____________________             # YOUR CODE HERE



assert_equal(want=[10, 10, 10], got=coin_change_fast(30, [1, 10, 25]))
assert_equal(want=[5, 1, 1, 1], got=coin_change_fast(8, [1, 5, 10, 20]))
assert_equal(want=[10, 5, 1, 1], got=coin_change_fast(17, [20, 10, 5, 1]))
assert_equal(want=[4, 4], got=coin_change_fast(8, [20, 10, 5, 4, 1]))
assert_equal(want=[5, 4], got=coin_change_fast(9, [1, 4, 5, 10, 20]))
assert_equal(want=[], got=coin_change_fast(0, [20, 10, 5, 1]))
assert_equal(want=[20, 20, 20, 20, 10, 5, 1, 1, 1, 1], got=coin_change_fast(99, [20, 10, 5, 1]))
assert_equal(want=[25, 25, 25, 10, 10, 1, 1, 1, 1], got=coin_change_fast(99, [25, 10, 5, 1]))

3 Challenge

3.1 fib_fast(n) runtime

We said that computing fib_fast(n) requires at most linearly many in $n$ calls to fib_fast(n). But what is its runtime?

Hint: Adding two numbers $A + B$ takes $\mathcal{O}(\log{A} + \log{B})$ runtime. Also, $f_n \approx 1.618^{n}$.

In [ ]:
# YOUR CODE/ANSWER HERE

3.2 fib_fast(n) space

fib_fast(n) currently stores every Fibonacci number $f_i : 0 \leq i \leq n$ in memory. How might you rewrite fib_fast(n) to use even less space?

Hint: Think of each invocation of fib_fast(i) as a separate node in a graph, and draw an edge from fib_fast(i) to fib_fast(j) if fib_fast(i) recursively calls fib_fast(j). In what order does fib_fast above "call" each node? When does the result of a call become unneeded? Can you call them in a different order to save space?

In [ ]:
# YOUR CODE/ANSWER HERE

3.3 Canonical Coin Making

A coin making system (i.e. the denominations of coins that are given) is called canonical if the greedy algorithm is also an optimal algorithm. (Our coin_change and coin_change_fast algorithms are optimal because they exhaustively search through all possibilities.)

Are the Jamaican and US coin systems canonical? Why or why not?

In [ ]:
# YOUR CODE/ANSWER HERE