Final Exam Model Paper 7

• i.9 3 − 2 ÷ 4 5 × + (it works out as 6 ÷ 2 + 20 = 23).
• ii.+ with × on top. When × arrived, the operator on the stack was +, which binds less tightly, so it stayed and × went on top to wait for its right-hand number. At the end × leaves first, so 4 × 5 is worked out before the +.
• iii.Two operators of the same level count as binding “at least as tightly”, so the first − leaves for the output: RPN 20 6 − 4 −, which is (20 − 6) − 4 = 10, working from the left. If the first stayed on the stack, the RPN would be 20 6 4 − −, which is 20 − (6 − 4) = 18, a wrong answer.

• i.git switch -c fare-table (or git branch fare-table then git switch fare-table).
• ii.git add fares.py, then git commit -m "Add fares for the new Lalitpur–Godawari route" (a short message saying what changed and why).
• iii.git switch main, git merge fare-table, git push.

• i.Tests first: writing the test makes them decide exactly what a function must do (what a price list with no vegetables should give, for example) before writing it, and the test then checks it after every change, so a change that breaks it is caught at once.
• ii.Pair programming: two people at one computer, one typing and one reviewing as they go, swapping often. Mistakes are caught as they are made, and at least two people understand every part, so the project doesn’t stop if one is ill.
• iii.Continuous integration: when each change is small and joined often, conflicts are small and easy to settle, and running every test each time shows a regression within minutes, while the change is still fresh in its author’s mind, instead of a pile of conflicts and bugs at the end.

• i.With asynchronous replication the leader says “done” at once and sends the change to the follower just after. The three bookings were on the leader but hadn’t yet reached Butwal when the disk failed, so they were lost with it.
• ii.Their seats look free on the new leader and can be sold again: two passengers may turn up for the same seat, or the customers may have no ticket at all, though they paid.
• iii.Use synchronous replication for bookings: “booked” is shown only after the follower has the change too. The cost is speed: every booking waits for an answer from Butwal, so it is slower, and if the follower can’t be reached, bookings must wait.

• i.The farmers chose the seed. Those who buy a new, dearer seed may also have better land, irrigation, more fertilizer or more time; these hidden factors (confounders) could give the bigger harvest with any seed.
• ii.Take a number of farmers willing to try it, and in each farm divide the land into plots, or take whole farms, and let chance (a coin, or a random draw) decide which get the new seed (the treatment group) and which the usual seed (the control group). Grow both the same way and compare the average harvests. Chance spreads land, water and care evenly between the groups on average, so a difference bigger than chance could explain shows the seed’s effect.
• iii.So that their hopes or beliefs can’t tilt the result (weighing a little more carefully, or rounding up, on the plots they expect to do well). This is a blind design.

Stopping as soon as the p-value dips under 5% is unfair to chance. A p-value of 4% means chance alone gives a difference this big about once in 25 tries; checking every evening gives chance a new try each day, and early on, with few users, the difference jumps about a lot. So a screen that is no better can easily look “significant” on some day, and stopping on that day picks the lucky moment: the claim is not supported. Four days also leave out part of the week, when people may buy tickets differently (weekdays and Saturday).
They should decide in advance the measure (the share who finish buying), the size of difference worth having and how many users that needs for enough power, run the test for the whole planned time, then do the shuffle test once, and report the size of the difference with its interval.

• i.φ(35) = (5 − 1)(7 − 1) = 4 × 6 = 24.
• ii.49 = 1 + 2 × 24, so 3⁴⁹ comes back to 3: 3⁴⁹ = 3²⁵ × 3²⁴, and 3²⁵ ≡ 3 (power 1 + 24), so it is 3 × 3²⁴ = 3²⁵ ≡ 3. 26 = 25 + 1, so 2²⁶ = 2²⁵ × 2 ≡ 2 × 2 = 4. (Check: 2²⁶ = 67,108,864, which leaves 4 when divided by 35.)
• iii.In RSA, d is chosen so that e × d = 1 + a multiple of φ(n). Decrypting works out cᵈ = (mᵉ)ᵈ = mᵉˣᵈ, a power that is 1 more than a multiple of φ(n), so by the pattern it comes back to m, the message.

