0% found this document useful (0 votes)
154 views

20 Recursion Practice Questions

The document provides 20 recursive programming challenges involving functions such as factorial, summation, reversing uppercase and lowercase letters in a string, counting and summing elements in nested lists, and more. The functions utilize base cases and recursive calls to iteratively solve each problem. Sample inputs and outputs are provided to test the functions.
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)
154 views

20 Recursion Practice Questions

The document provides 20 recursive programming challenges involving functions such as factorial, summation, reversing uppercase and lowercase letters in a string, counting and summing elements in nested lists, and more. The functions utilize base cases and recursive calls to iteratively solve each problem. Sample inputs and outputs are provided to test the functions.
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/ 31

1) Factorial

Write a recursive function factorial(n) that takes in a positive integer n, and returns the
factorial of n. The factorial of n is 1 x 2 x 3 x … x n.

factorial(1) # 1
factorial(2) # 2
factorial(3) # 6
factorial(4) # 24
factorial(5) # 120
factorial(6) # 720
factorial(7) # 5040
factorial(8) # 40320

2) Summation
Write a recursive function summation(n) that takes in a positive integer n, and returns the
summation of n. The summation of n is 1 + 2 + 3 + … + n

summation(1) # 1
summation(2) # 3
summation(3) # 6
summation(4) # 10
summation(5) # 15
summation(6) # 21
summation(7) # 28
summation(8) # 36

3) Reversing Uppercase And Lowercase


Write a recursive function reverse(string) that takes in a string, and returns the same string,
but with uppercase and lowercase letters reversed. Originally uppercase letters should
become lowercase, and vice versa.

reverse('apple') # APPLE
reverse('Apple') # aPPLE
reverse('AppLe') # aPPlE
reverse('APPLE') # apple
4) Sum Of Odd Numbers
Write a recursive function sum_odd(numbers) that takes in a list of integers, and returns the
sum of ONLY the odd numbers.

sum_odd([1,2,3,4]) # 4
sum_odd([1,2,3,4,5]) # 9
sum_odd([1,2,4,6,8]) # 1
sum_odd([]) # 0
sum_odd([2,4,6,8]) # 0

5) Add Odd Numbers, Subtract Even Numbers


Write a recursive function add_sub(numbers) that takes in a list of integers. It sums up all
ODD numbers, but subtracts all EVEN numbers.

add_sub([1,2,3,4]) # -2
add_sub([1,2,3,4,5]) # 3
add_sub([1,3,5]) # 9
add_sub([2,4,6]) # -12
add_sub([99,10,10]) # 79

6) Counting Vowels
Write a recursive function count_vowels(string) that takes in a string, and counts the number
of vowels inside the string. Vowels include a, e, i, o, and u.

count_vowels('apple') # 2
count_vowels('orange') # 3
count_vowels('pear') # 2
count_vowels('pineapple') # 4
count_vowels('durian') # 3
7) Removing Vowels
Write a recursive function remove_vowels(string) that takes in a string, and returns another
string with ALL vowels removed. Vowels include a, e, i, o, and u.

remove_vowels('apple') # ppl
remove_vowels('orange') # rng
remove_vowels('pear') # pr
remove_vowels('pineapple') # pnppl
remove_vowels('durian') # drn

8) Replacing Vowels
Write a recursive function replace_vowels(string) that takes in a string, and replaces all
vowels with its 'next' vowel.
● replace 'a' with 'e'
● replace 'e' with 'i'
● replace 'i' with 'o'
● replace 'o' with 'u'
● replace 'u' with 'a'

replace_vowels('apple') # eppli
replace_vowels('orange') # urengi
replace_vowels('pear') # pier
replace_vowels('pineapple') # ponieppli
replace_vowels('durian') # daroen

9) Double Letters
Write a recursive function double_letters(string) that takes in a string, and doubles each
character inside the original string.

