Functional Programming, Tail Recursion, & Spooky Stamps

Transcription

1 Functional Programming, Tail Recursion, & Spooky Stamps October 31, 2018 Intermediate Programming - Guest Lecture - Tatiana Bradley Notes: Take some candy as you walk in (if you like) Grab something to write on (electronic OK) These slides cover same general info as Prof. Pattis notes, but the presentation is slightly different - read his lecture notes

2 Intro to Functional Programming (Reference) Functional programming languages (e.g. Haskell) Use recursion instead of looping Generally optimize tail recursive functions Higher-order functions are common Functions take inputs and return results ONLY; they don t have side-effects Side-effect example: print( Hello ) Given same inputs, always get same output (referential transparency) Counterexample: function today() that gets today s date No re-binding of names Can t write x = 5; x = 6 Data structures never change (they are immutable) Can t write a = [1,2,3]; a.append(2) Python is NOT a functional language, but it does allow some functional elements

3 Higher Order Functions A higher order function is a function that takes one or more functions as input You ve already seen sorted(iterable, key = some_function) The classic higher-order functions are: map filter reduce

4 Map: Apply a function to each element of an iterable map(function, iterable) map object Examples: >>> m = map( (lambda x: x + is spooky ), [ Halloween, Candy, Tatiana ] ) >>> list(m) ['Halloween is spooky', 'Candy is spooky', 'Tatiana is spooky'] >>> [ x + is spooky for x in [ Halloween, Candy, Tatiana ] ] ['Halloween is spooky', 'Candy is spooky', 'Tatiana is spooky']

5 Implementing Map (Reference) map(function, iterable) map object # Generator version works for any iterable def map1(func, iterable): for item in iterable: yield func(item) # Recursive version only works for lists def map2(func, L): if L == []: return [] else: return [ func(l[0]) ] + map2(func, L[1:])

6 Filter: Keep elements of an iterable that match a predicate filter(predicate, iterable) filter object Example: A function that takes one input and returns a boolean >>> f = filter( (lambda x: x > 0 ), [10, 2, -1, 4, 0] ) >>> list(f) 10>0? 2>0? -1>0? 4>0? 0>0? [10, 2, 4] [10, 2, 4] >>> [ x for x in [10, 2, -1, 4, 0] if x > 0 ] [10, 2, 4] Am I a Predi Kit?

7 Reduce: Collect elements of an iterable into a single value from functools import reduce reduce(function, iterable) value (many possible types) Example: >>> from operator import add >>> f = reduce(add, [1,2,3,4,5]) 15 ( (1 + 2) + 3 ) + 4 ) + 5 = 15 >>> sum([1,2,3,4,5]) 15

8 Map & Filter are Mirrors of List Comps # Function that takes a tuple (thing, spookiness) # Returns True if the spookiness level is positive def spooky(x): thing, spookiness = x return spookiness > 0 >>> m = map( (lambda x: x[0] + is spooky ), filter(spooky, [( Halloween, 2), ( Candy, 1), ( Tatiana, 0)]) ) >>> list(m) Q1: What does this return? Q2: Convert this into a list comprehension. A1: [ Halloween is spooky, Candy is spooky ] A2: [ x[0] + is spooky for x in [( Halloween, 2), ( Candy, 1), ( Tatiana, 0)] if spooky(x) ]

9 Tail Recursion A function is tail recursive if it returns a recursive call with no other computation NOT tail recursive: def my_sum(l): if L == [] : return 0 else: return L[0] + my_sum(l[1:]) >>> my_sum([1,2,3]) 6 Tail recursive: def same_length(l1, L2): if L1 == [] or L2 == []: return L1 == L2 else: return same_length(l1[1:], L2[1:]) >>> same_length([ a, b ], [1,2]) True

10 Some Recursion can be written Tail Recursively NOT tail recursive: def my_sum(l): if L == []: return 0 else: return L[0] + my_sum(l[1:]) >>> my_sum([1,2,3]) 6 Tail recursive: def my_sum(l): return my_sum_helper(l, 0) def my_sum_helper(l, acc): if L == []: return acc else: return my_sum_helper(l[1:],acc + L[0]) Don t recurse on my tail!

11 Tail Recursion Can Always Be Written Iteratively Tail recursive: def my_sum(l): return my_sum_helper(l, 0) def my_sum_helper(l, acc): if L == []: return acc else: return my_sum_helper(l[1:],acc + L[0]) Iterative: def my_sum(l): acc = 0 while L!= []: acc = acc + L[0] L = L[1:] return acc Phew, I m safe! >>> my_sum([1,2,3]) 6 >>> my_sum([1,2,3]) 6

