10.1 Introduction to Recursion

• The base case in a recursive function is the condition that stops the recursion process.


  True
• The recursive call in a recursive function involves calling the function itself with a modified input
• What is the return value of the recursive case in the `factorial(n)` function?

  n * factorial(n - 1)
• What is the condition for the base case in the `factorial(n)` example?

  if n == 0
• What happens when the base case is reached in a recursive function?

  Recursion stops
• What is recursion in programming?

  Function calls itself
• Match the component of recursion with its description:

  Base Case ↔️ Stops recursion and provides the final result

  Recursive Call ↔️ Calls the function again with modified input
• The base case in the `factorial(n)` function is when `n == 0`.

  True
• Recursion simplifies complex problems by breaking them into self-similar subproblems
• The `factorial` function is a common example used to illustrate recursion.


  True
• Recursion differs from iteration in that recursion uses function calls, while iteration uses control structures like loops
• What is the purpose of the base case in a recursive function?

  Stops the recursion
• Without a proper base case, a recursive function will continue calling itself indefinitely, leading to a stack overflow error.


  True
• The recursive case is the part of a recursive function where it calls itself with modified input
• Recursion breaks down a complex problem into smaller, self-similar subproblems
• The final result of `factorial(4)` is 24.

  True
• The recursive call in `factorial(n)` is `n * factorial(n - 1)`.


  True
• The base case in a recursive function prevents infinite recursion
• The recursive case in the `factorial(n)` function is `n * factorial(n - 1)`.


  True
• Recursion involves breaking down a problem into smaller, self-similar subproblems until a base case is reached
• The base case in the `factorial` function returns the value 1
• What is the final calculation for `factorial(4)`?

  24
• The recursive call in the `factorial` function is `n * factorial(n - 1)
• What is recursion in programming?

  A function calling itself
• Steps of a recursive function, such as calculating factorial(n)

  1️⃣ Check the base case: if n == 0, return 1

  2️⃣ Else, make a recursive call: return n * factorial(n - 1)

  3️⃣ Recursion continues until n reaches 0

  4️⃣ Final result is computed
• The base case in the `factorial(n)` function is when `n` equals 0.


  True
• The recursive case allows a function to break down a problem into smaller subproblems.


  True
• Steps in calculating `factorial(4)` recursively

  1️⃣ factorial(4) = 4 * factorial(3)

  2️⃣ factorial(3) = 3 * factorial(2)

  3️⃣ factorial(2) = 2 * factorial(1)

  4️⃣ factorial(1) = 1 * factorial(0)

  5️⃣ factorial(0) = 1
• The base case in recursion stops the function and provides a final result
• What is the role of the base case in the `factorial(n)` function?

  Stops recursion
• What is the core principle of the recursive case in recursion?

  Breaks down problems
• What is the recursive case in recursion used for?

  Breaking down subproblems
• What is the base case in the `factorial` function?

  n == 0
• Steps in the execution of `factorial(4)`

  1️⃣ `factorial(4)`: `4 * factorial(3)`

  2️⃣ `factorial(3)`: `3 * factorial(2)`

  3️⃣ `factorial(2)`: `2 * factorial(1)`

  4️⃣ `factorial(1)`: `1 * factorial(0)`

  5️⃣ `factorial(0)` returns `1` (base case)
• What is the base case in the `factorial` function for recursion?

  n == 0
• What is the recursive call in the `fibonacci` function?

  fibonacci(n-1) + fibonacci(n-2)
• Recursion can express complex problems in a more natural and intuitive way.


  True
• Recursion can lead to more efficient algorithms for certain types of problems.


  True
• Recursion is ideal for processing data structures like trees.


  True
• Why might recursion be slower than iteration for large inputs?

  Function call overhead