double_letters('apple') # aappppllee
double_letters('orange') # oorraannggee
double_letters('pear') # ppeeaarr
double_letters('pineapple') # ppiinneeaappppllee
double_letters('durian') # dduurriiaann
10) Palindromes
A palindrome is a word that is the same backward as it is forward.

Examples of palindromes:
● aaa
● aba
● ababa
● abcba
● mom
● moom

Examples of NON-palindromes:
● aaab
● abab
● ababab
● abcda
● moms

Write a recursive function is_palindrome(string) that takes in a string, and returns True if the
string is a palindrome, and False if the string is NOT a palindrome.

is_palindrome('apple') # False
is_palindrome('ababab') # False
is_palindrome('abcda') # False
is_palindrome('aaaba') # False
is_palindrome('aaaab') # False

is_palindrome('aba') # True
is_palindrome('abba') # True
is_palindrome('aaaaaa') # True
is_palindrome('moooom') # True
is_palindrome('mooooom') # True
11) Number Pyramid
Write a recursive function number_pyramid(n) that takes in a positive integer n, and prints
the following number pyramid of height n.

# number_pyramid(3)
1
12
123

# number_pyramid(5)
1
12
123
1234
12345

12) Reverse Number Pyramid


Write a recursive function reversed_pyramid(n) that takes in a positive integer n, and prints
the following reversed number pyramid of height n.

# reverse_pyramid(3)
321
21
1

# reverse_pyramid(5)
54321
4321
321
21
1
13) Spaced Number Pyramid
Write a recursive function spaced_pyramid(n) that takes in a positive integer n, and prints
the following spaced number pyramid of height n.

# spaced_pyramid(3)
1
12
123

# spaced_pyramid(5)
1
12
123
1234
12345

14) Fibonacci Numbers


Fibonacci numbers are a sequence of numbers:
● That begin with 0 and 1
● Where each new number is the sum of the previous 2 numbers.

The first 10 numbers go 0, 1, 1, 2, 3, 5, 8, 13, 21, 34. Write a recursive function fib(n) that
takes in a positive integer n, and returns the nth fibonacci number.

fib(1) # 0
fib(2) # 1
fib(3) # 1
fib(4) # 2
fib(5) # 3
fib(6) # 5
fib(7) # 8
fib(8) # 13
fib(9) # 21
fib(10) # 34
15) Pascal's Triangle
This is Pascal's triangle:

Except the top 2 rows, each new row can be derived from the previous row:
1. Add each adjacent pair of numbers
2. Insert 2 1's at both ends

Write a recursive function pascal(n) that takes in an integer n, and returns the nth row of
Pascal's triangle as a list of numbers.

pascal(1) # [1]
pascal(2) # [1, 1]
pascal(3) # [1, 2, 1]
pascal(4) # [1, 3, 3, 1]
pascal(5) # [1, 4, 6, 4 ,1]
pascal(6) # [1, 5, 10, 10, 5, 1]
pascal(7) # [1, 6, 15, 20, 15, 6, 1]
pascal(8) # [1, 7, 21, 35, 35, 21, 7, 1]
16) Switching Every 2 Numbers
You are given a list of integers. Write a recursive function switch2(lis) that takes in this list of
integers, and switches every 2 elements in the list.

Note – If the length of the input list is an odd number, simply ignore the last element.

switch2([1, 2, 3]) # [2, 1, 3]


switch2([1, 2, 3, 4]) # [2, 1, 4, 3]
switch2([1, 2, 3, 4, 5]) # [2, 1, 4, 3, 5]
switch2([1, 2, 3, 4, 5, 6]) # [2, 1, 4, 3, 6, 5]

17) Plus Signs


Write a recursive function plus(n) that takes in a positive integer n, and returns a string
containing all numbers from 1 to n, with + characters in between them.

plus(1) # 1
plus(2) # 1+2
plus(3) # 1+2+3
plus(4) # 1+2+3+4
plus(5) # 1+2+3+4+5

18) Alternate Signs


Write a recursive function alternate(n) that takes in a positive integer n, and returns a string
containing all number from 1 to n, with alternating + and - characters in between them
(starting with a + character)

