Recursion Base Case and Recursive Case in DSA Python - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define the base case for the factorial function.

DSA Python

def factorial(n):
    if n == [1]:
        return 1
    else:
        return n * factorial(n - 1)

Drag options to blanks, or click blank then click option'

An

B0

C-1

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 as the base case instead of 0

Missing the base case causing infinite recursion

The base case for factorial is when n is 0, returning 1.

2fill in blank

medium

Complete the code to correctly call the recursive case in the Fibonacci function.

DSA Python

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci([1]) + fibonacci(n - 2)

Drag options to blanks, or click blank then click option'

An + 1

B1

Cn - 3

Dn - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Using n + 1 causing infinite recursion

Using wrong subtraction values

The recursive case calls fibonacci(n - 1) and fibonacci(n - 2) to sum previous two numbers.

3fill in blank

hard

Fix the error in the recursive sum function by completing the base case condition.

DSA Python

def recursive_sum(lst):
    if len(lst) == [1]:
        return 0
    else:
        return lst[0] + recursive_sum(lst[1:])

Drag options to blanks, or click blank then click option'

A-1

B1

C0

Dlen(lst)

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 causing index errors

Not defining a base case causing infinite recursion

The base case is when the list is empty (length 0), returning 0 to stop recursion.

4fill in blank

hard

Fill both blanks to complete the recursive function that counts down from n to 1.

DSA Python

def countdown(n):
    if n [1] 0:
        return
    else:
        print(n)
        countdown(n [2] 1)

Drag options to blanks, or click blank then click option'

A<=

B-

C>

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using <= in base case causing wrong stopping condition

Adding 1 causing infinite recursion

The base case checks if n is greater than 0 to continue. The recursive call subtracts 1 each time.

5fill in blank

hard

Fill all three blanks to complete the recursive function that reverses a string.

DSA Python

def reverse_string(s):
    if s == [1]:
        return s
    else:
        return s[[2]] + reverse_string(s[:[3]])

Drag options to blanks, or click blank then click option'

A""

B-1

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using non-empty base case

Wrong indices causing errors or wrong output

The base case is an empty string. The recursive call takes the last character and adds the reverse of the rest.

Practice

1. What is the purpose of the base case in a recursive function?

easy

A. To stop the recursion and prevent infinite calls

B. To call the function again with a smaller input

C. To increase the input size for the next call

D. To print the result of the recursion

Solution

1. Step 1: Understand recursion basics

   Recursion works by calling itself repeatedly until a stopping condition is met.

2. Step 2: Identify the role of base case

   The base case stops further recursive calls to avoid infinite loops.

3. Final Answer:

   To stop the recursion and prevent infinite calls -> Option A

4. Quick Check:

   Base case = stop recursion [OK]

Hint: Base case stops recursion to avoid infinite loops [OK]

Common Mistakes:

• Confusing base case with recursive case
• Thinking base case calls recursion again
• Ignoring the need for a stopping condition

2. Which of the following is the correct syntax for a recursive function in Python that calculates factorial?

easy

A. def fact(n): return n * fact(n+1)

B. def fact(n): while n > 0: return n * fact(n-1)

C. def fact(n): if n == 1: return 0 else: return n + fact(n-1)

D. def fact(n): if n == 0: return 1 else: return n * fact(n-1)

Solution

1. Step 1: Check base case correctness

   def fact(n): if n == 0: return 1 else: return n * fact(n-1) uses if n == 0: return 1 which is correct for factorial base case.

2. Step 2: Check recursive call correctness

   def fact(n): if n == 0: return 1 else: return n * fact(n-1) calls fact(n-1) and multiplies by n, which matches factorial definition.

3. Final Answer:

   def fact(n): if n == 0: return 1 else: return n * fact(n-1) -> Option D

4. Quick Check:

   Correct base and recursive case = def fact(n): if n == 0: return 1 else: return n * fact(n-1) [OK]

Hint: Base case returns 1 for factorial; recursive case multiplies by n [OK]

Common Mistakes:

• Using while loop instead of recursion
• Wrong base case value
• Recursive call increasing n instead of decreasing

3. What will be the output of the following code?

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

countdown(3)

medium

A. 3 2 1 Done

B. 3 2 1

C. Done

D. 3 2 1 0 Done

Solution

1. Step 1: Trace the recursive calls and prints

   Function prints 3, then calls countdown(2), prints 2, calls countdown(1), prints 1, calls countdown(0).

2. Step 2: Base case returns 'Done'

   When n == 0, function returns 'Done' without printing 0.

3. Final Answer:

   3 2 1 -> Option B

4. Quick Check:

   Prints 3,2,1; base case returns 'Done' (not printed) [OK]

Hint: Print happens before recursive call; base case returns 'Done' [OK]

Common Mistakes:

• Expecting 0 to be printed
• Ignoring the need for a stopping condition
• Confusing print order

4. Identify the error in this recursive function that sums numbers from n down to 1:

def sum_n(n):
    if n == 1:
        return 1
    else:
        return n + sum_n(n+1)

medium

A. Base case condition is wrong

B. Missing return statement in base case

C. Recursive call increases n causing infinite recursion

D. Function should use a loop instead

Solution

1. Step 1: Analyze recursive call parameter

   The function calls sum_n(n+1), which increases n, moving away from base case.

2. Step 2: Understand effect on recursion

   Since n increases, base case n == 1 is never reached, causing infinite recursion.

3. Final Answer:

   Recursive call increases n causing infinite recursion -> Option C

4. Quick Check:

   Recursive call must reduce n to reach base case [OK]

Hint: Recursive calls must move toward base case by decreasing input [OK]

Common Mistakes:

• Increasing n instead of decreasing
• Wrong base case condition
• Ignoring infinite recursion risk

5. Given the recursive function below, what will be the output when calling mystery(4)? Explain why.

def mystery(n):
    if n <= 0:
        return 0
    else:
        return n + mystery(n-2)

hard

A. 6 (4 + 2 + 0)

B. 10 (4 + 3 + 2 + 1)

C. 4 (only the first call)

D. Error due to missing base case

Solution

1. Step 1: Trace recursive calls with n=4

   mystery(4) calls 4 + mystery(2), mystery(2) calls 2 + mystery(0), mystery(0) returns 0.

2. Step 2: Calculate sum from calls

   Sum is 4 + 2 + 0 = 6.

3. Final Answer:

   6 (4 + 2 + 0) -> Option A

4. Quick Check:

   Recursive case adds n and calls with n-2 until n ≤ 0 [OK]

Hint: Sum n and n-2 recursively until base case n ≤ 0 [OK]

Common Mistakes:

• Assuming all numbers from n down to 1 are added
• Missing base case for n ≤ 0
• Confusing decrement step