Eecs 110 lec 7 program planning
Download
1 / 39

EECS 110: Lec 7: Program Planning - PowerPoint PPT Presentation


  • 109 Views
  • Uploaded on

EECS 110: Lec 7: Program Planning. Aleksandar Kuzmanovic Northwestern University. http://networks.cs.northwestern.edu/EECS110-s14/. Midterm and Final. Midterm: Wednesday 4/30/2014 9:30am – 11:30am Kresge Centennial Hall 2415 Final: Wednesday 6/4/2014 9:30am – 11:30am

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' EECS 110: Lec 7: Program Planning' - israel


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Eecs 110 lec 7 program planning

EECS 110: Lec 7: Program Planning

Aleksandar Kuzmanovic

Northwestern University

http://networks.cs.northwestern.edu/EECS110-s14/


Midterm and final
Midterm and Final

  • Midterm:

    • Wednesday 4/30/2014

    • 9:30am – 11:30am

    • Kresge Centennial Hall 2415

  • Final:

    • Wednesday 6/4/2014

    • 9:30am – 11:30am

    • Kresge Centennial Hall 2415


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


(1)

What does chai draw?

def chai(size):

""" mystery! """

forward(size)

left(90)

forward(size/2.0)

right(90)

right(90)

forward(size)

left(90)

left(90)

forward(size/2.0)

right(90)

backward(size)

Why are there two identical commands in a row?


(2)

Finish rwalk to draw a "stock-market-type" random path of nsteps steps.

from random import *

def rw(nsteps):

""" moving for nsteps steps, randomly

45 deg. left/up or right/down """

if nsteps == 0:

return

if choice(['left','right']) == 'left':

left(45)

forward(20)

right(45)

else: # 'right‘

right(45)

forward(20)

left(45)

return rw(nsteps-1)

one possible result of rw(20)

What if we didn't go back to the starting pose?


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!

def rps(p1,p2):

""" rock-paper-scissors judger """

if 'p1' == 'p2':

return 0

The string 'p1' is not the same as the variable p1 !

def rps(p1,p2):

""" rock-paper-scissors judger """

if p1 == p2:

return '0'

The string '0' is not the same as the number 0 !

no docstring!

def letterscore(let):

if let in 'zq':

return 10 …(lots more)…

Capital letters count! (It should be letterScore.)


What CS is really about

thinking like a machine

variables

42

storage

int

guess

sequences

'w'

'a'

'r'

't'

str

s[1]

str

s[2]

str

s[3]

str

s[0]

if…elif…else

making decisions

“high” or “low”

recursion

repeated actions


What CS is really about

thinking like a machine

thinking for a machine

variables

library

42

storage

int

guess

deciding how to use these tools

sequences

functions

'w'

'a'

'r'

't'

str

s[1]

str

s[2]

str

s[3]

str

s[0]

creating your own tools ...

if…elif…else

classes

making decisions

creating your own data structures ...

“high” or “low”

(later)

recursion

repeated actions


Top-down program design

Given: a description of the problem

translation!

Wanted: a function that solves it


Top-down program design

Given: a description of the problem

translation!

Wanted: a function that solves it

with as much detail as possible

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)

variables, lists, if…elif…else, recursion

  • What do you need for each?

  • 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

translation!

Wanted: a function that solves it

with as much detail as possible

1. Visualize what the program will do

2. Break up the work into a set of smaller tasks

How to do this…

3. Compose solutions for these tasks (functions)

variables, lists, if…elif…else, recursion

  • What do you need for each?

  • 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!': return 1 + MCMH( init, sors, N-1 )

else: 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])

removeOne('p', 'computer programming')

'comuter programming'

[5,7,8,42]


max

A recipe for life ?

and python already has it for us…

The hard part is knowing what we want to maximize!


Google Inc

to themax

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 ] # LOL

bestPair = max( LOL )

return bestPair[1]


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[1]


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"

Name(s):

Nothing but the best!

abs( x ) is built-in to Python

Hints:

Use bestWord as a guide:

Write this function usingmax/min or recursively:

def bestWord( L ):

""" example code """

LOL = [ [scsc(w), w] for w in L ]

bestPair = max( LOL )

return bestPair[1]

def bestNumber( L ):

""" returns the # in L closest to 42 """

Hint:

Write this function however you like:

Consider defining a helper function !

def mode( L ):

""" returns the element appearing most often in L """


"Quiz"

abs( x ) is built-in to Python

Hints:

Solutions…

Use bestWord as a guide:

def bestWord( L ):

""" example code """

LOL = [ [scsc(w), w] for w in L ]

bestPair = max( LOL )

return bestPair[1]

Write this function usingmax/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…

Hint:

Write this function however you like:

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]

returnmax(LOL)[1]


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])

removeOne('p', 'computer programming')

'comuter programming'

[5,7,8,42]


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 )



ad