alternate(1) # 1
alternate(2) # 1+2
alternate(3) # 1+2-3
alternate(4) # 1+2-3+4
alternate(5) # 1+2-3+4-5
19) Counting Elements In Nested List
You are given a messy nested list of numbers. Elements are either integers, list of integers,
or nested list of integers.

Write a recursive function count(lis) that takes in this nested list, and counts the total number
of integers inside the entire nested list.

lis = [1, 2, 3, 4, 5]
count(lis) # 5

lis = [1, 2, [3, 4], 5]


count(lis) # 5

lis = [[1, 2], [3, 4], 5]


count(lis) # 5

lis = [1, [2, [3, [4], 5]]]


count(lis) # 5

lis = [[[1], [2], [3], [4], [5]]]


count(lis) # 5

20) Sum of Nested List


You are given a messy nested list similar to that in question 19. The nested list contains only
integers, lists of integers, or nested lists of integers.

Write a recursive function nested_sum(lis) that takes in a nested list as stated above, and
returns the sum of all integers inside that list.

lis = [1, 2, 3, 4, 5]
nested_sum(lis) # 15

lis = [1, 2, [3, 4], 5]


nested_sum(lis) # 15

lis = [[1, 2], [3, 4], 5]


nested_sum(lis) # 15

lis = [1, [2, [3, [4], 5]]]


nested_sum(lis) # 15

lis = [[[1], [2], [3], [4], [5]]]


nested_sum(lis) # 15
ANSWERS

1) Factorial
def factorial(n):
if n == 1:
return 1

return n * factorial(n-1)

How this works:

# Base case
if n == 1, We simply return 1

# Recursive step
return n * factorial(n-1)

# Using n=5

factorial(1) = 1

factorial(2) = 2 x factorial(1)
= 2 x 1
= 2

factorial(3) = 3 x factorial(2)
= 3 x 2
= 6

factorial(4) = 4 x factorial(3)
= 4 x 6
= 24

factorial(5) = 5 x factorial(4)
= 5 x 24
= 120
2) Summation
def summation(n):
if n == 1:
return 1

return n + summation(n-1)

How this works:

# Base case
if n == 1, We simply return 1

# Recursive step
return n + summation(n-1)

# Using n=5

summation(1) = 1

summation(2) = 2 + summation(1)
= 2 + 1
= 3

summation(3) = 3 + summation(2)
= 3 + 3
= 6

summation(4) = 4 + summation(3)
= 4 + 6
= 10

summation(5) = 5 + summation(4)
= 5 + 10
= 15
3) Reversing Uppercase And Lowercase
def reverse(string):
if len(string) == 0:
return ''

first = string[0]
if first.isupper():
return first.lower() + reverse(string[1:])

return first.upper() + reverse(string[1:])

How this works:

# Base case
if string is empty, we return an empty string

# Recursive case
if first is uppercase,
we return first.lower() + reverse(string[1:])

if first is lowercase,
we return first.upper() + reverse(string[1:])

# Using string = 'Abc'

reverse('') = ''

reverse('c') = 'C' + reverse('')


= 'C' + ''
= 'C'

reverse('bc') = 'B' + reverse('c')


= 'B' + 'C'
= 'BC'

reverse('Abc') = 'a' + reverse('bc')


= 'a' + 'BC'
= 'aBC'
4) Sum Of Odd Numbers
def sum_odd(numbers):
if len(numbers) == 0:
return 0

first = numbers[0]
if first % 2 == 1:
return first + sum_odd(numbers[1:])

return sum_odd(numbers[1:])

How this works:

# Base case
if numbers is empty, return 0

# Recursive Step
if first is odd:
return first + sum_odd(numbers[1:])

if first is even:
return sum_odd(numbers[1:])

# eg. numbers = [1, 2, 3, 4, 5]

sum_odd([]) = 0

sum_odd([5]) = 5 + sum_odd([])
= 5 + 0
= 5

