Final Exam Model Paper 5

i. In the first race the third lap, 95 seconds, is the first one over 94, and return ends the function at once, so the fourth lap is never looked at. In the second race no lap is over 94:

30

ii. It returns the number of the first lap slower than the target (counting from 1), and 0 if every lap was on time. The last line runs only if the loop finished without finding a slow lap, so 0 means “none”, a number no real lap can have.

• i.Nearest first visits every place closer to Kalanki than Koteshwor is, in all directions: it would work through roads toward Thankot and Kirtipur, away from the shop, as carefully as those toward it, before it reached Koteshwor.
• ii.It prefers places that are closer in a straight line to the goal, so it searches mostly in the direction of Koteshwor and visits far fewer places in the wrong direction. It still finds the shortest way, with much less work.

SELECT clubs.nameFROM membershipsJOIN clubs ON memberships.club_id = clubs.club_idWHERE memberships.student_id = 7ORDER BY clubs.name;

Each row of memberships is one student in one club; the JOIN brings each of student 7’s rows the club’s name. (Joining students as well, to pick her by name, also works.)

i. Each answer is made small-letter and checked against the rules in order:

clothes    2books      2games      1other      1Name: count, dtype: int64

New clothes and Football shoes are clothes; story books and Shoes and a book are books; mobile game is games; saved it is other.
ii. “Shoes and a book”: it bought both, but the books rule comes first, so it is counted as books only. Every rule, and its order, is a choice, so it should be written down beside the results (or such answers counted in both groups).

• i.From its source: VLC’s own website (or the computer’s app store or package manager). “Free download” sites and adverts can give a file that someone has changed, with malware or extra programs added, and the installer would then get administrator permission to put it on every lab computer.
• ii.Any two: check that the permission box names the right publisher (the program’s maker), not “Unknown”; give administrator permission only because he trusts the source; choose the custom install and untick any extras (toolbars, “recommended” programs); compare the file’s checksum with the one on the website, if one is given.

i. cd school/class10 goes to /home/anil/school/class10; .. goes up to school, then into class9:

/home/anil/school/class9

ii. ../.. goes up two levels, from class9 to school and then to anil:

/home/anil

A language model never sees letters: the tokenizer cuts the text into tokens, each turned into a number, and the model works only with those numbers. A tokenizer that learned mostly from English cuts Nepali into pieces that don’t match letters, sometimes even pieces of a letter’s bytes. So the model has no direct way to see how many letters a word has, or whether a vowel sign is the right one; it predicts a likely answer, which can be wrong. A dictionary (for Nepali, the Brihat Shabdakosh) is the place to check.

What she sees is the ELIZA effect: people tend to feel that a program that answers in a human way understands and cares, even a very simple one. The chatbot writes the likely next words after hers, and kind, caring words are likely there; it “remembers” only because her earlier messages are in its context window. Whether such a model understands anything is still argued about, but nothing here shows that it cares, and it has no life of its own in which she matters. Advice: it can help her plan revision, but she shouldn’t rely on it for her feelings or tell it private things; when she is stressed, she should talk to people, a friend, a family member or a teacher, who really can care.

Any two of the seven: the problem, with evidence; the law (and the part) it changes; the change itself, in exact words; who gains and who pays; risks and safeguards; how it encourages good innovation (technology-neutral, proportionate); how we will know it worked (what is measured, and when it is reviewed).

It is a poor choice. Data kept is data that can leak, be stolen, or be used for something nobody agreed to, and the risk grows with time: a list kept for twenty years has twenty years in which to leak, long after the students have left. “In case they are useful” is no purpose. Keeping it on the website’s database also puts it on the computer that the whole internet can reach.
Better: keep only what the school needs, for as long as it needs it; say why each item is kept; delete it at a set time (for example, a year after a student leaves); and keep it on a protected system that only the people who need it can open.

i. and ii.

"""Choosing a data pack."""  def cheapest_pack(mb, packs):    """The name of the cheapest pack in packs ({name: (MB, rupees)})    with at least mb MB, or None if no pack is big enough."""    best = None    for name in packs:        size, price = packs[name]        if size >= mb:            if best is None or price < packs[best][1]:                best = name    return best  if __name__ == "__main__":    test_packs = {"Small": (500, 50), "Big": (2000, 150)}    print(cheapest_pack(300, test_packs), "should be Small")    print(cheapest_pack(500, test_packs), "should be Small")    print(cheapest_pack(501, test_packs), "should be Big")    print(cheapest_pack(5000, test_packs), "should be None")

