Programming fundamentals: variables, data types, strings, exceptions, debugging – IB Computer Science exam questions with mark scheme

1Core5 marks

State the value produced by each Python expression.

(a) 17 // 5
(b) 17 % 5
(c) 2 ** 3
(d) "hello"[1:4]
(e) 7 / 2

[5]

(a) 3(1)
(b) 2(1)
(c) 8(1)
(d) 'ell' (accept ell or "ell", with or without quotes)(1)
(e) 3.5 (reject 3: / is true division in Python 3)(1)
Answer: 3, 2, 8, 'ell', 3.5
Examiner tip: The slice stops before index 4; students often include the final character or start at index 0.

2Core6 marks

A school is writing a program to record results on sports day. For each runner it stores the five items of data below.

Item	Example
(i) House the runner belongs to, stored as a single letter	`R`
(ii) Number of events the runner has entered	`3`
(iii) Finishing time in the 100 m, in seconds	`12.84`
(iv) Whether a medical consent form has been received	yes / no
(v) Parent's phone number	`07700 900123`

(a) State the most appropriate data type for each of items (i) to (iv). Choose from Boolean, char, decimal, integer and string. [4]

(b) Explain why item (v) should be stored as a string rather than as an integer. [1]

(c) A runner has scored a total of 17 points across 4 events. The program calculates the runner's average points per event and stores the result in a variable of type integer. State the value that is stored. [1]

(a)(i) char (accept string of length 1 in Python, which has no separate char type; reject string with no qualification)(1)
(a)(ii) integer (accept int)(1)
(a)(iii) decimal (accept float / double / real)(1)
(a)(iv) Boolean (accept bool / boolean; reject 'yes/no' as a type)(1)
(b) The leading zero would be lost if stored as an integer / it contains a space (non-digit character) / it is not used in calculations / an 11-digit number is too large for a 32-bit integer (any one) (reject 'it is too long' on its own)(1)
(c) 4 (the fractional part .25 is lost / truncated) (reject 4.25; reject 4.0)(1)
Answer: (a) (i) char (ii) integer (iii) decimal (iv) Boolean (b) e.g. an integer would drop the leading 0 and cannot hold the space; no arithmetic is done on it. (c) 4
Examiner tip: In (b) 'phone numbers are text' is too vague: name the leading zero or the fact that it is never used in arithmetic.

3Core5 marks

A program calculates bus fares. It runs without crashing and produces output, but some passengers are charged the wrong fare.

(a) State the type of error that the program contains. [1]

(b) Describe how a programmer could use a breakpoint and step-by-step execution to find the line that causes the wrong fare. [3]

(a) Logic error (reject syntax error / runtime error / exception)(1)
(b) Set a breakpoint on/before the line(s) that calculate the fare, so execution pauses there when that line is reached(1)
(b) Step through the code one line/statement at a time (step over/step into)(1)
(b) Inspect/watch the values of the variables after each step and compare them with the expected values (e.g. from a hand trace); the first line where a value differs from what is expected locates the error (allow 'until the value goes wrong')(1)
(c) The source code has to be edited to add (and later remove) the statements, which may be forgotten / can introduce new errors / the program must be re-run each time a new print is added / large amounts of output are hard to read (any one)(1)
Answer: (a) Logic error. (b) Pause at a breakpoint before the fare calculation, step one line at a time, watch variable values and compare with expected values to find the first wrong one. (c) e.g. code must be edited and the prints removed afterwards.
Examiner tip: In (b), saying the breakpoint 'finds the error' scores nothing: the marks are for pausing, stepping and comparing variable values with what you expect.

Stuck on Programming fundamentals: variables, data types, strings, exceptions, debugging?

Get it sorted in a free 30-minute session

We work through your weakest questions on this topic on Zoom. I reply the same day.

Free 30-min session on this topic Send me 5 questions a day

4Standard5 marks

Consider the following Python program.

points = 10
bonus = 3

def award(bonus):
    global points
    points = points + bonus
    level = points // 5
    return level

def reset():
    points = 0
    return points

print(award(4))
print(reset())
print(points, bonus)

(a) State the three lines of output produced when the program runs. [3]

(b) Explain why the call reset() does not change the value printed for points on the last line. [2]