• Control: responsibility follows the power to make a difference. Those who decide how a system works, how it is tested and when it is released carry more than someone told only to watch it.
• Knowledge: someone who knew, or should have known, of a risk carries more than someone who couldn’t have known.
• A person for every decision: every AI system that affects people should have a named person or office responsible for it, who can be asked to explain and to put things right. A system nobody answers for leaves a responsibility gap.

i.

It uses 4 channels.

ii. How many each interferes with: G 5, C 4, F 3, and A, B, D, E 2 each. So the order is G, C, F, A, B, D, E.

It uses 3 channels.

iii. C, F and G all interfere with each other (C–F, C–G, F–G), so the three of them need three different channels: no way of giving channels can use fewer than 3. Checking ii’s channels pair by pair: A–D 2/1, A–G 2/1, B–C 3/2, B–G 3/1, C–D 2/1, C–F 2/3, C–G 2/1, E–F 2/3, E–G 2/1, F–G 3/1: every pair differs, so 3 is the fewest, and ii found it. The order in i, which happened to give G its channel last, cost a fourth channel.

iv. Each post can have any of 3 channels, so there are 3²⁰⁰ ways, about 2.7 × 10⁹⁵: at a billion a second, far longer than the age of the universe, and each post more multiplies the work by 3. Like the trek through the villages, it is a problem where every method known to be sure of the best can take work that grows explosively. Instead, use a heuristic, such as the most-interference-first greedy method, perhaps tried with several orders and improved by moving single posts; measure it against the best answer (found by trying every way) on small parks, and accept a good answer that may not be the best.

i.

• 0.3: precision 38 ÷ (38 + 76) = 38 ÷ 114 ≈ 33%; recall 38 ÷ 40 = 95%.
• 0.5: precision 34 ÷ (34 + 26) = 34 ÷ 60 ≈ 57%; recall 34 ÷ 40 = 85%.
• 0.7: precision 27 ÷ (27 + 6) = 27 ÷ 33 ≈ 82%; recall 27 ÷ 40 ≈ 68%.

ii. One well-argued case (other conclusions earn marks with good reasons):

• A missed flood can cost lives, houses, animals and stored grain: it is the worst mistake, so recall matters most, which argues against 0.7, which misses a third of the floods.
• But a false alarm isn’t free: a family leaves at night with children, old people and animals, and loses a night’s sleep and work. At 0.3, two of every three sirens are false (76 in these 600 periods). People who are called out again and again for nothing stop believing the siren (alarm fatigue), and then even a true warning saves fewer people. So the lowest threshold can save fewer lives than it seems.
• A good answer: two levels. At 0.3, a “get ready” message (pack, move animals and grain higher, the old and sick go first), which costs little when it is wrong; at 0.5 or 0.7, the siren to leave. Or, with one level, 0.5: it misses 6 floods rather than 2, and over half its alarms are true, so people keep trusting it; together with the warnings that already exist, from the river gauges upstream and the people who watch them.

iii. Before: test it on monsoons it wasn’t trained on, and on this village’s river, and ask for a model card; decide who presses the siren (a person in the disaster office, who sees the score with the upstream gauges), and keep the old warnings running beside it. After: record every flood and every alarm, and check its recall and false alarms each monsoon; a river changes its course, and new embankments and roads change how it floods, so the model can drift; have a plan to stop using it, and tell the villages what it can and can’t do.

A breadth-first search over the lines: first every line through the start (one bus), then every line that shares a stop with one of those (two buses), and so on. A queue takes them in that order, so the first line found that reaches the goal needs the fewest buses.