iii.

import datapacks PACKS = {    "Day 300 MB": (300, 30),       # (MB, rupees)    "Week 1 GB": (1000, 99),    "Week 3 GB": (3000, 249),    "Month 10 GB": (10000, 599),} for need in [800, 5000, 20000]:    name = datapacks.cheapest_pack(need, PACKS)    if name is None:        print(need, "MB: no pack is big enough")    else:        print(need, "MB:", name, "for Rs", PACKS[name][1])

800 MB: Week 1 GB for Rs 995000 MB: Month 10 GB for Rs 59920000 MB: no pack is big enough

The function keeps the cheapest pack found so far among those big enough. Because the packs are a parameter, the shop changes only the dictionary in its program when prices change: the module’s interface stays the same. Any clear names are fine. (The packs are made up for this paper.)

i. Each square is a node, joined to its open neighbors; breadth-first search from S numbers them ring by ring:

• ii.8 steps. For example (0,0) → (0,1) → (0,2) → (1,2) → (2,2) → (2,3) → (2,4) → (3,4) → (4,4).
• iii.E is 4 rows down and 4 columns across from S, and each step moves only one row or one column. So every route needs at least 4 + 4 = 8 steps; the walls can make a route longer, never shorter. This route has no wasted step.

i. The blue items nobody has collected:

ii. One row per color, kept only if it has more than one item; red has only one:

• iii.Items found before 15 July are rows 1, 2 and 3; the latest of them, alone, is the Water bottle found on 2026-07-10. Dates written year-month-day sort and compare correctly as text.
• iv.No. Text must match exactly, and “Blue” with a capital B is not equal to 'blue', so the cap is left out of every search for blue things. A list check in the table, such as CHECK (color IN ('black', 'blue', 'red', …)), would refuse “Blue” (the form could also offer the colors to choose from, instead of typing).

• i.count: Dipika batted in 13 innings (13 values). 50% is the median: in half her innings she scored 20 or fewer, and in half 20 or more.
• ii.One innings of 110, far above the rest (an outlier), pulls the mean up; the median, the middle value, isn’t moved by how big it was. So the median, 20, describes a usual innings better.
• iii.A quarter of her innings were 12 runs or fewer, and three quarters 31 or fewer: the middle half of her innings were between 12 and 31 runs.
• iv.Her scores are much closer to her mean: most of her innings are near 28, so she is a steadier scorer. Dipika’s large standard deviation (27.8) shows her scores spread widely, from 4 to 110.

• i.A sensor turns something in the world (here, light) into an electrical signal; the analog-to-digital converter turns that signal into numbers the computer can work with.
• ii.1,000 readings a second. Runners finish fractions of a second apart and move several meters each second, so a slow sampling rate would miss the moment the beam is broken and couldn’t tell close runners apart; at 1,000 a second the moment is known to a thousandth of a second.
• iii.Resolution is the smallest change it can show: here a thousandth of a second. Accuracy is how close its time is to the true time: if the start signal reaches the timer late, every time can be wrong by far more than a thousandth, however fine the resolution.
• iv.It is an impossible value: nobody runs 100 m in 0.4 seconds, so something else broke the beam (a hand, a bird, a falling leaf). It must not be used as the runner’s time: mark it as missing (keeping the original log), and take the time from another record, such as a teacher’s stopwatch.

"""Who may play in the under-16 tournament.""" from datetime import date FIRST_DAY = date(2027, 1, 15)AGE_LIMIT = 16  def age_on(born, day):    """Age in whole years, on day, of someone born on born."""    age = day.year - born.year    if (day.month, day.day) < (born.month, born.day):        age = age - 1        # this year's birthday hasn't come yet    return age  def eligible(born):    """True if a player born on born is under 16 on the first day."""    return age_on(born, FIRST_DAY) < AGE_LIMIT  if __name__ == "__main__":    # tests at the edge: 16 on the day, a day younger, a day older    print(age_on(date(2011, 1, 15), FIRST_DAY), eligible(date(2011, 1, 15)), "should be 16 False")    print(age_on(date(2011, 1, 16), FIRST_DAY), eligible(date(2011, 1, 16)), "should be 15 True")    print(age_on(date(2011, 1, 14), FIRST_DAY), eligible(date(2011, 1, 14)), "should be 16 False")    print(age_on(date(2010, 12, 31), FIRST_DAY), "should be 16")

Run by itself, players.py prints its tests:

16 False should be 16 False15 True should be 15 True16 False should be 16 False16 should be 16

from datetime import dateimport players for p in range(1, 4):    text = input(f"Player {p}: date of birth (year-month-day)? ")    year, month, day = text.split("-")    born = date(int(year), int(month), int(day))    age = players.age_on(born, players.FIRST_DAY)    if players.eligible(born):        print("Age", age, "on the first day: may play")    else:        print("Age", age, "on the first day: may not play")

Player 1: date of birth (year-month-day)? 2011-01-15Age 16 on the first day: may not playPlayer 2: date of birth (year-month-day)? 2011-01-16Age 15 on the first day: may playPlayer 3: date of birth (year-month-day)? 2013-06-30Age 13 on the first day: may play

Comparing (month, day) pairs works because Python compares them item by item, as it compares words letter by letter; born.month > day.month or (born.month == day.month and born.day > day.day) does the same.

The same program, with these three lines in place of the last one:

import sqlite3 db = sqlite3.connect(":memory:")db.execute("CREATE TABLE projects (project_id INTEGER PRIMARY KEY, title TEXT, grade INTEGER, category TEXT)")db.execute("""CREATE TABLE votes (vote_id INTEGER PRIMARY KEY,              project_id INTEGER REFERENCES projects(project_id),              voter_grade INTEGER)""")db.executemany("INSERT INTO projects VALUES (?, ?, ?, ?)", [    (1, "Solar water heater", 9, "energy"),    (2, "Line-following robot", 10, "robotics"),    (3, "Rain gauge from bottles", 8, "weather"),    (4, "Robot arm from cardboard", 9, "robotics"),    (5, "Biogas from kitchen waste", 10, "energy"),    (6, "Talking plant pot", 8, "robotics"),])db.executemany("INSERT INTO votes VALUES (?, ?, ?)", [    (1, 2, 6), (2, 2, 7), (3, 4, 6), (4, 2, 9), (5, 5, 10), (6, 1, 8),    (7, 4, 7), (8, 2, 10), (9, 5, 8), (10, 6, 6), (11, 4, 9),])  def ask(sql):    """Print each row the query gives, then a blank line."""    for row in db.execute(sql):        print(row)    print()  ask("""SELECT title, grade FROM projects       WHERE category = 'robotics' AND grade IN (9, 10) ORDER BY title""")ask("SELECT project_id, COUNT(*) FROM votes GROUP BY project_id HAVING COUNT(*) >= 2")ask("""SELECT projects.title, COUNT(*) FROM votes       JOIN projects ON votes.project_id = projects.project_id       GROUP BY projects.project_id ORDER BY COUNT(*) DESC LIMIT 3""")

('Line-following robot', 10)('Robot arm from cardboard', 9) (2, 4)(4, 3)(5, 2) ('Line-following robot', 4)('Robot arm from cardboard', 3)('Biogas from kitchen waste', 2)

AND (grade = 9 OR grade = 10) works as well as IN, but only with its brackets: without them, AND is done first, and every Grade 10 project would come in, robotics or not. (The votes are made up for this paper.)

• i.They are on the two sides of the edge: the first turns 16 exactly on the first day and may not play, the second is a day younger and may. A mistake such as <= for <, or forgetting the birthday check, shows up only there. Calling age_on means the age is worked out in one place: if it needs fixing, it is fixed once, and both functions stay right.
• ii.AND is done before OR, so without brackets the query means “(robotics and Grade 9) or any Grade 10 project”, and Grade 10’s energy project would come in. HAVING is needed because the condition is on each project’s count of votes, a value of the group, which exists only after GROUP BY; WHERE works on single rows before grouping.
• iii.The function starts with Didi, takes her from the list, and looks up graph["Didi"], which isn’t there: the program stops with a KeyError. To make it safe, check first, if start not in graph: return None, or look up neighbors with graph.get(person, []), which gives an empty list for a missing name.