CS116 - Module 5 - Accumulative Recursion

Transcription

1 CS116 - Module 5 - Accumulative Recursion Cameron Morland Winter Cameron Morland CS116 - Module 5 - Accumulative Recursion

2 Types of Recursion Structural Recursion Generative Recursion Accumulative Recursion 3 Cameron Morland CS116 - Module 5 - Accumulative Recursion

3 Structural Recursion what we ve been doing so far Template for code is based on recursive definition of the data. Examples: Define the set N of natural numbers: 1 0 is in N. 2 If n is in N then n + 1 is in N. def factorial(n): if n == 0: return 1 else: return n * factorial(n-1) These both use the countdown template we used in Racket. Racket lists were defined recursively. A list is either empty or (cons v L) where v is a value L is another list. We extracted the value using first, and the remaining list using rest. This is not how it works in Python, but we can still process a list L that way, using L[0] instead of first and L[1:] instead of rest. def sum(l): if n == []: return 0 else: return L[0] + sum(l[1:]) 4 Cameron Morland CS116 - Module 5 - Accumulative Recursion

4 Generative Recursion Generative Recursion is Recursion not modelled after the structure of the data. For example, def is_palindrome(s): if len(s) < 2: return True else: return s[0] == s[-1] and is_palindrome(s[1:-1]) This is not structural recursion unless s is defined in a really strange way! 5 Cameron Morland CS116 - Module 5 - Accumulative Recursion

5 Generative Recursion Consider new ways (other than the definition of the data) to break into subproblems. Requires more creativity in solutions. We can do more Different solutions techniques. Even more problems can be solved. More variations no standard template. Generative Recursion is the alternative to structural recursion. We don t really care about the difference between structural and generative recursion. It merely means that you cannot rely on templates to design your code. 6 Cameron Morland CS116 - Module 5 - Accumulative Recursion

6 Trace factorial # factorial: Nat -> Nat def factorial(n): if n == 0: return 1 else: return n * factorial(n-1) factorial(5) => 5 * factorial(4) => 5 * (4 * factorial(3)) => 5 * (4 * (3 * factorial(2))) => 5 * (4 * (3 * (2 * factorial(1)))) => 5 * (4 * (3 * (2 * (1 * factorial(0))))) => 5 * (4 * (3 * (2 * (1 * 1)))) => 5 * (4 * (3 * (2 * 1))) => 5 * (4 * (3 * 2)) => 5 * (4 * 6) => 5 * 24 => 120 The computer keeps track of all variables to multiply later, and this takes memory. 8 Cameron Morland CS116 - Module 5 - Accumulative Recursion

7 Accumulative Recursion Instead of leaving all the multiplication to the end, accumulate it as we go. The recursive function will consume the accumulated values. We ll need a helper function to initialize the accumulator. 9 Cameron Morland CS116 - Module 5 - Accumulative Recursion

8 Accumulative factorial # remember_fact: Nat Nat -> Nat def remember_fact( product, n0): if n0 <= 0: return product else: return remember_fact( product*n0, n0-1) # accumulative_factorial: Nat -> Nat def accumulative_factorial(n): return remember_fact(1, n) accumulative_factorial(5) => remember_fact(1, 5) => remember_fact(5, 4) => remember_fact(20, 3) => remember_fact(60, 2) => remember_fact(120, 1) => remember_fact(120, 0) => 120 There is nothing left over to multiply later, so memory usage may not increase. 10 Cameron Morland CS116 - Module 5 - Accumulative Recursion

9 Differences and similarities in implementations remember_fact needs a helper function to keep track of the work done so far Both implementations are correct, but factorial does all calculations after reaching the base case remember_fact does the calculations as we go. product is called the accumulator Mathematically equivalent, but not computationally equivalent. 11 Cameron Morland CS116 - Module 5 - Accumulative Recursion

10 Accumulative Recursion This technique is called accumulative recursion. It may be used with structural recursion, in which case it may be called structural recursion with an accumulator. It may also be used with generative recursion. 12 Cameron Morland CS116 - Module 5 - Accumulative Recursion