sum_odd([4, 5]) = sum_odd([5])


= 5

sum_odd([3, 4, 5]) = 3 + sum_odd([4, 5])


= 3 + 5
= 8

sum_odd([2, 3, 4, 5]) = sum_odd([3, 4, 5])


= 8

sum_odd([1, 2, 3, 4, 5]) = 1 + sum_odd([2, 3, 4, 5])


= 1 + 8
= 9
5) Add Odd Numbers, Subtract Even Numbers
def add_sub(numbers):
if len(numbers) == 0:
return 0

first = numbers[0]
if first % 2 == 1:
return first + add_sub(numbers[1:])

return -first + add_sub(numbers[1:])

How this works:

# Base case
if numbers is empty, return 0

# Recursive case
if first is odd,
return first + add_sub(numbers[1:])

if first is even,
return -even + add_sub(numbers[1:])

# numbers = [1, 2, 3, 4]
add_sub([]) = 0

add_sub([4]) = -4 + add_sub([])
= -4 + 0
= -4

add_sub([3, 4]) = 3 + add_sub([4])


= 3 + -4
= -1

add_sub([2, 3, 4]) = -2 + add_sub([3, 4])


= -2 + -1
= -3

add_sub([1, 2, 3, 4]) = 1 + add_sub([2, 3, 4])


= 1 + -3
= -2
6) Counting Vowels
def count_vowels(string):
if len(string) == 0:
return 0

if string[0] in 'aeiou':
return 1 + count_vowels(string[1:])
else:
return count_vowels(string[1:])

How this works:

# Base case
if string is empty, we simply return 0

# Recursive case
if first letter is a vowel,
return 1 + count_vowels(string[1:])

if first letter is NOT a vowel,


return 0 + count_vowels(string[1:])

# string = 'apple'
count_vowels('') = 0

count_vowels('e') = 1 + count_vowels('')
= 1 + 0
= 1

count_vowels('le') = count_vowels('e')
= 1

count_vowels('ple') = count_vowels('le')
= 1

count_vowels('pple') = count_vowels('ple')
= 1

count_vowels('apple') = 1 + count_vowels('pple')
= 1 + 1
= 2
7) Removing Vowels
def remove_vowels(string):
if len(string) == 0:
return ''

if string[0] in 'aeiou':
return remove_vowels(string[1:])
else:
return string[0] + remove_vowels(string[1:])

How this works:

# Base case
if string is empty, we simply return an empty string

# Recursive case
if first letter of string is a vowel,
return remove_vowels(string[1:])

else if first letter of string is NOT a vowel,


return first_letter + remove_vowels(string[1:])

# string = 'apple'
remove_vowels('') = ''

remove_vowels('e') = '' + remove_vowels('')


= '' + ''
= ''

remove_vowels('le') = 'l' + remove_vowels('e')


= 'l' + ''
= 'l'

remove_vowels('ple') = 'p' + remove_vowels('le')


= 'p' + 'l'
= 'pl'

remove_vowels('pple') = 'p' + remove_vowels('ple')


= 'p' + 'pl'
= 'ppl'

remove_vowels('apple') = '' + remove_vowels('pple')


= '' + 'ppl'
= 'ppl'
8) Replacing Vowels
def replace_vowels(string):
if len(string) == 0:
return ''

d = {'a':'e', 'e':'i', 'i':'o', 'o':'u', 'u':'a'}


first_letter = string[0]

if first_letter in d:
return d[first_letter] + replace_vowels(string[1:])
else:
return first_letter + replace_vowels(string[1:])

How this works:

# Base case
if string is empty, we simply return an empty string

# Recursive case
if first letter is a vowel,
return corresponding_vowel + replace_vowels(string[1:])

else if first letter is NOT a vowel


return first_letter + replace_vowels(string[1:])

# string = 'apple'
replace_vowels('') = ''

replace_vowels('e') = 'i' + replace_vowels('')


= 'i' + '' = 'i'

replace_vowels('le') = 'l' + replace_vowels('e')


