Embercode: AI-powered software engineer course

1. In intersectionBySwitch, what does pa move to when it is nullptr?

nullptr again, so the loop stopsThe head of list A, so the pointer starts over on its own listThe head of list B, so the walk continues into the other listThe first node of the shared tail, which is known in advance

2. Two separate nodes each hold the value 7, but they are different nodes in memory. Which statement is correct?

They are not shared, because shared means the same node in memory and the code compares addressesThey are shared, because their values matchThey are shared only if they are the first node of each listThey are shared, but only when the lists have the same length

3. What does this program print? ``

cpp
#include <iostream>

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

Node* intersectionBySwitch(Node* a, Node* b, int& moves) {
    Node* pa = a;
    Node* pb = b;
    while (pa != pb) {
        pa = pa ? pa->next : b;
        pb = pb ? pb->next : a;
        ++moves;
    }
    return pa;
}

int main() {
    Node s2{8};
    Node s1{7, &s2};
    Node a4{4, &s1};
    Node a3{3, &a4};
    Node a2{2, &a3};
    Node a1{1, &a2};
    Node b1{9, &s1};
    int moves = 0;
    Node* hit = intersectionBySwitch(&a1, &b1, moves);
    std::cout << "value " << hit->value << " after " << moves << " moves\n";
    return 0;
}

``

value 7 after 8 movesvalue 7 after 7 movesvalue 8 after 8 movesvalue 9 after 8 moves

4. What extra memory does the length method use, apart from the lists themselves?

A set that grows with the size of list A, to store the address of every nodeA fixed amount: a few integer and pointer variables, however long the lists areA copy of list B for each node of AA stack of recursive calls that grows with the length of the lists

5. Two lists of 10,000 nodes each are checked with the naive method, which compares every node of A with every node of B. About how many steps does it take?

20,000 steps10,000 steps50,000,000 steps100,000,000 steps

Intersection