0% found this document useful (0 votes)
42 views73 pages

Rekurzija Fantasticno!!!!

The document discusses recursion concepts through examples like computing factorials and lengths/sums of lists iteratively and recursively. It provides code examples and step-by-step workings of a recursive factorial function. Later sections include exercises on defining recursive functions for problems like finding the minimum element and checking membership in a list.

Uploaded by

Dragan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
42 views73 pages

Rekurzija Fantasticno!!!!

The document discusses recursion concepts through examples like computing factorials and lengths/sums of lists iteratively and recursively. It provides code examples and step-by-step workings of a recursive factorial function. Later sections include exercises on defining recursive functions for problems like finding the minimum element and checking membership in a list.

Uploaded by

Dragan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 73

Recursion: concepts,

examples, and makeChange

Acknowledgement: The following slides are


adopted, some with minor revisions, from
several lecture slides of the CS5 Green
course at Harvey Mudd.
Factorial: Iteration Code

n! = n(n-1)(n-2)…1

def factorial(n):
result = 1
for k in range(1, n+1):
result = result * k
return result
Recursion…

n! = n(n-1)(n-2)…1
n! = n  (n-1)! “inductive definition”
Recursion…

n! = n(n-1)(n-2)…1
n! = n x (n-1)! “inductive definition”
0! = 1 “base case”

Why is
0! = 1?
Math Induction = CS Recursion

Math Python (Functional)


inductive
recursive function
definition

0! = 1 # recursive factorial
def factorial(n):
n! = n  (n-1)! if n == 0:
return 1
else:
return n * factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)

return 2 * factorial(1)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)

return 2 * factorial(1)

return 1 * factorial(0)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)

return 2 * factorial(1)

1
return 1 * factorial(0)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)

return 2 * factorial(1)
1
return 1 * factorial(0)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3):
return 3 * factorial(2)
2
return 2 * factorial(1)
1
return 1 * factorial(0)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Is Recursion Magic?
factorial(3): 6
return 3 * factorial(2)
2
return 2 * factorial(1)
1
return 1 * factorial(0)

# recursive factorial
def factorial(n):
if n == 0:
return 1
else:
return n*factorial(n-1)
Computing the length of a list
>>> len([1, 42, “spam”]) Python has
3 this built-in!
>>> len([1, [2, [3, 4]]])
2

def len(L):
‘’’returns the length of list L’’’
Computing the length of a list
>>> len([1, 42, “spam”]) Python has
3 this built-
>>> len([1, [2, [3, 4]]]) in!
2

def len(L):
‘’’returns the length of list L’’’
if L == []: return 0 # base case
Computing the length of a list
>>> len([1, 42, “spam”])
3
>>> len([1, [2, [3, 4]]])
2

def len(L):
‘’’returns the length of list L’’’
if L == []: return 0 # base case
else: return 1 + len(L[1:])
Summing up the numbers in a list
>>> sum([3, 42, 7])
52 Python has
>>> sum([42]) this built-in
42 too!
>>> sum([])
0

def sum(L):
‘’’returns the sum of numbers in the list’’’

Worksheet
Summing up the numbers in a list
>>> sum([1, 42, 7])
50
>>> sum([42])
42 The base
>>> sum([]) case takes
0 care of the
simplest
case we
def sum(L): could get.
‘’’returns the sum of numbers in the list’’’
if L == []: return 0
Summing up the numbers in a list
>>> sum([1, 42, 7])
50
>>> sum([42])
42
>>> sum([])
0

def sum(L):
‘’’returns the sum of numbers in the list’’’
if L == []: return 0
else: return ???
Summing up the numbers in a list
>>> sum([1, 42, 7])
50
>>> sum([42])
42
>>> sum([])
0

def sum(L):
‘’’returns the sum of numbers in the list’’’
if L == []: return 0
else: return L[0] + sum(L[1:])
Recursion = :^)
“To understand recursion, you
must first understand recursion”
-anonymous Mudd alum
The following pages have
a number of exercises for
you to do (in your notes).
You’re welcome to work
at your own pace.