= 'l' + 'i' = 'li'

replace_vowels('ple') = 'p' + replace_vowels('le')


= 'p' + 'li' = 'pli'

replace_vowels('pple') = 'p' + replace_vowels('ple')


= 'p' + 'pli' = 'ppli'

replace_vowels('apple') = 'e' + replace_vowels('pple')


= 'e' + 'ppli' = 'eppli'
9) Double Letters
def double_letters(string):
if len(string) == 0:
return ''

return string[0] + string[0] + double_letters(string[1:])

How this works:

# Base case
if string is empty, we return an empty string

# Recursive case
return first_letter + first_letter + double_letters(string[1:])

# string = 'apple'
double_letters('') = ''

double_letters('e') = 'e' + 'e' + double_letters('')


= 'e' + 'e' + ''
= 'ee'

double_letters('le') = 'l' + 'l' + double_letters('e')


= 'l' + 'l' + 'ee'
= 'llee'

double_letters('ple') = 'p' + 'p' + double_letters('le')


= 'p' + 'p' + 'llee'
= 'ppllee'

double_letters('pple') = 'p' + 'p' + double_letters('ple')


= 'p' + 'p' + 'ppllee'
= 'ppppllee'

double_letters('apple') = 'a' + 'a' + double_letters('pple')


= 'a' + 'a' + 'ppppllee'
= 'aappppllee'
10) Palindromes
def is_palindrome(string):
if len(string) <= 1:
return True

if string[0] == string[-1]:
return is_palindrome(string[1:-1])
else:
return False

How this works:

# Base case
if string has length of 0 or 1,
it is definitely a palindrome, so we return True

# Recursive case
We check if the first letter is equal to the last letter

if they are equal:


return is_palindrome(string[1:-1])
else:
return False

Some examples:

# string = 'abcba'
is_palindrome('c') = True

is_palindrome('bcb') = is_palindrome('c') # as 'b'=='b'


= True

is_palindrome('abcba') = is_palindrome('bcb') # as 'a'=='a'


= True

# string = 'abca'
is_palindrome('') = True

is_palindrome('bc') = False # as 'b'!='c'


11) Number Pyramid
def number_pyramid(n):
if n == 1:
print(1)
else:
number_pyramid(n-1)
for i in range(1, n+1):
print(i, end='')
print()

How this works:

# Base case
if n is 1, simply print 1

# Recursive case
if n is larger than 1, we:
number_pyramid(n-1), then
print(1, 2, … n)

# n = 4
number_pyramid(1) # prints:
1 # base case

number_pyramid(2)
1 # printed from number_pyramid(1)
12 # printed from number_pyramid(2)

number_pyramid(3)
1 # printed from number_pyramid(1)
12 # printed from number_pyramid(2)
123 # printed from number_pyramid(3)

number_pyramid(4)
1 # printed from number_pyramid(1)
12 # printed from number_pyramid(2)
123 # printed from number_pyramid(3)
1234 # printed from number_pyramid(4)
12) Reverse Number Pyramid
def reverse_pyramid(n):
if n == 1:
print(1)
else:
for i in range(n, 0, -1):
print(i, end='')
print()
reverse_pyramid(n-1)

How this works:

# Base case
if n is 1, simply print 1

# Recursive case
if n is larger than 1, we:
print(n, n-1, … 1) then
reverse_pyramid(n-1)

# n = 4
number_pyramid(1) # prints:
1 # base case

number_pyramid(2)
21 # printed from number_pyramid(2)
1 # printed from number_pyramid(1)

number_pyramid(3)
321 # printed from number_pyramid(3)
21 # printed from number_pyramid(2)
1 # printed from number_pyramid(1)

number_pyramid(4)
4321 # printed from number_pyramid(4)
321 # printed from number_pyramid(3)
21 # printed from number_pyramid(2)
1 # printed from number_pyramid(1)
13) Spaced Pyramid
def spaced_pyramid(n, length=None):
if length is None:
length = n

