EECS 110: Lec 7: Program Planning Aleksandar Kuzmanovic Northwestern University

The not-so-subtle art of singling out the best (and worst) of anything… Lights On! for fun and safety Computing to the max Hw #3 due Sunday… How to break apart a tough problem EECS 110 Today

Notes from prior hwks… Warnings! def rps(p1,p2): """ rock-paper-scissors judger """ if 'p1' == 'p2': return 0 def letterscore(let): if let in 'zq': return 10 …(lots more)… def rps(p1,p2): if p1 == p2: return '0'

Notes from prior hwks… Warnings! def rps(p1,p2): """ rock-paper-scissors judger """ if 'p1' == 'p2': return 0 def letterscore(let): if let in 'zq': return 10 …(lots more)… def rps(p1,p2): """ rock-paper-scissors judger """ if p1 == p2: return '0' The string 'p1' is not the same as the variable p1 ! The string '0' is not the same as the number 0 ! Capital letters count! (It should be letterScore.) no docstring!

What CS is really about recursion variables if…elif…else making decisions storage repeated actions “high” or “low” int guess 42 thinking like a machine sequences 'w''a''r''t' str s[0] str s[1] str s[2] str s[3]

thinking like a machinethinking for a machine What CS is really about recursion variables if…elif…else making decisions storage repeated actions “high” or “low” int guess 42 sequences str s[0] str s[1] str s[2] str s[3] 'w''a''r''t' deciding how to use these tools library functions creating your own tools... classes creating your own data structures... (later)

Top-down program design Given: a description of the problem Wanted: a function that solves it translation!

Top-down program design Given: a description of the problem 1. Visualize what the program will do 2. Break up the work into a set of smaller tasks 3. Compose solutions for these tasks (functions) Wanted: a function that solves it Are these tasks still too big? if so, go to step 1… What do you need for each? 1. Visualize what the function will do... translation! with as much detail as possible variables, lists, if…elif…else, recursion

Top-down program design Given: a description of the problem 1. Visualize what the program will do 2. Break up the work into a set of smaller tasks 3. Compose solutions for these tasks (functions) Wanted: a function that solves it Are these tasks still too big? if so, go to step 1… What do you need for each? 1. Visualize what the function will do... translation! with as much detail as possible variables, lists, if…elif…else, recursion How to do this…

Monte Carlo Monty Hall Suppose you always switch to the other door... What are the chances that you will win the car ? Run it (randomly) 1000 times and see! How can we write MCMH?

Monte Carlo Monty Hall How can we write MCMH? What data do we need to keep track of? What is the input/output of your function?

Monte Carlo Monty Hall How can we write MCMH? What specific actions does your function need to take?

Monte Carlo Monty Hall How can we write MCMH? Put it all together into an algorithm…

Monte Carlo Monty Hall def MCMH( init, sors, N ): """ plays the same "Let's make a deal" game, N times returns the number of times you win the car """ if N == 0: return 0 # don't play, can't win carDoor = choice([1,2,3]) # where is the car? if init == carDoor and sors == 'stay': result = 'Car!' elif init == carDoor and sors == 'switch': result = 'Spam.' elif init != carDoor and sors == 'switch': result = 'Car!' else: result = 'Spam.' print 'You get the', result if result == 'Car!': return 1 + MCMH( init, sors, N-1 ) else: return 0 + MCMH( init, sors, N-1 ) Then translate the algorithm to code!

Sorting a List What data do we need to keep track of? What is the input/output of the function?

Sorting a List If we had an easy way to find the maximum of the list, how could we use this to sort the list?

Taking only one… def removeOne( e, L ): """ this function removes one element e from the top level of the list L """ if len(L) == 0: return L # L is empty elif e == L[0]: return L[1:] # remove this one else: return L[0:1] + removeOne(e,L[1:]) # keep the non-e element and then keep going removeOne(42, [5,7,42,8,42]) [5,7,8,42] removeOne('p', 'computer programming') 'comuter programming'

max A recipe for life ? The hard part is knowing what we want to maximize! and python already has it for us…

to the max If we want the highest price… What if the months are in there, as well? max( [449.5, 580.0, 562.4, 481.3, 498.3, 414.5] ) 'sep''aug''jul''jun''may''apr' max([ [449.5,'apr'], [580.0,'may'], [562.4,'jun'], [481.3,'jul'], [498.3,'aug'], [414.5,'sep'] ]) Google Inc