min
member
pal
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
if ??? # base case?
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
if len(L) == 1: return L[0] # base case!
return L[0]
else: return min(L[1:]
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
if len(L) == 1: return L[0] # base case!
elif L[0] < min(L[1:]): ???return L[0]
else: return min(L[1:]
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
if len(L) == 1: return L[0] # base case?
elif L[0] < min(L[1:]): return L[0]
else: return ???
Minimum! [ , , ]

>>> min([372, 112, 42, 451]) Assume that the list


42 always has at least one
>>> min([16]) number in it! Use len
as a helper function!
16

def min(L):
‘’’ returns smallest value in the list L ‘’’
if len(L) == 1: return L[0] # base case?
elif L[0] < min(L[1:]): return L[0]
else: return min(L[1:])
Member
(Skipped in Class, Study on your own)
>>> member(42, [1, 3, 5, 42, 7])
This is sort of like the “in”
True thing in Python, but don’t
>>> member(42, ['spam', 'is', 'yummy']) use “in” here. Just list
indexing, slicing, and
False
recursion!

def member(thing, myList):


‘’’ return True if thing in myList and
False otherwise. ‘’’
member
>>> member(42, [1, 3, 5, 42, 7])
True
>>> member(42, ['spam', 'is', 'yummy'])
False

def member(thing, myList):


if myList == []: return ??? # base case
member
>>> member(42, [1, 3, 5, 42, 7])
True
>>> member(42, ['spam', 'is', 'yummy'])
False

def member(thing, myList):


if myList == []: return False # base case
elif thing == myList[0]: return True
member
>>> member(42, [1, 3, 5, 42, 7])
True
>>> member(42, ['spam', 'is', 'yummy'])
False

def member(thing, myList):


if myList == []: return False # base case
elif thing == myList[0]: return True
else: return member(thing, myList[1:])
Palindrome?
(Skipped in Class, Study on your own)
>>> pal('radar')
True
>>> pal('amanaplanacanalpanama')
True
>>> pal('spam')
False

def pal(myString):
‘’’ returns True if myString is a
palindrome and False otherwise ‘’’
Palindrome?
>>> pal('radar')
True
>>> pal('amanaplanacanalpanama')
True
>>> pal('spam')
False

def pal(myString):
‘’’ returns True if myString is a
palindrome and False otherwise ‘’’
if len(myString) <= 1: return True # base case
Palindrome?
>>> pal('radar')
True
>>> pal('amanaplanacanalpanama')
True
>>> pal('spam')
False

def pal(myString):
‘’’ returns True if myString is a
palindrome and False otherwise ‘’’
if len(myString) <= 1: return True # base case
elif myString[0] != myString[-1]:
return False
else:
Palindrome?
>>> pal('radar')
True
>>> pal('amanaplanacanalpanama')
True
>>> pal('spam')
False

def pal(myString):
‘’’ returns True if myString is a
palindrome and False otherwise ‘’’
if len(myString) <= 1: return True # base case
elif myString[0] != myString[-1]:
return False
else: return pal(myString[1:-1])
Change

>>> change(42, [25, 10, 5, 1])


5
>>> change(42, [10, 5, 1])
6 But in Shmorbodia…

In this problem,
we’re allowed
to use a coin
denomination
as many times
as we want!
Change

>>> change(42, [25, 10, 5, 1])


5
>>> change(42, [10, 5, 1])
6
>>> change(42, [25, 21, 1])

In this problem,
we’re allowed
to use a coin
denomination
as many times
as we want!
Change
>>> change(42, [25, 21, 1])
2
Let’s make
change together!
def change(amount, Coins):
Change
>>> change(42, [25, 21, 1]) We’re making change!

def change(amount, Coins):


if amount == 0: return ???
Change
>>> change(42, [25, 21, 1]) We’re making change!

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return ???
Change
>>> change(42, [25, 21, 1]) We’re making change!

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
Change
>>> change(42, [25, 21, 1]) We’re making change!
2

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount: return ???
else:
useIt =

loseIt =

return _____________________________________________
Change
>>> change(42, [25, 21, 1]) Python has a built in min
2 function: min(42,5)is 5

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount: return change(amount, Coins[1:])
else:
useIt =

loseIt =

return min(useIt, loseIt)

Fill this in (in your notes)!


Change
>>> change(42, [25, 21, 1]) Python has a built in min
2 function: min(42,5)is 5

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount: return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)

loseIt =

return min(useIt, loseIt)

Fill this in (in your notes)!


Change
>>> change(42, [25, 21, 1]) Python has a built in min
2 function: min(42,5)is 5

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount: return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)

loseIt = change(amount, Coins[1:])

return min(useIt, loseIt)

Fill this in (in your notes)!


Change
>>> change(42, [25, 21, 1]) Python has a built in min
2 function: min(42,5)is 5

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount: return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)

loseIt = change(amount, Coins[1:])

return min(useIt, loseIt)

Fill this in (in your notes)!


change(10, [8, 5, 1]) cs124: a different example
done on the black board.
useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

useIt loseIt
def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
useIt loseIt if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

useIt loseIt
def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
useIt loseIt if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

useIt loseIt
def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt
It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

useIt loseIt
def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt
def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])

useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt 2 useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])
3
useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt 2 useIt loseIt

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])
3
useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt 2 2 useIt loseIt 10

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])
3 2
useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt 2 2 useIt loseIt 10

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [8, 5, 1])
3 2
useIt loseIt

1+change(2, [8, 5, 1]) change(10, [5, 1])

useIt loseIt 2 2 useIt loseIt 10

Forbidden! change(2, [5, 1]) 1+change(5, [5, 1]) change(10, [1])

useIt loseIt 2 useIt loseIt useIt loseIt

Forbidden! change(2, [ 1])

2 useIt loseIt inf


def change(amount, Coins):
1+change(1, [ 1]) change(2, [ ]) if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
1 useIt loseIt inf It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
else:
useIt = 1 + change(amount-It, Coins)
1+change(0, [ 1]) change(1, [ ]) loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
change(10, [4, 2, 1]) Another example
3 (done in class on
useIt Lose It the board)

1+change(6, [4, 2, 1]) change(10, [2, 1])

useIt loseIt useIt loseIt


2
1+change(2, [4, 2, 1]) change(6, [2, 1]) 1+change(8, [2, 1]) change(10, [1])
1
useIt loseIt useIt loseIt useIt loseIt

Forbidden! change(2, [2, 1]) 1+ change(6, [2, 1])

useIt loseIt def change(amount, Coins):


if amount == 0: return 0
elif Coins == []: return float(‘inf’)
else:
It = Coins[0]
if It > amount:
return change(amount, Coins[1:])
This works, but it’s slow! else:
useIt = 1 + change(amount-It, Coins)
There is repeated work!! loseIt = change(amount, Coins[1:])
return min(useIt, loseIt)
Check your note and read the
textbook for memoizing change…
Show the coins,
not just the number of coins
(Not covered in class, study on your own)

def change( amount, denominations ):


''' Returns the least number of coins required to make the given
amount using the list of provided denominations.'''
if amount == 0: return 0
elif denominations == []: return float('infinity')
elif denominations[0] > amount: return change(amount, denominations[1:])
else:
useIt = 1 + change(amount - denominations[0], denominations)
loseIt = change(amount, denominations[1:])
return min(useIt, loseIt)

>>> change(42, [25, 21, 1])


2

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0:
elif denominations == []:

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount:

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return showChange(amount, denominations[1:])

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return showChange(amount, denominations[1:])
else:
useIt = showChange(amount - denominations[0], denominations)

loseIt = showChange(amount, denominations[1:])

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return showChange(amount, denominations[1:])
else:
useIt = showChange(amount - denominations[0], denominations)

loseIt = showChange(amount, denominations[1:])

if useIt[0] <= loseIt[0]:


return useIt
else:
return loseIt

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return showChange(amount, denominations[1:])
else:
useIt = showChange(amount - denominations[0], denominations)
useIt = [useIt[0] +1, [denominations[0]] + useIt[1] ]

loseIt = showChange(amount, denominations[1:])

if useIt[0] <= loseIt[0]:


return useIt
else:
return loseIt

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
change and showChange return
different types
>>> change(42, [25, 21, 1])
2

>>> showChange(42, [25, 21, 1])


[2, [21, 21]]
A common mistake...
def change( amount, denominations ):
if amount == 0: return 0
elif denominations == []: return float('infinity')
elif denominations[0] > amount: return change(amount, denominations[1:])
else:
useIt = 1 + change(amount - denominations[0], denominations)
loseIt = change(amount, denominations[1:])
return min(useIt, loseIt)

def showChange( amount, denominations ):


if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return change(amount, denominations[1:])
else:
useIt = change(amount - denominations[0], denominations)
useIt = [useIt[0] +1, [denominations[0]] + useIt[1] ]

loseIt = change(amount, denominations[1:])

if useIt[0] <= loseIt[0]:


return useIt TypeError
else: schmype error!
return loseIt
showChange
def showChange( amount, denominations ):
''' Takes an integer amount and a list of possible
denominations. Returns a list containing two elements. First
the minimum number of coins required, and second a list of the
actual coins used in that solution.'''
if amount == 0: return [0, []]
elif denominations == []: return [float('infinity'), []]
elif denominations[0] > amount: return showChange(amount, denominations[1:])
else:
useIt = showChange(amount - denominations[0], denominations)
useIt = [useIt[0] +1, [denominations[0]] + useIt[1] ]

loseIt = showChange(amount, denominations[1:])

if useIt[0] <= loseIt[0]:


return useIt
else:
return loseIt

>>> showChange(42, [25, 21, 1])


[2, [21, 21]] Demo

You might also like