(a) Line 1: 2 (points becomes 14; 14 // 5 = 2)(1)
(a) Line 2: 0(1)
(a) Line 3: 14 3 (both values needed; allow follow-through for points from an incorrect line 1 working; bonus must be 3)(1)
(b) points = 0 inside reset creates a new local variable (because there is no global statement in reset)(1)
(b) The local variable only exists while reset runs / is destroyed when it returns, so the global points (14) is unchanged(1)
Answer: (a) 2, 0, 14 3. (b) reset assigns to a new local variable called points, which disappears when the function ends; the global points stays 14.
Examiner tip: Many candidates print 10 on the last line: award declares points global, so its change to 14 is permanent; only reset works on a local copy.

5Standard5 marks

A school creates usernames for new students using this rule:

the first three letters of the surname (or the whole surname if it is shorter), then
the first letter of the first name, then
the last two digits of the year of entry.

All letters in the username are lower case. For example, Priya Okonkwo entering in 2009 has the username okop09.

(a) Construct a function make_username(first, surname, year) that returns the username. first and surname are strings and year is an integer. [4]

(b) State the username returned for Li Ng entering in 2010. [1]

(a) Extracts the first three characters of the surname, e.g. surname[0:3] / surname[:3] (Java: surname.substring(0, Math.min(3, surname.length())); in Java, award only if surnames shorter than 3 letters are handled)(1)
(a) Extracts the first character of the first name, e.g. first[0] / first[:1] (Java: first.charAt(0) / first.substring(0,1))(1)
(a) Converts year to a string and extracts the last two characters, e.g. str(year)[2:] / str(year)[-2:] (reject str(year % 100) unless padded to two digits, as 2009 would give 9)(1)
(a) Concatenates the three parts in the correct order, converts to lower case (.lower() / .toLowerCase()) and returns the result (not just prints it)(1)
(b) ngl10 (allow follow-through from their function only if it handles short surnames)(1)
Answer: (a) e.g. return surname[0:3].lower() + first[0].lower() + str(year)[2:] (b) ngl10
Examiner tip: Using year % 100 loses the leading zero (2009 gives 9, not 09): convert to a string first and slice.

6Standard5 marks

Consider the following Python code.

card = "4929 1234 5678 9012"
masked = "**** **** **** " + card[-4:]
print(masked)
code = "ab-12-cd"
code.replace("-", "")
print(code)
code = code.replace("-", "").upper()
print(code, len(code))

(a) State the three lines of output. [3]

The programmer then adds the line code[0] = "X" to change the first character of code to X. This causes an error.

(b) Explain why this line causes an error, and write a correct line of code that makes code hold XB12CD. [2]

(a) **** **** **** 9012(1)
(a) ab-12-cd (unchanged, because the result of replace on line 5 is not assigned)(1)
(a) AB12CD 6 (both needed)(1)
(b) Strings are immutable / individual characters of a string cannot be assigned to (raises a TypeError)(1)
(b) code = "X" + code[1:] (accept code = code.replace("A", "X", 1) / code = "X" + code[1:6]; must assign back to code)(1)
Answer: (a) **** **** **** 9012 / ab-12-cd / AB12CD 6 (b) Strings are immutable; code = "X" + code[1:]
Examiner tip: replace() returns a new string: unless the result is assigned, the original variable is unchanged, which is why line 2 of the output still contains the hyphens.

7Standard5 marks

A reading-planner program asks a student how many pages they will read per day, and the input is passed to this Python function as a string.

def plan(entry):
    try:
        pages = int(entry)
        per_day = 240 // pages
        print("A", per_day)
    except ValueError:
        print("B")
    except ZeroDivisionError:
        print("C")
    finally:
        print("D")
    print("E")

(a) State the output when the function is called with each of these inputs:

(i) plan("16") [1]

(ii) plan("0") [1]

(iii) plan("7.5") [1]

(b) State the purpose of the finally block. [1]

(c) The call plan("-48") outputs A -5, D, E. Outline why the exception handling does not deal with this unexpected input. [1]

(a)(i) A 15, D, E (all three, in order)(1)
(a)(ii) C, D, E (all three, in order)(1)
(a)(iii) B, D, E (all three, in order; int("7.5") raises ValueError)(1)
(b) Code in finally always runs, whether or not an exception was raised / caught (accept 'used for clean-up, e.g. closing files/releasing resources, that must always happen')(1)
(c) A negative number converts and divides without raising any exception, so no except block runs; it needs an explicit validation check (e.g. if pages <= 0) / it is a logic (validation) problem, not an exception(1)
Answer: (a)(i) A 15, D, E (ii) C, D, E (iii) B, D, E (b) finally always executes, e.g. for clean-up. (c) -48 raises no exception, so the except blocks never run; a range check is needed.
Examiner tip: Candidates often forget that finally runs after an exception has been caught, and that E still prints because the exception was handled.

8Hard6 marks

A weather station saves temperature readings in a text file, one reading per line. Some lines are corrupted, for example err, N/A or blank.

Construct a function average_reading(filename) that:

outputs File not available and returns -1 if the file cannot be opened
skips any line that cannot be converted to a decimal number, counting how many lines are rejected
makes sure the file is closed, even if an error occurs while it is being read
outputs the number of rejected lines and returns the mean of the valid readings (or -1 if there are no valid readings).

You may answer in Python or Java. [6]

Attempts to open the file inside a try block (Java: new Scanner(new File(filename)) / BufferedReader inside try)(1)
Catches the specific file exception (FileNotFoundError / OSError / IOError; Java FileNotFoundException / IOException), outputs File not available and returns -1 (accept a bare except for this mark only if it wraps the open alone)(1)
Loops through every line and converts each with float() (Java Double.parseDouble) inside an inner try, adding valid values to a running total and counter(1)
Catches ValueError (Java NumberFormatException) for a bad line, increments the rejected counter and continues with the next line (the loop must not stop)(1)
Closes the file in a finally block (accept Python with open(...) or Java try-with-resources, which close automatically)(1)
Outputs the rejected count and returns total / count of valid readings, guarding against count = 0 by returning -1(1)

Answer: Model (Python):

def average_reading(filename):
    try:
        f = open(filename)
    except FileNotFoundError:
        print("File not available")
        return -1
    total = 0
    valid = 0
    rejected = 0
    try:
        for line in f:
            try:
                value = float(line)
                total = total + value
                valid = valid + 1
            except ValueError:
                rejected = rejected + 1
    finally:
        f.close()
    print("Rejected:", rejected)
    if valid == 0:
        return -1
    return total / valid

Examiner tip: Wrapping the whole loop in a single try means the first bad line stops all further reading: the conversion needs its own inner try/except so the loop carries on.

9Hard6 marks

The function below is intended to return the longest word in a sentence. Words are separated by single spaces.

def longest_word(sentence):
    longest = ""
    current = ""
    for ch in sentence:
        if ch == " ":
            if len(current) > len(longest):
                longest = current
            current = ""
        else:
            current = current + ch
    return longest

The function is called with longest_word("go far away"). The table shows the values of the variables at the end of each iteration of the loop.

Iteration	ch	current	longest
1	g	g	""
2	o	go	""
3	(space)	""	go
4
5
6
7
8
9
10
11

(a) Copy and complete the trace table for iterations 4 to 11. [3]

(b) State the value returned by the function. [1]

(d) Describe the change needed to correct the error. [1]

(a) Iterations 4–6: ch = f, a, r; current = f, fa, far; longest = go (unchanged)(1)
(a) Iteration 7: ch = space; current = "" (empty); longest = far(1)
(a) Iterations 8–11: ch = a, w, a, y; current = a, aw, awa, away; longest = far (unchanged)(1)
(b) far (allow follow-through from their trace table)(1)
(c) The last word is never compared with longest, because the comparison only happens when a space is found and there is no space after the final word(1)
(d) After the loop (before return), add the same check: if len(current) > len(longest): longest = current (accept appending a space to the sentence before the loop, e.g. sentence = sentence + " ")(1)
Answer: (a) 4: f, f, go; 5: a, fa, go; 6: r, far, go; 7: space, "", far; 8: a, a, far; 9: w, aw, far; 10: a, awa, far; 11: y, away, far. (b) far (c) The final word is never compared. (d) Repeat the length check after the loop ends.
Examiner tip: In (c) 'it returns the wrong word' is a symptom, not the error: you must say why, i.e. the final word is never checked because no space follows it.

10Stretch5 marks

A programmer expects this program to add 0.1 to total ten times and then stop, but it never finishes. They set a breakpoint on line 4 and run the program. The diagram shows the debugger the 11th time execution pauses at the breakpoint.

(a) The programmer resumes execution until the next pause. State the values of total and count shown at that pause. [1]

(b) Explain why the loop never terminates. [2]

(c) A student suggests changing line 3 to while total < 1.0:. Using the values in the diagram, explain why the program would still not output 10 steps. [1]

(d) Suggest a change that makes the loop run exactly ten times while still adding amounts of 0.1. [1]

(a) total = 1.0999999999999999 (accept approximately 1.1) and count = 11(1)
(b) 0.1 cannot be represented exactly in binary floating point / decimals are stored as approximations, so small rounding errors build up with each addition(1)
(b) total goes from 0.9999999999999999 to 1.0999999999999999 and is therefore never exactly equal to 1.0, so the condition total != 1.0 is always True (infinite loop) (accept 'skips over 1.0')(1)
(c) 0.9999999999999999 is still less than 1.0, so the loop body runs an 11th time and the output is 11 steps(1)
(d) Control the loop with the integer counter (e.g. while count < 10: / a for loop over range(10)) or work in integer units (e.g. add 10 to an integer until it reaches 100 and divide by 100 for display) (accept comparing with a tolerance, e.g. while abs(total - 1.0) > 1e-9:; reject rounding only for display)(1)
Answer: (a) total 1.0999999999999999 (about 1.1), count 11 (b) 0.1 is stored only approximately, so total jumps from 0.9999999999999999 to 1.0999999999999999 and never equals 1.0 exactly. (c) 0.9999999999999999 < 1.0, so it loops an 11th time and prints 11 steps. (d) e.g. while count < 10, or use integer values.
Examiner tip: Never test a decimal (float) for exact equality: compare an integer counter or use a tolerance instead.

Stuck on this topic?

Book a free 30-minute session on WhatsApp and we'll find exactly which step is costing you the marks. Or build a timed paper on it.

Free 30-minute session