Introduction to Recursion (Python)

RecursionExtracted from my lecture during A. Paruj Ratanaworabhan’s
basic preparatory programming course for freshmen:
Introduction to Programming: A Tutorial for New Comers Using Python
By Thai Pangsakulyanont
Software and Knowledge Engineering Undergraduate Student
Kasetsart University

http://greatingpoint.co.th/?
showpage=product&ﬁle=product_detail&prd_id=1328776222

Read this sentence and
do what it says twice.
http://programmers.stackexchange.com/a/93858

n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0

Factorial Example
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
3!

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
We turn this problem into a
smaller problem of same kind.
This is called “decomposition.”

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1
= 0! × 1

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1
= 0! × 1
0! = 1

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1
= 0! × 1
0! = 1
This is called the “base case”
where the function does not
call itself anymore.

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1
= 0! × 1
= 1 × 1 = 1

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
1! = (1 - 1)! × 1
= 0! × 1
= 1 × 1 = 1
We use the result of smaller problem
to find the result of larger problem.
This is called “composition”.

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
2! = (2 - 1)! × 2
= 1! × 2
= 1 × 2 = 2

Factorial Example
3!
n! =
(
1 if n = 0
(n 1)! ⇥ n if n > 0
= (3 - 1)! × 3
= 2! × 3
= 2 × 3
= 6.

def fac(n):
if n == 0:
return 1
else:
return fac(n - 1) * n
print fac(12)
Factorial Example

Recursive Function
• A function that calls itself!

Count Down
countdown(5)
print "happy recursion day"

Countdown Algorithm
• If I want to countdown from 0,
then it’s over! Don’t do anything.
• If I want to countdown from N (> 0),
then count N, and countdown from N-1.

Countdown Example
def countdown(n):
if n == 0:
return
print n
countdown(n - 1)
countdown(5)
print "happy recursion day"

Example:
Euclidean Algorithm
• Fast way to ﬁnd a GCD
of two numbers.

Example:
Euclidean Algorithm
If you have 2 numbers,
then you subtract the smaller number
from the larger number, the GCD of these
two number stays the same.

Example:
Euclidean Algorithm
68 119
GCD(68, 119) is 17

Example:
Euclidean Algorithm
68 119
GCD(68, 51) is still 17
68 51

Example:
Euclidean Algorithm
If you have 2 numbers,
then you subtract the smaller number
from the larger number, the GCD of these
two number stays the same.
Keep doing that until the two numbers
equal each other, then that number is the GCD.

Example:
Euclidean Algorithm
GCD(68, 119)

Example:
Euclidean Algorithm
GCD(68, 119) = GCD(68, 51)

Example:
Euclidean Algorithm
GCD(68, 119) = GCD(68, 51)
= GCD(17, 51)

Example:
Euclidean Algorithm
GCD(68, 119) = GCD(68, 51)
= GCD(17, 51)
= GCD(17, 34)

Example:
Euclidean Algorithm
GCD(68, 119) = GCD(68, 51)
= GCD(17, 51)
= GCD(17, 34)
= GCD(17, 17)

Example:
Euclidean Algorithm
GCD(68, 119) = GCD(68, 51)
= GCD(17, 51)
= GCD(17, 34)
= GCD(17, 17)
= 17

Example:
Euclidean Algorithm
def gcd(a, b):
if a < b:
return gcd(a, b - a)
elif b < a:
return gcd(a - b, b)
else:
return a
print gcd(68, 119)

Who Says It’s Fast?
print gcd(21991144, 21)
# = gcd(21991123, 21)
# = gcd(21991102, 21)
# = gcd(21991081, 21)
# = gcd(21991060, 21)
# = gcd(21991039, 21)
# = gcd(21991018, 21)
# = gcd(21990997, 21)
# = gcd(21990976, 21)

It’s Actually Really Fast
Consider:
(56, 10) → (46, 10) → (36, 10) →
(26, 10) → (16, 10) → (6, 10)
56 % 10 = 6
(the rest of this is for your exercise)

Why Recursion?
• Sometimes it’s easier to write and read
code in recursive form.

Why Recursion?
• You can always convert an iterative
algorithm to recursive and vice versa.

Why Recursion?
• You can always convert an iterative
algorithm to recursive and vice versa.
(does not mean it’s easy)

Iterative
Euclidean Algorithm
def gcd(a, b):
while a != b:
if a < b:
b = b - a
elif b < a:
a = a - b
return a
print gcd(68, 119)

Remember?
• Decomposition
• Base Case
• Composition

String Reversal
• Given a string, I want a reversed version
of that string.
print reverse("reenigne")
# => “engineer”

String Reversal
• Let’s think recursively!
reenigne

Recursive Case
r enginee
eenigne
somehow

e
eenigne
enignee
engine
enginee

Base Case
• The reverse of an empty string is an
empty string.

Recursive Algorithm
reverse(“Hello”)

Recursive Algorithm
reverse(“Hello”) = reverse(“ello”) + “H”

Recursive Algorithm
reverse(“ello”) = reverse(“llo”) + “e”

Recursive Algorithm
reverse(“llo”) = reverse(“lo”) + “l”

Recursive Algorithm
reverse(“lo”) = reverse(“o”) + “l”

Recursive Algorithm
reverse(“o”) = reverse(“”) + “o”

Recursive Algorithm
reverse(“”) = “”

Recursive Algorithm
= “” + “o” = “o”

Recursive Algorithm
= “o” + “l” = “ol”

Recursive Algorithm
= “ol” + “l” = “oll”

Recursive Algorithm
= “oll” + “e” = “olle”

Recursive Algorithm
= “olle” + “H”
= “olleH”

Reverse Example
def reverse(str):
if str == "":
return str # or return “”
else:
return reverse(str[1:]) + str[0]
print reverse("reenigne")

print sum_digits(314159265) # => 36
Sum of Digits

print sum_digits(314159265) # => 36
Sum of Digits
• NO LOOPS!
• NO STRINGS!

Recursive Algorithm
• Sum of digits of 0 is 0.
• Sum of digits of N > 0:
Find last digit + sum of digits except last.

Recursive Algorithm
• Sum of digits of 0 is 0.
• Sum of digits of N > 0:
Find last digit + sum of digits except last.
N % 10 N // 10

Sum of Digits
def sum_digits(n):
if n == 0:
return 0
else:
return (n % 10) + sum_digits(n // 10)
print sum_digits(314159265)

Palindrome
Civic
Level
Madam
Malayalam
Radar
Reviver
Rotator
Terret

print is_palindrome("Refer") # => True
print is_palindrome("Referrer") # => False

Recursive Algorithm
• Empty string is a palindrome.
• String with 1 character is a palindrome.
• String that has a different ﬁrst character
and last character is not a palindrome.

Recursive Algorithm
• Empty string is a palindrome.
• String with 1 character is a palindrome.
• String that has a different first character
and last character is not a palindrome.
• String that has a same first and last
character is a palindrome only if the
string without first and last character is a
palindrome.

def is_palindrome(s):
if len(s) < 2:
return True
if s[0].lower() != s[-1].lower():
return False
return is_palindrome(s[1:-1])

def is_palindrome(s):
return reverse(s.lower()) == s.lower()
def reverse(str):
if str == "":
return str
else:
return reverse(str[1:]) + str[0]

Introduction to Recursion (Python)

More Related Content

What's hot

Similar to Introduction to Recursion (Python)

Recently uploaded

In this document

Introduction to Recursion (Python)