EECS 110: Lec 7:
Program Planning
Aleksandar Kuzmanovic
Northwestern University
http://cs.northwestern.edu/~akuzma/classes/EECS110-s09/
EECS 110 Today
Computing to the max
The not-so-subtle art of singling out the
best (and worst) of anything…
Hw #3 due
Sunday…
Lights On!
for fun and safety
How to break apart a tough problem
Notes from prior hwks…
Warnings!
def rps(p1,p2):
""" rock-paper-scissors judger """
if 'p1' == 'p2':
return 0
def rps(p1,p2):
if p1 == p2:
return '0'
def letterscore(let):
if let in 'zq':
return 10 …(lots more)…
Notes from prior hwks…
Warnings!
The string 'p1' is not the
same as the variable p1 !
The string '0' is not the
same as the number 0 !
def rps(p1,p2):
""" rock-paper-scissors judger """
if 'p1' == 'p2':
return 0
def rps(p1,p2):
""" rock-paper-scissors judger """
if p1 == p2:
return '0'
no docstring!
Capital letters count! (It
should be letterScore.)
def letterscore(let):
if let in 'zq':
return 10 …(lots more)…
What CS is really about
thinking like a machine
variables
storage
int
guess
sequences
str
s[0]
str
s[1]
str
s[2]
str
s[3]
if…elif…else
making decisions
“high” or “low”
recursion
repeated actions
What CS is really about
thinking like a machine
variables
storage
thinking for a machine
library
int
guess
deciding how to use these tools
sequences
str
s[0]
str
s[1]
str
s[2]
str
s[3]
if…elif…else
making decisions
“high” or “low”
recursion
repeated actions
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
Wanted:
a function that solves it
1. Visualize what the program will do
translation!
with as much
detail as possible
2. Break up the work into a set of smaller tasks
3. Compose solutions for these tasks (functions)
• What do you need for each?
variables, lists,
if…elif…else, recursion
• Are these tasks still too big? if so, go to step 1…
1. Visualize what the function will do ...
Top-down program design
Given:
a description of the problem
Wanted:
a function that solves it
1. Visualize what the program will do
translation!
with as much
detail as possible
2. Break up the work into a set of smaller tasks
How to do this…
3. Compose solutions for these tasks (functions)
• What do you need for each?
variables, lists,
if…elif…else, recursion
• Are these tasks still too big? if so, go to step 1…
1. Visualize what the function will do ...
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 is the input/output of your function?
What data do we need to keep track of?
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
Then translate the algorithm to code!
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!':
else:
return 1 + MCMH( init, sors, N-1 )
return 0 + MCMH( init, sors, N-1 )
Sorting a List
Sorting a List
What is the input/output of the function?
What data do we need to keep track of?
Sorting a List
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 ?
and python already has it for us…
The hard part is knowing what we want to maximize!
to the max
Google Inc
If we want the highest price…
max( [449.5, 580.0, 562.4, 481.3, 498.3, 414.5] )
'apr'
'may'
'jun'
'jul'
'aug'
'sep'
What if the months are in there, as well?
max([ [449.5,'apr'], [580.0,'may'], [562.4,'jun'],
[481.3,'jul'], [498.3,'aug'], [414.5,'sep'] ])
"Best" word
def scrabbleScore(w):
# see homework #1!
Let's abbreviate this function as
scsc(w)
def bestWord( L ):
""" finds the "best" word from L, a list of words
here, "best" means highest scrabble score """
"Best" word
def scrabbleScore(w):
# see homework #1!
Let's abbreviate this function as
scsc(w)
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
"Best" word
def scrabbleScore(w):
# see homework #1!
Let's abbreviate this function as
scsc(w)
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:] )
A suggestion
def scrabbleScore(w):
# see homework #1!
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
]
# LOL
The last word on bestWord
def scrabbleScore(w):
# see homework #1!
Let's abbreviate this function as
scsc(w)
using raw recursion
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:] )
using max
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
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"
Nothing but the best!
Name(s):
Hints:
Write this function using max/min or recursively :
def bestNumber( L ):
""" returns the # in L closest to 42 """
Write this function however you like:
Hint:
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
Consider defining a helper function !
def mode( L ):
""" returns the element appearing most often in L """
]
"Quiz"
Solutions…
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
Write this function using max/min:
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]
]
"Quiz"
Solutions…
Write this function however you like:
Hint:
Consider defining a helper function !
def numberOfTimes( w, L ):
""" returns the # in times w repeats in L """
return sum([k==w for k in L])
def mode( L ):
""" returns the element appearing most often in L """
LOL = [[numberOfTimes(w,L),w] for w in L]
return max(LOL)[1]
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 !