if n == 1:
print(' '*(length-1) + '1')
else:
spaced_pyramid(n-1, length=length)
print(' '*(length-n), end='')
for i in range(1, n+1):
print(i, end='')
print()

Note – The length variable is shared amongst all recursive calls. How this works:

# Base case
if n is 1, simply print 1 with (length-1) spaces in front

# Recursive case
if n is larger than 1, we:
print(1, 2, … n) with (length-n) spaces in front, then
reverse_pyramid(n-1, length=length)

# n = 4 # length=4 is shared among all calls


spaced_pyramid(1, length=4)
1 # base case

spaced_pyramid(2, length=4)
1 # from spaced_pyramid(1, length=4)
12 # from spaced_pyramid(2, length=4)

spaced_pyramid(3, length=4)
1 # from spaced_pyramid(1, length=4)
12 # from spaced_pyramid(2, length=4)
123 # from spaced_pyramid(3, length=4)

spaced_pyramid(4, length=4)
1 # from spaced_pyramid(1, length=4)
12 # from spaced_pyramid(2, length=4)
123 # from spaced_pyramid(3, length=4)
1234 # from spaced_pyramid(4, length=4)
14) Fibonacci Numbers
def fib(n):
if n == 1:
return 0

if n == 2:
return 1

return fib(n-1) + fib(n-2)

How this works:

# Base case 1
if n is 1, we return the first fibonacci number 0

# Base case 2
if n is 2, we return the second fibonacci number 1

# Recursive case
fib(n) = fib(n-1) + fib(n-2)

# n = 8
fib(1) = 0 # base case 1

fib(2) = 1 # base case 2

fib(3) = fib(2) + fib(1) = 1 + 0


= 1

fib(4) = fib(3) + fib(2) = 1 + 1


= 2

fib(5) = fib(4) + fib(3) = 2 + 1


= 3

fib(6) = fib(5) + fib(4) = 3 + 2


= 5

fib(7) = fib(6) + fib(5) = 5 + 3


= 8

fib(8) = fib(7) + fib(6) = 8 + 5


= 13
15) Pascal's Triangle
def pascal(n):
if n == 1:
return [1]

if n == 2:
return [1, 1]

previous = pascal(n-1)
new = []
for i in range(len(previous)-1):
left = previous[i]
right = previous[i+1]
new.append(left+right)

return [1] + new + [1]

How this works:

# Base case 1
if n is 1, return the first row [1]

# Base case 2
if n is 2, return the second row [1, 1]

# recursive case
1) first generate the previous row
2) Add every 2 adjacent numbers together
3) add 2 1's at both ends of the list

eg. [1,2,1] → [3, 3] -> [1,3,3,1]

# n = 5
pascal(1) = [1] # base case 1
pascal(2) = [1, 1] # base case 2

pascal(3) = [1, 2, 1]
[1, 1] -> [2] -> [1, 2, 1]

pascal(4) = [1, 3, 3, 1]
[1, 2, 1] -> [3, 3] -> [1, 3, 3, 1]

pascal(5) = [1, 4, 6, 4, 1]
[1, 3, 3, 1] -> [4, 6, 4] -> [1, 4, 6, 4, 1]
16) Switching Every 2 Numbers
def switch2(lis):
if len(lis) <= 1:
return lis

return lis[:2][::-1] + switch2(lis[2:])

How this works:

# base case
if the list has 0 or 1 elements, simply return the list itself.
(no switching required)

# recursive case
given a list [a, b, c, ...],
switch the first 2 elements, and
return [b, a,]

# lis = [1, 2, 3, 4]
switch2([]) = []

switch2([3, 4]) = [4, 3] + switch2([])


= [4, 3] + [] = [4, 3]

switch2([1, 2, 3, 4]) = [2, 1] + switch2([3, 4])


= [2, 1] + [4, 3]
= [2, 1, 4, 3]

# lis = [1, 2, 3, 4, 5]
switch2([5]) = [5]