from collections import deque LINES = {    "Red":    ["Lagankhel", "Satdobato", "Gwarko", "Koteshwor"],    "Blue":   ["Lagankhel", "Jawalakhel", "Kupondole", "Thapathali"],    "Green":  ["Satdobato", "Bhaisepati", "Sainbu", "Bungamati"],    "Yellow": ["Godawari", "Badikhel", "Chapagaun", "Bungamati"],    "White":  ["Gwarko", "Imadol", "Lubhu", "Lamatar"],    "Orange": ["Thecho", "Chapagaun", "Dhapakhel", "Satdobato"],    "Purple": ["Tikabhairab", "Lele"],}  def fewest_buses(start, goal):    """(number of buses, the lines in order) with the fewest buses, or None."""    if start == goal:        return 0, []    waiting = deque()    came_from = {}    for line, stops in LINES.items():        if start in stops:            came_from[line] = None            waiting.append(line)    while waiting:        line = waiting.popleft()        if goal in LINES[line]:            route = []            while line is not None:                route.append(line)                line = came_from[line]            return len(route), route[::-1]        for other, stops in LINES.items():            if other not in came_from and set(stops) & set(LINES[line]):                came_from[other] = line                waiting.append(other)    return None  def test_already_there():    assert fewest_buses("Gwarko", "Gwarko") == (0, [])  def test_one_bus():    assert fewest_buses("Lagankhel", "Koteshwor") == (1, ["Red"])  def test_no_bus_goes_there():    assert fewest_buses("Lagankhel", "Lele") is None  def test_worked_by_hand():    # by hand: Thapathali on Blue to Lagankhel, Red to Satdobato, Orange to Chapagaun, Yellow to Godawari    buses, lines = fewest_buses("Thapathali", "Godawari")    assert buses == 4, f"{buses} {lines}"  def test_same_both_ways():    stops = {s for line in LINES.values() for s in line}    for a in stops:        for b in stops:            there, back = fewest_buses(a, b), fewest_buses(b, a)            assert (there is None) == (back is None), f"{a} and {b}"            if there:                assert there[0] == back[0], f"{a} to {b}: {there[0]}, back {back[0]}"  passed = failed = 0for name, test in list(globals().items()):    if name.startswith("test_"):        try:            test()            print("PASS", name)            passed += 1        except AssertionError as problem:            print("FAIL", name, problem)            failed += 1print(passed, "passed,", failed, "failed") buses, lines = fewest_buses("Lubhu", "Thecho")print(f"Lubhu to Thecho: {buses} buses: {' → '.join(lines)}")

PASS test_already_therePASS test_one_busPASS test_no_bus_goes_therePASS test_worked_by_handPASS test_same_both_ways5 passed, 0 failedLubhu to Thecho: 3 buses: White → Red → Orange

The first run:

PASS test_all_goodPASS test_one_expiredFAIL test_two_expired_together gave [('Amoxicillin', 60), ('Iron', 0), ('ORS', 120)]FAIL test_all_expired gave [('Iron', 0)]2 passed, 2 failed

Line 5 removes items from the list while the loop on line 3 is going through it. When Zinc (item 1) is removed, Iron moves up into its place, and the loop goes on to item 2, which is now ORS: Iron is never looked at. So an expired medicine straight after another stays on the list. The tests that passed had no two expired medicines together. The function also changes the list it was given, which the requirement doesn’t ask for. The tests match the requirement, so the code is wrong: build a new list instead.

