PCEP Certification Practice Test: Mastering Recursion in Python

Question 1: What is recursion in Python?

1. A function that calls another function.
2. A function that repeats a loop.
3. A function that calls itself.
4. A function that returns multiple values.

Question 2: Which of the following are necessary for a recursive function to work correctly? (Choose all that apply)

• A base case to terminate recursion.
• The function must call itself.
• The function must have parameters.
• The function should always return an integer.

Question 3: Complete the code to define a recursive function factorial that calculates the factorial of a number.

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(______)

Question 4: What will be the output of the following code?

def countdown(n):
    if n == 0:
        return
    print(n)
    countdown(n - 1)

countdown(3)

1. 3 2 1
2. 3 2 1 0
3. 3 2
4. Error

Question 5: Insert the correct base case to stop the recursion in the sum_to_n function.

def sum_to_n(n):
    if ______:
        return 0
    return n + sum_to_n(n - 1)

Question 6: What will the following recursive function output when fibonacci(4) is called?

def fibonacci(n):
    if n == 0:
        return 0
    elif n == 1:
        return 1
    else:
        return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(4))

1. 2
2. 3
3. 5
4. 4

Question 7: Which of the following are valid base cases for a recursive function? (Choose all that apply)

1. if n == 1: return 1
2. if n <= 0: return
3. if n == "stop": return 0
4. if not condition: return

Question 8: Arrange the steps to define a recursive function power that calculates x raised to the power of y.

1. Define the base case when y == 0.
2. Multiply x by the result of the recursive call with y - 1.
3. Define the function power().
4. Return the result from the base case.

Question 9: Complete the code to define a recursive function sum_digits that returns the sum of the digits of a number.

def sum_digits(n):
    if n < 10:
        return n
    return n % 10 + sum_digits(______)

Question 10: What will be the output of the following code?

def reverse_string(s):
    if len(s) == 0:
        return s
    return reverse_string(s[1:]) + s[0]

print(reverse_string("abc"))

1. abc
2. cba
3. Error
4. ab

Question 11: Insert the correct recursive call to complete the factorial function.

def factorial(n):
    if n == 1:
        return 1
    return n * ______

Question 12: What is the main purpose of a base case in recursion?

1. To perform mathematical operations.
2. To stop the recursion when a condition is met.
3. To generate infinite loops.
4. To return multiple values.

Question 13: Which of the following functions are examples of valid recursive functions? (Choose all that apply)

1. A function that calls itself.
2. A function that returns after the base case is met.
3. A function that does not have a base case.
4. A function that returns a recursive call until a condition is met.

Question 14: Arrange the steps to define a recursive function that calculates the sum of numbers from 1 to n.

1. Define the base case when n == 1.
2. Define the recursive function sum_to_n().
3. Return n + sum_to_n(n - 1) in the recursive case.
4. Return 1 in the base case.

Question 15: Complete the code to define a recursive function gcd that calculates the greatest common divisor (GCD) of two numbers using the Euclidean algorithm.

def gcd(a, b):
    if b == 0:
        return a
    return gcd(b, ______)

Question 16: What will be the output of the following code?

def count_up(n):
    if n == 0:
        return
    count_up(n - 1)
    print(n)

count_up(3)

1. 1 2 3
2. 3 2 1
3. 3 2
4. Error

17. Insert the correct base case to terminate the recursion in the fib_sum function, which calculates the sum of Fibonacci numbers up to n.

def fib_sum(n):
    if ______:
        return 0
    return fibonacci(n) + fib_sum(n - 1)

Question 18: Which of the following is a risk when using recursion without a proper base case?

1. Infinite recursion.
2. Faster execution.
3. Reduced memory usage.
4. Increased readability.

Question 19: Which of the following are characteristics of recursion? (Choose all that apply)

• Involves a base case to stop the recursion.
• Calls the same function repeatedly.
• Can be used to solve problems by dividing them into smaller instances.
• Always runs faster than iterative solutions.

Question 20: Arrange the steps to define a recursive function product_of_numbers that calculates the product of numbers from 1 to n.

1. Define the function product_of_numbers().
2. Return 1 in the base case.
3. Return n * product_of_numbers(n - 1) in the recursive case.
4. Set the base case when n == 1.

Question 21: Complete the code to define a recursive function print_digits that prints the digits of a number from left to right.

def print_digits(n):
    if n < 10:
        print(n)
    else:
        print_digits(n // 10)
        print(______)

Question 22: What will be the output of the following code?

def power(x, y):
    if y == 0:
        return 1
    return x * power(x, y - 1)

print(power(2, 3))

1. 6
2. 8
3. 12
4. Error

Question 23: Insert the correct recursive call to calculate the length of a string using recursion.

def string_length(s):
    if s == "":
        return 0
    return 1 + ______

Question 24: What will be the result of the following recursive function?

def decrement(n):
    if n == 0:
        return 0
    return decrement(n - 1)

print(decrement(3))

1. 0
2. 3
3. Error
4. None

Question 25: Which of the following problems can be solved using recursion? (Choose all that apply)

• Calculating factorials.
• Generating the Fibonacci sequence.
• Reversing a string.
• Counting elements in a list.