Embercode: AI-powered software engineer course

1. print_reverse prints the list 1 -> 2 -> 3 -> 4 as 4 3 2 1. What makes it print in that order?

It prints each node before the recursive call, so it walks the list from the backThe print line runs after the recursive call returns, so the waiting calls print on the way back upIt copies the values into a std::vector and prints the vector backwardsIt reverses the next pointers first, then prints the list in order

2. On the lesson's test build, length_rec crashes at 400000 nodes, but length_loop handled 1000000 nodes. What is the reason?

length_loop skips the nodes it does not countlength_loop stores the nodes in a vector on the call stacklength_loop runs on a larger stack that the compiler allocates for loopslength_loop keeps one local pointer and makes no call per node, so its memory use does not grow with the list

3. What does this program print? ``

cpp
#include <iostream>

struct Node {
    int value;
    Node* next;
};

void walk(const Node* head) {
    if (head == nullptr) {
        std::cout << "end\n";
        return;
    }
    std::cout << "down " << head->value << '\n';
    walk(head->next);
    std::cout << "up " << head->value << '\n';
}

int main() {
    Node c{3, nullptr}, b{2, &c}, a{1, &b};
    walk(&a);
}

``

1, 2, 3, enddown 3, down 2, down 1, end, up 1, up 2, up 3down 1, down 2, down 3, end, up 3, up 2, up 1down 1, up 1, down 2, up 2, down 3, up 3, end

4. What does this program print? ``

cpp
#include <iostream>

struct Node {
    int value;
    Node* next;
};

Node* bad_reverse(Node* head) {
    if (head == nullptr || head->next == nullptr) {
        return head;
    }
    bad_reverse(head->next);
    head->next->next = head;
    head->next = nullptr;
    return head;
}

int main() {
    Node c{3, nullptr}, b{2, &c}, a{1, &b};
    Node* result = bad_reverse(&a);
    std::cout << result->value << '\n';
}

``

32nullptr1

5. True or false: a recursive list function with no base case stops when it reaches the last node.

True, because the call for the last node returns without calling itselfFalse, because the next call starts with nullptr and reads head->next through it, which crashes

Recursion depth and groups