"Best" word def scrabbleScore(w): # see homework #1! def bestWord( L ): """ finds the "best" word from L, a list of words here, "best" means highest scrabble score """ Let's abbreviate this function as scsc(w)

"Best" word def scrabbleScore(w): # see homework #1! def bestWord( L ): """ finds the "best" word from L, a list of words here, "best" means highest scrabble score """ if len(L) < 2: return elif return else: return Let's abbreviate this function as scsc(w)

"Best" word def scrabbleScore(w): # see homework #1! def bestWord( L ): """ finds the "best" word from L, a list of words here, "best" means highest scrabble score """ if len(L) < 2: return L[0] elif scsc(L[0]) < scsc(L[1]): return bestWord( L[1:] ) else: return bestWord( L[0:1] + L[2:] ) Let's abbreviate this function as scsc(w)

A suggestion def bestWord( L ): """ returns the word in L w/max scrabble score """ LOL = [ [scsc(w), w] for w in L ] # LOL bestPair = max( LOL ) return bestPair def scrabbleScore(w): # see homework #1! Let's abbreviate this function as scsc(w)

The last word on bestWord def scrabbleScore(w): # see homework #1! def bestWord( L ): """ finds the "best" word from L, a list of words here, "best" means highest scrabble score """ if len(L) < 2: return L[0] elif scsc(L[0]) < scsc(L[1]): return bestWord( L[1:] ) else: return bestWord( L[0:1] + L[2:] ) Let's abbreviate this function as scsc(w) def bestWord( L ): """ returns the word in L w/max scrabble score """ LOL = [ [scsc(w), w] for w in L ] bestPair = max( LOL ) return bestPair using raw recursion using max

Examples >>> bestNumber( [ 10, 20, 30, 40, 50, 60, 70 ] ) 40 >>> bestNumber( [ 100, 200, 300, 400 ] ) 100 >>> bestNumber( [ 1, 2, 3, 4, 5, 6, 7, 8, 7 ] ) 8 >>> mode( [ 1, 2, 3, 4, 5, 6, 7, 8, 7 ] ) 7 What is bestNumber ? mode ?

"Quiz" def bestNumber( L ): """ returns the # in L closest to 42 """ def mode( L ): """ returns the element appearing most often in L """ Name(s): Nothing but the best! Hint: Consider defining a helper function ! Hints: abs( x ) is built-in to Python Use bestWord as a guide: Write this function using max/min or recursively : Write this function however you like: def bestWord( L ): """ example code """ LOL = [ [scsc(w), w] for w in L ] bestPair = max( LOL ) return bestPair

"Quiz" Solutions… def bestNumber( L ): """ returns the # in L closest to 42 ""“ LOL = [ [abs(w-42), w] for w in L ] bestPair = min( LOL ) return bestPair[1] Write this function using max/min : Hints: abs( x ) is built-in to Python Use bestWord as a guide: def bestWord( L ): """ example code """ LOL = [ [scsc(w), w] for w in L ] bestPair = max( LOL ) return bestPair

"Quiz" Solutions… def mode( L ): """ returns the element appearing most often in L """ LOL = [[numberOfTimes(w,L),w] for w in L] return max(LOL)[1] Hint: Consider defining a helper function ! Write this function however you like: def numberOfTimes( w, L ): """ returns the # in times w repeats in L """ return sum([k==w for k in L])

sort(L) def sort( L ): """ a list of elements in L, sorted from hi to low """ if len(L) < 1: return L else:

sort(L) def sort( L ): """ a list of elements in L, sorted from hi to low """ if len(L) < 1: return L else: return [max(L)] + sort(removeOne( max(L), L ))

sort(L, maxFun) def sort( L, maxFun ): """ a list of elements in L, sorted using maxFun """ if len(L) < 1: return L else: return

sort(L, maxFun) def sort( L, maxFun ): """ a list of elements in L, sorted using maxFun """ if len(L) < 1: return L else: return [maxFun(L)] + sort(removeOne( maxFun(L), L )) Will this work?

sort(L, maxFun) def sort( L, maxFun ): """ a list of elements in L, sorted using maxFun """ if len(L) < 1: return L else: return [maxFun(L)] + sort(removeOne( maxFun(L), L ), maxFun)

sort(L, maxFun) def sort( L, maxFun ): """ a list of elements in L, sorted using maxFun """ if len(L) < 1: return L else: return [maxFun(L)] + sort(removeOne( maxFun(L), L ), maxFun) What happens if you call >>>sort( L, min )

See you in Lab !