11 Accumulative Recursion Wrapper Function: The wrapper function sets the initial value of the accumulator(s). The wrapper function may also handle special cases. Recall: def accumulative_factorial(n): return remember_fact(1, n) Helper Function: Does most of the work. Requires at least two parameters: The accumulator records what has been done so far. The remainder records what remains to be done (and is used to identify the base cases). Some problems may need more than one accumulator or tracker. Recall: def remember_fact(product, n0): Cameron Morland CS116 - Module 5 - Accumulative Recursion

12 Accumulative function pattern def acc_helper(acc, remaining,...): if at base case of remaining: return acc else: ##... maybe do some extra work here... return acc_helper( updated acc, updated remaining,...) ## Key point: the return has * nothing* outside the acc_helper call. ## We return * exactly* what acc_helper returns. def fn(...): ## Consider special cases, as needed. return... acc_helper( initial acc, initial remaining,...)... Exercise: Rewrite this non-accumulative function list_sum to create an accumulative function list_sum(l) which consumes a (listof Int) and returns the sum. def list_sum(l): if L == []: return 0 else: return L[0] + list_sum(l[1:])

13 Accumulative Fibonacci Numbers The nth Fibonacci number is the sum of the two previous Fibonacci numbers: where f 0 = 0, f 1 = 1. f n = f n 1 + f n 2 Exercise: Type in this program, and verify that it works. # fib(n): returns the nth Fibonacci number. def fib(n): if n == 0: return 0 elif n == 1: return 1 else: return fib(n-1) + fib(n-2) What is fib(30)? What is fib(35)? What is fib(40)? This is a purely structural program, but it is very slow. Exercise: Write a function fib(n) which uses accumulative recursion to compute the first n Fibonacci numbers. Hint: use a helper extend_fib(fibs, n) where fibs accumulates the result.

14 Reversing a List This is non-accumulative recursion: # invert(l): return a list with the elements of L in reverse order # invert: ( listof Any) -> ( listof Any) def invert(l): if len(l) <= 1: return L else: return invert(l[1:]) + [L[0]] # ˆˆˆˆˆˆˆˆˆ # Stuff outside the recursive call # means it ' s non - accumulative. Exercise: def invert( orig): mylist = orig. copy() acc = [] acc_invert( mylist, acc) return acc Write an accumulative helper function acc_invert(l, A) which will allow this to return an inverted copy of orig. Use append and pop so at the end L == [] and A contains the answer.