def still_good(stock):    """The medicines whose expiry is still ahead (days left more than 0), in the same order."""    good = []    for medicine in stock:        if medicine[1] > 0:            good.append(medicine)    return good  def test_all_good():    assert still_good([("ORS", 120), ("Paracetamol", 30)]) == [("ORS", 120), ("Paracetamol", 30)]  def test_one_expired():    assert still_good([("ORS", 120), ("Zinc", -5), ("Paracetamol", 30)]) == [("ORS", 120), ("Paracetamol", 30)]  def test_two_expired_together():    stock = [("Amoxicillin", 60), ("Zinc", -5), ("Iron", 0), ("ORS", 120)]    result = still_good(stock)    assert result == [("Amoxicillin", 60), ("ORS", 120)], f"gave {result}"  def test_all_expired():    result = still_good([("Zinc", -5), ("Iron", 0), ("Vitamin A", -40)])    assert result == [], f"gave {result}"  passed = failed = 0for name, test in list(globals().items()):    if name.startswith("test_"):        try:            test()            print("PASS", name)            passed += 1        except AssertionError as problem:            print("FAIL", name, problem)            failed += 1print(passed, "passed,", failed, "failed")

PASS test_all_goodPASS test_one_expiredPASS test_two_expired_togetherPASS test_all_expired4 passed, 0 failed

people = [    (25, 0, 0), (18, 0, 0), (4, 0, 0), (26, 0, 1), (19, 0, 0), (52, 0, 0), (16, 0, 0), (12, 0, 0),    (78, 0, 0), (10, 1, 1), (9, 1, 0), (45, 0, 0), (39, 0, 0), (72, 1, 1), (44, 0, 0), (75, 1, 1),    (35, 0, 0), (72, 0, 1), (11, 0, 0), (7, 1, 0), (74, 0, 0), (27, 1, 1), (13, 1, 1), (14, 0, 0),    (11, 1, 0), (7, 0, 0), (6, 0, 0), (4, 0, 1), (53, 1, 0), (72, 1, 1), (33, 0, 1), (23, 0, 0),    (20, 0, 1), (7, 0, 0), (40, 0, 0), (4, 0, 0), (3, 0, 0), (15, 0, 0), (39, 1, 1), (8, 0, 0),    (65, 0, 1), (72, 1, 1), (74, 1, 1), (38, 1, 1), (56, 0, 0), (22, 0, 0), (38, 1, 1), (71, 0, 0),]  def measure(name, low, high):    """Count the outcomes for people aged low to high."""    tp = fp = fn = tn = 0    for age, tb, flagged in people:        if not low <= age <= high:            continue        if tb and flagged:            tp += 1        elif tb:            fn += 1        elif flagged:            fp += 1        else:            tn += 1    print(f"{name:9} TP {tp:2}  FP {fp}  FN {fn}  TN {tn:2}  precision {tp / (tp + fp):.0%}  recall {tp / (tp + fn):.0%}")  measure("Everyone", 0, 120)measure("Under 15", 0, 14)measure("15 and up", 15, 120)

Everyone  TP 11  FP 6  FN 4  TN 27  precision 65%  recall 73%Under 15  TP  2  FP 1  FN 3  TN 10  precision 67%  recall 40%15 and up TP  9  FP 5  FN 1  TN 17  precision 64%  recall 90%

One limit: “The app flagged only 2 of the 5 children under 15 who had TB, so a child it doesn’t flag may still have TB; and with only 5 children with TB in the test, we can’t yet say how well it works for children.” Children’s coughs are different and they often can’t cough on purpose, so a model that hears adults well may not hear them.

• i.The queue takes every line that needs one bus before any that needs two, every two-bus line before any three-bus line, and so on, so the first line found that reaches the goal is on a trip with the fewest buses. Buses go both ways along their lines, so the fewest buses from A to B must equal the fewest from B to A; the test checked this for every pair of stops. Many mistakes in the search (a line skipped, or lines taken in the wrong order) would make some pair differ, so passing for every pair is evidence, though not proof: a mistake that is the same both ways would still pass.
• ii.Removing an item skips only the item straight after it. In the two tests that passed, no expired medicine came straight after another, so nothing that mattered was skipped.
• iii.The 73% mixes two groups: for people 15 and over it found 9 of 10, but for children only 2 of 5. Telling the health post “three in four” would hide that it misses most children with TB. I would test it on many more children with TB, report its recall by age, and until it does better, not use it to decide which children are tested.