switch2([3, 4, 5]) = [4, 3] + switch([5])


= [4, 3] + [5] = [4, 3, 5]

switch2([1, 2, 3, 4, 5]) = [2, 1] + switch2([3, 4, 5])


= [2, 1] + [4, 3, 5]
= [2, 1, 4, 3, 5]
17) Plus Signs
def plus(n):
if n==1:
return '1'

return plus(n-1) + f'+{n}'

How this works:

# Base case
if n is 1, we simply return the string '1'

# Recursive case
plus(n) = plus(n-1) + '+' + str(n)

# n = 5
plus(1) = '1'

plus(2) = plus(1) + '+2'


= '1' + '+2'
= '1+2'

plus(3) = plus(2) + '+3'


= '1+2' + '+3'
= '1+2+3'

plus(4) = plus(3) + '+4'


= '1+2+3' + '+4'
= '1+2+3+4'

plus(5) = plus(4) + '+5'


= '1+2+3+4' + '+5'
= '1+2+3+4+5
18) Alternate Signs
def alternate(n):
if n == 1:
return '1'

if n%2 == 0:
return alternate(n-1) + f'+{n}'
else:
return alternate(n-1) + f'-{n}'

How this works:

# Base case
if n is 1, simply return the string '1'

# Recursive case
if n is even, alternate(n) = alternate(n-1) + f'+{n}'
if n is odd, alternate(n) = alternate(n-1) + f'-{n}'

# n = 5
alternate(1) = '1'

alternate(2) = alternate(1) + '+2'


= '1' + '+2'
= '1+2'

alternate(3) = alternate(2) + '-3'


= '1+2' + '-3'
= '1+2-3'

alternate(4) = alternate(3) + '+4'


= '1+2-3' + '+4'
= '1+2-3+4'

alternate(5) = alternate(4) + '-5'


= '1+2-3+4' + '-5'
= '1+2-3+4-5'
19) Counting Elements In Nested List
def count(lis):
if type(lis) != list:
return 1

total = 0
for element in lis:
total += count(element)
return total

How this works:

# Base case
if lis is not a list (meaning that it is an integer etc), return 1

# recursive case
return the sum of count() of all its elements

# lis = [1, [2], [3, 4], [[5]]]


count([1, [2], [3, 4], [[5]]]) = count(1) + count([2]) +
count([3, 4]) + count([[5]])

# computing the inner stuff


count(1) = 1

count([2]) = count(2)
= 1

count([3, 4]) = count(3) + count(4)


= 1 + 1
= 2

count([[5]]) = count([5])
= count(5)
= 1

# hence
count([1, [2], [3, 4], [[5]]]) = count(1) + count([2]) +
count([3, 4]) + count([[5]])
= 1 + 1 + 2 + 1
= 5
20) Sum of Nested List
def nested_sum(lis):
if type(lis) != list:
return lis

total = 0
for element in lis:
total += nested_sum(element)
return total

How this works (quite similar to Q19):

# Base case
if lis is not a list, return itself

# recursive case
return the sum of count() of all its elements

# lis = [1, [2], [3, 4], [[5]]]


nested_sum([1, [2], [3, 4], [[5]]]) = nested_sum(1) + nested_sum([2]) +
nested_sum([3, 4]) +
nested_sum([[5]])

# computing the inner stuff


nested_sum(1) = 1

nested_sum([2]) = nested_sum(2)
= 2

nested_sum([3, 4]) = nested_sum(3) + nested_sum(4)


= 3 + 4
= 7

nested_sum([[5]]) = nested_sum([5])
= nested_sum(5)
= 5

# hence
nested_sum([1, [2], [3, 4], [[5]]]) = nested_sum(1) + nested_sum([2]) +
nested_sum([3, 4]) +
nested_sum([[5]])
= 1 + 2 + 7 + 5
= 15
Conclusion
Congratulations for making it to the end of this PDF file. Hope these questions got your
recursive muscle working, and hope that the answers and explanations were clear.

You might also like