15 Avoiding the recursion depth limit A new function: list(range(5)) => [0,1,2,3,4] Using the structural recursive my_max, we are limited in the length of the list we can work on. my_max(list(range(5))) => 4, but my_max(list(range(2000))) results in RecursionError: maximum recursion depth exceeded in comparison Why? Each recursive call shortens the list by only one. We make another recursive call for each item in the list. Let s break the list up a different way: generative recursion. Instead of making one recursive call on L[1:] and comparing that with L[0], split the list in two more or less equal halves, and recurse on each of those. L[:len(L)//2] => first half L[len(L)//2:] => second half Exercise: By splitting the list in two halves, use generative recursion to write a function that returns the maximum value in a (listof Int). 20 Cameron Morland CS116 - Module 5 - Accumulative Recursion

16 Steps for Generative Recursion 1 Break the problem into any subproblem(s) that seem natural for the problem. 2 Determine the base case(s). 3 Solve the subproblems, recursively if necessary. 4 Determine how to combine subproblem solutions to solve the original problem. 5 Test! Without a template, it can be more difficult to be sure you have tested all possibilities. Test thoroughly. 21 Cameron Morland CS116 - Module 5 - Accumulative Recursion

17 Example: gcd The greatest common divisor (gcd) of two natural numbers is the largest natural number that divides evenly into both. gcd(10, 25) = 5 gcd(20, 22) = 2 gcd(47, 21) = 1 This is a structurally recursive function that computes gcd. It uses the countdown template on n. # gcd_countdown(a,b,n): return the # greatest divisor of a and b which # is <= n. # gcd: Nat Nat -> Nat def gcd_countdown(a, b, n): if a % n == 0 and b % n == 0: return n else: return gcd_countdown(a, b, n-1) # gcd(a,b): return the gcd of a and b # gcd: Nat Nat -> Nat def gcd(a, b): return gcd_countdown(a, b, a) 22 Cameron Morland CS116 - Module 5 - Accumulative Recursion

18 Euclid s Algorith for gcd When two unequal numbers are set out, and the less is continually subtracted in turn from the greater, if the number which is left never measures the one before it until a unit is left, then the original numbers are relatively prime. [...and if the number left does eventually measure one before it, that number is the gcd.] Euclid s Elements, Book VII, Proposition I. def gcd(a, b): if a == 0: return b elif b == 0: return a else: return gcd(b, a % b) This is not structural; it is generative. But it still has a base case still is recursive 23 Cameron Morland CS116 - Module 5 - Accumulative Recursion

19 Tracing accumulative, generative recursion Exercise: Given mylist = [1,0,4,3,2], trace find(mylist, 0). # help(l, i, s):...ouch... # help: ( listof Nat) Nat Nat -> Nat def help(l, i, s): if L[i] == s: return i else: return help(l, L[i], s) # find(l, i): Find where i is in L. # find: ( listof Nat) Nat -> Nat def find(l,i): return help(l, i, i) Exercise: Now with mylist = [4,2,0,4,3], trace find(mylist, 0). What happens and why? 24 Cameron Morland CS116 - Module 5 - Accumulative Recursion

20 Locally defined functions (inner functions) in Python You can t have two variables with the same name, even if one is a function: # foo(x) returns 1 more than x # foo: Int -> Int def foo(x): return x + 1 # bar(y) returns 2*( y+1) # bar: Int -> Int def bar(y): return foo(2* y)...but you can define functions locally: # bar(y) returns 2*( y+1) # bar: Int -> Int def bar(y): # foo(x): returns 1 more than x # foo: Int -> Int def foo(x): return x + 1 return foo(2* y) bar(5) => 11 foo = 42 bar(5) -> TypeError: 'int' object is not callable bar(5) => 11 foo = 42 bar(5) => 11 You may now define helper functions locally on assignments. You still need the design recipe.

21 Removing Duplicates To remove all copies of some value (e.g. 4) from a list, we may use filter: list(filter(lambda x: x!= 4, [4, 2, 3, 4, 6])) => [2, 3, 6] Exercise: Using this idea, write a function singles(l) which consumes listof Int and returns a list like L but containing only the first instance of each element. For example, singles([1,2,1,3,4,2]) => [1,2,3,4] Do not use a lambda, instead use a locally-defined function. 26 Cameron Morland CS116 - Module 5 - Accumulative Recursion

22 Locally defined functions and design recipes for accumulative recursion You need to write the design recipe even for locally defined functions. As in Racket, you cannot test locally defined functions. If possible, it s a good idea to write them as ordinary functions and test them before moving them inside. # fib4(n) returns nth Fibonacci # fib4: Nat -> Nat # Example: fib4(10) => 55 def fib4(n): # acc(n0,last, prev) produces (n+n0)th Fibonacci number, # where last is the (n)th, and prev is (n-1) th # acc: Nat Nat Nat -> Nat def acc (n0, last, prev): if n0 >= n: return last else: return acc(n0+1, last+prev, last) # Body of fib4 if n==0: return 0 else: return acc(1,1,0) 28 Cameron Morland CS116 - Module 5 - Accumulative Recursion

23 Goals of Module 5 Understand how to write recursive functions in Python. Write functions that are structurally recursive, and ones that are not structurally recursive. Write functions that use accumulative recursion. Before we begin the next module, please Read Think Python, chapter Cameron Morland CS116 - Module 5 - Accumulative Recursion