Final Practice Exam B

Section A

Q1. Compiler: translates the whole source file into machine code / object form, catching grammar errors first. Linker: connects the object code to the standard library’s compiled implementations (cout machinery) and to main as the entry point, producing the executable.

Q2. a = int 1 · b = double 2 (integer division happened first — the result is then converted) · c = double 2.5 (the cast promotes before dividing) · d = char ‘B’ (‘A’ + 1 promotes to int 66, converted back to char).

Q3. The statement sees the local — the inner declaration shadows the outer within the function’s scope. This is name shadowing; ::name reaches the outer/global one explicitly.

Section B

Q4. Science of Data / Data-Science — exact strings, one newline after the first line.

Q5.

int house;
cin >> house;
cin.ignore();            // eat the newline left by >>
string address;
getline(cin, address);

Q6. 2b 1a — pairs stream as (s,n); output concatenates n then s per pass, space-separated.

Q7. Reference:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() {
    ifstream in("notes.txt");
    if (!in) { cout << "missing\n"; return 0; }
    string line;
    int count = 0;
    while (getline(in, line))
        if (line.size() > 40) count++;
    cout << count << "\n";
    return 0;
}

(Marks: open+guard 0.5, getline loop 0.5, size test 0.5, count+print 0.5.)

Section C

Q8. (hour > 7 && hour < 9) || (hour > 17 && hour < 19) — “strictly between” excludes the endpoints; the two windows join with ||.

Q9. 1234 → valid; 0 → invalid (0 fails the ≥1000 side; the guard correctly rejects absurd pins).

Q10. Two defects: (1) > 50 must be >= 50 for pass-at-50; (2) the ladder’s thresholds are unreachable in order — any mark > 70 is caught by the first branch (since > 85 is also > 50… specifically: after fixing (1), MERIT and DISTINCTION can never fire because the first branch swallows them). Corrected:

if (marks > 85)       cout << "DISTINCTION";
else if (marks >= 70) cout << "MERIT";
else if (marks >= 50) cout << "PASS";
else                  cout << "FAIL";

(Highest threshold first; boundaries chosen to match the spec.)

Section D

Q11. 15 — odd i values 1, 3, 5 multiplied: 1·3·5.

Q12. 1 6 — 100→50→25→12→6→3→1: six halvings, x ends at 1. (Integer division: 12/2=6, 6/2=3, 3/2=1.)

Q13. Reference:

for (int row = 1; row <= 4; row++) {
    for (int k = 1; k <= row; k++)
        cout << row;
    cout << "\n";
}

(Marks: outer rows 0.5, dependent inner count 0.5, newline 0.5, exact digits 0.5.)

Q14. Defect: total = n % 10; assigns, discarding earlier digits — only the last digit of the last number survives. Corrected:

int n, total = 0;
while (cin >> n && n != 0) {
    while (n > 0) {
        total += n % 10;   // accumulate, not assign
        n /= 10;
    }
}
cout << total;

Section E

Q15. 10 — n is a copy; n += g changed the copy. The global g was read, but no write reached v.

Q16.

long long pow2(int e);                      // prototype

long long pow2(int e) {                     // definition
    long long r = 1;
    for (int i = 0; i < e; i++) r *= 2;
    return r;
}
// call:
cout << pow2(10);   // 1024

(Marks: prototype 0.5, correct loop and type 0.5, return 0.5, call 0.5.)

Q17. Defect: pass-by-value — the function divides its own copy. Corrected:

void normalize(double& x) {
    x = x / 100.0;
}

(The & is the whole repair; the body was already correct.)

Section F

Q18. fig — shortest-wins scan: kiwi(4) → apple(5) no → fig(3) yes.

Q19. {2, 6, 8, 4} — pass 1 selects min (2) and swaps with slot 0: exactly 1 swap (selection does at most one per pass).

Q20. Reference:

#include <vector>
using namespace std;

int countBelow(const vector<int>& v, int cut) {
    int count = 0;
    for (size_t i = 0; i < v.size(); i++)
        if (v[i] < cut) count++;
    return count;
}

Empty vector: the loop body never runs → returns 0 — correct without a special case. (Range-for version equally correct; marks: signature+const& 0.5, loop 0.5, strict < 0.5, empty-case reasoning 0.5.)

Section G

Q21. 87 — p++ moved to index 1 (8); p+2 is index 3 (6).

Q22. (1) Leak: b is never freed. Fix: delete[] b; before return. (2) (Half-credit framing) The return 0 path is fine here because both deletes precede it — but a’s delete is present while b’s is missing: the single required fix is delete[] b;. Full marks: name the missing delete (0.5), add delete[] b; (1). If you also reordered deletes to release both on every path (defensive restructuring), that earns the second mark.

Section H

Q23. ON — three toggles: ON→OFF→ON. Odd toggles end ON.

Q24. Reference choice: throw invalid_argument — one sentence: a temperature below absolute zero is not a temperature, so the object should never exist in that state, and an exception makes the failure loud at the construction site rather than silent in the data.

class Temperature {
    double c;
public:
    Temperature(double celsius) {
        if (celsius < -273.15) throw invalid_argument("below absolute zero");
        c = celsius;
    }
    double toFahrenheit() const { return c * 9.0 / 5.0 + 32.0; }
};
ostream& operator<<(ostream& os, const Temperature& t) {
    return os << t.toFahrenheit() << "F-from-" << 0;   // see note
}

(Practical note: printing 25C needs the celsius value — either a getCelsius() const accessor used inside operator«, or friend. The marked skills are the guard choice + justification, the const conversion method, and the operator’s stream-in/stream-out shape. The storing-0 alternative earns full marks only with an honest one-sentence cost: the object then lies about being a temperature.)

Q25. Composition couples less: the part can be swapped, tested, and reused without dragging the whole hierarchy along, and has-a describes most real relationships. Inheritance earned its place in the course’s shape hierarchies (Circle/Rectangle behind a Shape interface): genuinely is-a, shared interface, and the collection needed to treat them uniformly through one base type.