12 Try it: Convert my_len to tail recursion def my_len(l): if L == []: return 0 else: return 1 + my_len(l[1:]) >>> my_len([1,2,3]) 3 To get you started. def my_len(l): return my_len_helper(l, 0) def my_len_helper(l, acc): if : # base case return else: return my_len returns the length of a list

13 Answer: Tail Recursive my_len def my_len(l): return my_len_helper(l) def my_len_helper(l, acc): if L == []: return acc else: return my_len_helper(l[1:], acc + 1)

14 The Spooky Stamps Problem (aka Minimum Number of Stamps) In Halloweentown there are four denominations of stamps: Spider: 1 Pumpkin: 6 Cat: 14 Skull: 57 It costs 18 to send a postcard. What s the minimum number of stamps needed to send a postcard (without overpaying)?

15 The Spooky Stamps Problem (aka Minimum Number of Stamps) In Halloweentown there are four denominations of stamps: Spider: 1 Pumpkin: 6 Cat: 14 Skull: 57 COST = 18 STAMPS = (1, 6, 14, 57) (Incorrect) Temptation Grab the biggest stamp that works first This gives (14, 1, 1, 1, 1) 5 stamps Actual answer (6,6,6) 3 stamps We have to try every possibility - no shortcuts!

16 The Spooky Stamps Problem: Recursive Solution (aka Minimum Number of Stamps) In Halloweentown there are four denominations of stamps: Spider: 1 Pumpkin: 6 Cat: 14 Skull: 57 spooky_stamps(cost, stamps) cost = stamps = (1, 6, 14, 57) Base case? cost = 0 stamps = (1,6,14,57) min_stamps = 0

17 Solution: Spooky Stamps in General def spooky_stamps(cost, stamps): if cost == 0: return 0 else: Solve the problem for each stamp possible = [spooky_stamps(cost - stamp, stamps) for stamp in stamps if cost - stamp >= 0 ]) return 1 + min(possible) Get the best option out of the possibilities

18 This takes a long time! Each recursive call calls itself up to 4 times (because there are 4 stamps to check) The running time is EXPONENTIAL, meaning that this is VERY slow for large problems (i.e., when there are more stamps and/or higher cost)

19 This example recurs 210 times, but there are only 19 cases that need to be checked. On Friday, we ll see how to fix this problem. checking 18, (1, 6, 14, 57) checking 17, (1, 6, 14, 57) checking 16, (1, 6, 14, 57) checking 15, (1, 6, 14, 57) checking 14, (1, 6, 14, 57) checking 13, (1, 6, 14, 57) checking 12, (1, 6, 14, 57) checking 11, (1, 6, 14, 57) checking 10, (1, 6, 14, 57) checking 9, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 9, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 10, (1, 6, 14, 57) checking 9, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 11, (1, 6, 14, 57) checking 10, (1, 6, 14, 57) checking 9, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 12, (1, 6, 14, 57) checking 11, (1, 6, 14, 57) checking 10, (1, 6, 14, 57) checking 9, (1, 6, 14, 57) checking 8, (1, 6, 14, 57) checking 7, (1, 6, 14, 57) checking 6, (1, 6, 14, 57) checking 6, (1, 6, 14, 57)

20 Practice with Recursion Try it! Step 1: Write a (standard) recursive function my_len that returns the length of a list (Don t use the Python built-in function len) Step 2: Convert the my_len function to tail recursion Step 3: Convert the tail recursive function to an iterative function >>> my_len([1,2,3]) 3

21 Practice with Recursion (Step 1) def my_len(l): if L == []: return 0 else: return 1 + my_len(l[1:]) Try it! Step 1: Write a (standard) recursive function my_len that returns the length of a list Step 2: Convert the my_len function to tail recursion Step 3: Convert the tail recursive function to an iterative function

22 Practice with Recursion (Step 2) def my_len(l): return my_len_helper(l) def my_len_helper(l, acc): if L == []: return acc else: return my_len_helper(l[1:], acc + 1) Try it! Step 1: Write a (standard) recursive function my_len that returns the length of a list Step 2: Convert the my_len function to tail recursion Step 3: Convert the tail recursive function to an iterative function

23 Practice with Recursion (Step 3) def my_len(l): acc = 0 while L!= []: acc = acc + 1 L = L[1:] return acc Try it! Step 1: Write a (standard) recursive function my_len that returns the length of a list Step 2: Convert the my_len function to tail recursion Step 3: Convert the tail recursive function to an iterative function