Embercode: AI-powered software engineer course

1. The recursive total(n) below is called with n = 100000. At the deepest point, every pending call still holds a frame on the call stack. Which space complexity does this recursion use on the call stack? ``

python
def total(n):
    if n == 0:
        return 0
    return n + total(n - 1)

``

O(log n)O(n)O(1)O(n * n)

2. total(100000) from the previous question fails with RecursionError under the default limit. Which change lets it finish, with the recursive code left as it is?

Changing the function to return a float instead of an intWrapping the call in a try block that catches RecursionErrorCalling sys.setrecursionlimit(200000) before the callAdding a type hint n: int to the parameter

3. A function recurse(depth) adds one to depth, returns when depth == 10, and otherwise calls itself. print(recurse(0)) prints 10 with no error. Why?

The compiler removed the recursive callsThe default limit is exactly ten callsRecursionError is only raised by methods, not functionsThe base case returned after ten calls, far below the recursion limit

4. What is the bug in this function? ``

python
def sum_to(n):
    if n == 1:
        return 1
    return n + sum_to(n - 1)

print(sum_to(0))

``

The base case is n == 1, so sum_to(0) never stops and ends in RecursionErrorThe function should use a while loop instead of an ifThe function adds n twice, so the answer is doubledAn int cannot hold the sum of 1 to n

5. What happens when this code runs? ``

python
import dataclasses

@dataclasses.dataclass(frozen=True)
class Person:
    name: str

p = Person('x')
p.name = 'y'

``

The assignment works, and p.name becomes yIt raises FrozenInstanceError: cannot assign to field 'name'It raises a SyntaxError, because Python checks field assignments before the program runsIt raises TypeError: 'Person' object does not support item assignment

Stack and read-only values