Loading…

Worked solutions

IB Computer Science HL · Paper 2

Computer Science, Higher Level

Session: November 2016
Marks: 260
Duration: 1 hour 20 min
Calculator: Not allowed
Questions: 20

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Q15 Q16 Q17 Q18 Q19 Q20

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the November 2016 Global paper, which your school or the IB can provide.

Practice mode

Hide our working until you've had a go.

Option A: Databases · Option

Questions 1–4 · 65 marks

Question 1

14 marks

College CourseTable data types, validation checks, and database queries

Databases

(a)

2 marks

Data consists of raw, unprocessed facts or figures without context (for example, the number `105` or string `'CS1201'`).
Information is data that has been processed, organized, and interpreted within a meaningful context so it is useful to a human user (for example, knowing that course `CS1201` is `'Java Programming'` and lasts `105 hours`).

Mentor tip

Contrast raw, unorganized values (data) with processed, contextualized meaning (information).

(b)

3 marks

`CourseID`: `String` / `VARCHAR` (alphanumeric text, e.g., `'CS1200'`).
`Course_Name`: `String` / `VARCHAR` (text string).
`Duration (Hours)`: `Integer` (or `Float`, representing whole hours like `10`, `105`).
`Cost`: `Float` / `Real` / `Decimal` / `Currency` (numeric value with decimal places, e.g., `30.00`).

Mentor tip

Avoid generic terms like 'number'—specify `Integer` for `Duration` and `Float`/`Decimal`/`Currency` for `Cost`.

(c)

2 marks

Data validation automatically checks data at the point of entry to ensure it is sensible, reasonable, and conforms to predefined format, type, and range rules.
This prevents corrupt or out-of-bounds values from entering the database, maintaining data integrity and preventing processing errors in downstream queries.

Mentor tip

Emphasize automated checking of input against rules (type/range/format) to maintain database integrity.

(d)(i)

1 mark

Format check (or length check): Ensure `CourseID` consists of exactly 6 characters starting with 2 uppercase letters followed by 4 digits (e.g., `LL9999`).

Mentor tip

A format mask (2 letters + 4 digits) or exact length check (6 characters) is ideal for `CourseID`.

(d)(ii)

1 mark

Range check (or type check): Ensure `Cost` is a non-negative numeric value within a sensible range (e.g., `Cost >= 0.00` and `Cost <= 1000.00`).

Mentor tip

Specify a non-negative range check (`>= 0`) for monetary attributes.

(e)(i)

3 marks

Step 1 (Projection): `SELECT Course_Name`.
Step 2 (Source Table): `FROM CourseTable`.
Step 3 (Filter Condition): `WHERE Duration >= 40 AND Duration <= 80` (which matches `'Java Programming – Advanced'` at 50 hours and `'Python Programming'` at 75 hours).

Mentor tip

Include all three query clauses clearly: the field to select (`Course_Name`), the table (`CourseTable`), and the range condition (`Duration >= 40 AND Duration <= 80`).

(e)(ii)

2 marks

Insertion (or Updating / Deleting): Adding new course records (`INSERT`) to `CourseTable` when the college introduces new classes, or modifying (`UPDATE`) existing records when course fees or durations change.

Mentor tip

Name any core data manipulation operation (`INSERT`, `UPDATE`, or `DELETE`) and briefly describe how it modifies the table.

Question 2

17 marks

Three-level database schema architecture, DBA responsibilities, DDL, and data modelling

Databases

(a)

6 marks

1. **Conceptual Schema (Internal/Enterprise View)**: Defines the high-level preliminary design of all data entities and concepts required by the organization and how they relate to one another, independent of physical storage.
2. **Logical Schema (External/User View)**: Defines how relationships and data structures are formally organized into relational tables, attributes, primary/foreign keys, and customized user views.
3. **Physical Schema**: Defines the low-level implementation details of how data files, indexes, partitions, and byte blocks are physically stored on disk drives or solid-state media.

Mentor tip

Clearly name and describe all three schema levels: Conceptual (high-level domain entities), Logical (tables, keys, relationships, user views), and Physical (low-level disk storage and indexing).

(b)(i)

4 marks

Responsibility 1 — Security and Access Control: The DBA creates user accounts, assigns role-based permissions, and monitors audit logs to ensure unauthorized users cannot read or modify restricted records.
Responsibility 2 — Schema Maintenance, Backup, and Recovery: The DBA updates table structures (adding/modifying attributes or relations as business needs evolve) and schedules regular backups so the database can be restored swiftly after hardware or software failures.

Mentor tip

State two distinct DBA duties (e.g., managing user security/access rights and performing upgrades/backups) and expand on each.

(b)(ii)

3 marks

Data Definition Language (DDL) is a subset of SQL used by the DBA during the setup, modification, or removal phases of a database to define and alter structural schema objects.
The DBA uses DDL statements to create new tables, define primary/foreign keys, alter column types, or drop obsolete tables.
Example DDL command: `CREATE TABLE CourseTable (CourseID VARCHAR(6) PRIMARY KEY, Course_Name VARCHAR(50), Duration INT, Cost DECIMAL(6,2));` (or `ALTER TABLE` / `DROP TABLE`).

Mentor tip

Explain when and why the DBA uses DDL (to create, alter, or drop schema structures) and provide a concrete SQL DDL command (`CREATE TABLE`, `ALTER TABLE`, or `DROP TABLE`).

(c)

4 marks

1. **Data Redundancy**: Poorly structured relations duplicate the same information across multiple rows/tables, wasting storage space.
2. **Inconsistent or Incorrect Query Results**: Update anomalies cause copies of repeated data to fall out of sync, leading to contradictory reports.
3. **Missing Essential Data**: Crucial domain entities or attributes needed for organizational reporting may be omitted entirely from the schema.
4. **Inappropriate Data Types & Inflexibility**: Assigning wrong data types to fields impairs sorting/searching, and a rigid, unnormalized schema makes future structural modifications difficult and error-prone.

Mentor tip

List four distinct negative consequences of poor data modelling: redundancy, inconsistency/update anomalies, missing attributes for reports, and wrong data types or inflexibility.

Question 3

14 marks

Data redundancy, referential integrity, 2NF normalization of College table, and DBMS security

Databases

(a)

2 marks

Data redundancy occurs when the exact same piece of data is duplicated unnecessarily in multiple locations or rows within a database (or when a stored value could be derived/calculated from other fields).
This wastes physical storage space and creates the risk of data inconsistency during updates.

Mentor tip

Define redundancy as unnecessary duplication of identical data across multiple rows/tables and note its storage/inconsistency cost.

(b)

2 marks

Referential integrity is a relational property ensuring that relationships between linked tables remain consistent and unbroken.
Specifically, every non-null foreign key value in a child table must match an existing, valid primary key value in the referenced parent table (preventing orphan records).

Mentor tip

State clearly that every foreign key in one relation must correspond to an existing primary key in the related table.

(c)

6 marks

Step 1 (Ensure 1NF): Verify that all attributes in `College` contain atomic (indivisible) values and identify the composite primary key `(StudentID, Subject)` needed to uniquely identify each row.
Step 2 (Identify Partial Dependencies): Notice that `Name` and `Gender` depend only on `StudentID` (part of the composite key), whereas `ExamGrade` depends on both `StudentID` and `Subject`.
Step 3 (Decompose into Separate Tables): Split the table to remove partial dependencies so every non-key attribute depends on the whole primary key.
Step 4 (Assign Primary and Foreign Keys): Make `StudentID` the primary key of the `Student` table, and `(StudentID, Subject)` the composite primary key of the `StudentSubject` (or `Grades`) table, linking them via `StudentID`.
Resulting 2NF Schema:
`STUDENT` (`StudentID`*, `Name`, `Gender`)
`STUDENT_SUBJECT` (`StudentID`*, `Subject`*, `ExamGrade`)

Mentor tip

Walk through the normalization steps (1NF atomic values -> removing partial dependencies on the composite key -> splitting tables -> assigning primary/foreign keys) and write out the two resulting 2NF schemas clearly.

(d)

4 marks

Method 1 — Role-Based Access Control (RBAC): The DBMS requires user authentication (passwords/PINs) and assigns granular read/write permissions so students can only view their own grades while teachers/administrators can enter updates.
Method 2 — Audit Trails (or Encryption): The DBMS automatically records an immutable audit log of every user login, query, and record modification (who changed what and when) to deter and trace unauthorized tampering; additionally, data encryption protects stored files from disk theft.

Mentor tip

Describe two distinct DBMS security mechanisms (e.g., access rights/passwords, audit trails, encryption, or backup/locking) with a clear explanation of each.

Question 4

20 marks

Healthcare organization object-oriented database, concurrency, data warehouse ETL, and data mining

Databases

(a)

4 marks

Characteristic 1 — Encapsulation & Complex Modularity: An OODB bundles patient attributes (text records, high-resolution X-ray images, audio notes) together with the methods that manipulate them into self-contained objects, and builds complex medical histories from smaller component objects.
Characteristic 2 — Object Identity & Inheritance: Every stored object has a unique system-generated Object Identifier (OID) independent of its attribute values, and classes can be organized into inheritance hierarchies (e.g., `InPatient` and `OutPatient` inheriting from `Patient`).

Mentor tip

Describe any two core OODB characteristics: encapsulation of data + methods, complex modularity/multimedia support, unique object identity (OID), transparent persistence, or inheritance hierarchies.

(b)

2 marks

Concurrency is the ability of a database to allow multiple users (doctors, nurses, administrators) to access and query shared records simultaneously.
While many users can read the same patient record concurrently, record locking ensures that only one user can edit/write to a record at a time—holding uncommitted edits in a temporary buffer so other users only see consistent saved data.

Mentor tip

Contrast simultaneous multi-user read access with exclusive single-user write/edit locking until changes are committed.

(c)

4 marks

1. **Data Cleansing & Format Standardization**: Converting inconsistent data formats across the 20 hospitals and 200 clinics into a single standard (e.g., converting dates from `DD/MM/YYYY` to `YYYY-MM-DD`).
2. **Merging and Joining**: Combining related patient, clinic, evacuation, and insurance records from disparate source databases into unified warehouse records.
3. **Filtering / Selection & Validation**: Extracting only relevant attributes required for analytics and validating fields to reject or fix corrupt/missing values.
4. **Aggregation & Derivation**: Calculating summary metrics (such as total treatment cost or length of stay) and sorting records before loading.

Mentor tip

Identify four distinct ETL transformation operations: format standardization/cleansing, merging/joining sources, filtering/selecting fields, and aggregation/deriving calculated values.

(d)(i)

2 marks

A patient's complete medical history, allergies, and prior treatments across all 20 hospitals and 200 clinics are consolidated in one place, allowing doctors or helicopter evacuation teams to make faster, safer treatment decisions based on how similar patients responded to therapies.

Mentor tip

Connect unified longitudinal medical history across clinics/hospitals to improved diagnosis and evidence-based treatment outcomes for the patient.

(d)(ii)

2 marks

Hospital administrators and clinicians can analyze aggregated outcomes across facilities to identify the most effective clinical best practices, while insurance providers reduce administrative overhead when verifying claims and treatment histories.

Mentor tip

Highlight how service providers (doctors, administrators, insurers) use aggregated historical data to benchmark best practices, improve resource allocation, or streamline insurance claims.

(e)(i)

4 marks

Classification assigns patient records into **predefined target categories** based on historical training data (supervised); for example, using a patient's age, blood pressure, and cholesterol to classify them into `'High Risk'` or `'Low Risk'` for heart disease.
Cluster Analysis groups patient records into **previously unknown clusters** based on attribute similarity without predefined labels (unsupervised); for example, discovering natural groupings of chronic disease patients by geographic region, lifestyle, and prescription history.

Mentor tip

Define both techniques (predefined classes in classification vs discovering similarity groups in clustering) and provide a concrete healthcare example for each.

(e)(ii)

2 marks

Deviation (anomaly) detection identifies unusual statistical outliers or sudden spikes that depart from normal baseline health patterns.
For example, detecting a sudden anomalous spike in pediatric gastrointestinal or respiratory cases in one specific district alerts the healthcare organization early to investigate local water contamination or an emerging epidemic.

Mentor tip

Explain that deviation detection spots statistical anomalies/outliers early, and give a concrete public health example (e.g., localized outbreak or environmental hazard).

Option B: Modelling and simulation · Option

Questions 5–9 · 65 marks

Question 5

16 marks

Tropical insect population geometric growth and logistic survival rate models

Modelling and simulation

(a)

2 marks

Substitute $P_{0} = 100$ , $k = 3$ , and $n = 2$ into the geometric growth formula $P_{n} = P_{0} k^{n}$ :
$P_{2} = 100 \times 3^{2} = 100 \times 9 = 900$ insects.

P_{2} = 100 \times 3^{2} = 900

Mentor tip

Show the substitution ( $100 \times 3^{2}$ ) clearly as well as the final value `900`.

(b)

3 marks

Set up a two-column spreadsheet table where Column A holds the month number (`0` to `10` in cells `ColA2:A12`) and Column B holds the population (`B2 = 100` for Month 0):
```
| A | B |
----+-------------+--------------+
1 | Month (n) | Population |
2 | 0 | 100 |
3 | 1 | =B2 * 3 |
4 | 2 | =B3 * 3 |
.. | ... | ... |
12 | 10 | =B11 * 3 |
```
Enter the initial population `100` in cell `B2`, enter the recursive formula `=B2 * 3` (or `=100 * (3^A3)`) in cell `B3`, and replicate (copy/drag) the formula down through row 12 for the first 10 months.

Mentor tip

Draw the cell grid showing row/column labels, the initial value in `B2`, the formula in `B3`, and state that the formula is copied down for 10 rows.

(c)

2 marks

State a clear assumption about how the survival rate of `0.4` interacts with the monthly multiplier (for example, assuming the net monthly multiplier is $k \times 0.4$ , or assuming reproduction factor $k = 2$ combined with $0.4$ twice as in $100 \times 0.8 = 64$ , or multiplying each month's population formula by `* 0.4`).
In the spreadsheet, modify the formula in cell `B3` to multiply the previous month's population by both the growth factor and the survival constant `0.4` (e.g., `=B2 * k * 0.4`), and copy this formula down across all 10 monthly rows.

Mentor tip

State your assumption explicitly (e.g., applying the 0.4 survival factor at the end of each monthly reproductive cycle) and show how the cell formula is updated and copied down.

(d)

5 marks

Initialize the survival rate `X = 0.4` and constant `R = 3`, then loop across the first 10 months, outputting the survival rate and updating `X` using $x_{n + 1} = r x_{n} (1 - x_{n})$ :
```
R = 3
X = 0.4
loop MONTH from 1 to 10
output "Month ", MONTH, ": ", X
X = R * X * (1 - X)
end loop
```

x_{n + 1} = r x_{n} (1 - x_{n})

Mentor tip

Ensure all 5 algorithmic elements are present: initializing `R = 3` and `X = 0.4`, looping 10 times, calculating `R * X * (1 - X)`, updating `X`, and outputting the rate each month.

(e)

4 marks

In the **Constant survival rate** row, the population declines monotonically every month (`100, 64, 51, ..., 11`) towards extinction ( $0$ ).
In the **Changing survival rate** row, the population initially drops from `100` to `72` and then oscillates in a stable equilibrium between `61` and `71`.
To compare accuracy, ecologists can sample the actual island insect population over several months and compare field counts against both trajectories.
If the real-world species persists in a stable ecological balance rather than dying out rapidly, the changing survival rate (logistic feedback) model is validated as more accurate.

Mentor tip

Contrast the two numerical trends from the table (steady decline toward extinction vs oscillation around a stable equilibrium of 61–71) and explain how field observations over time will validate which model matches reality.

Question 6

15 marks

City influenza epidemic risk modelling, simulation testing, and public health response

Modelling and simulation

(a)

2 marks

Collect standardized medical records from hospitals and clinics for patients who have contracted the flu (recording age, gender, pre-existing conditions, and symptom severity/duration).
Perform statistical correlation analysis across these patient records to identify which demographic and health traits appear most frequently in severe cases.

Mentor tip

Mention both gathering patient demographic/severity records from clinics and analyzing correlations among affected individuals.

(b)

4 marks

Collate the clinical data on severe cases to assign numerical risk weights or boolean rules to the key risk factors (`Age`, `Gender`, and `Current_Health` / pre-existing conditions).
Define a mathematical risk-scoring model or classification tiers (e.g., High Risk if `Age > 65` AND `PreExistingCondition == true`).
Query the city's census or healthcare population database using these model rules to categorize every resident by how many risk factors they possess.
Sum the counts in the high-risk categories to estimate the total number of vulnerable citizens who urgently require the limited vaccine.

Mentor tip

Trace the 4 steps: collate clinical data -> formalize rules on age, gender, and health -> apply the rules to city population records -> count the resulting high-risk group.

(c)

2 marks

Omitted Variables / Incomplete Scope: The model only considers age, gender, and current health, ignoring critical transmission factors such as occupation (e.g., healthcare/transit workers), household crowding, hygiene, or diet, which can skew risk estimates.

Mentor tip

Identify a specific limitation (such as omitted environmental/occupational variables or inaccurate reporting data) and explain how it reduces prediction accuracy.

(d)

3 marks

1. Divide the city into a geographic grid or district zones in the simulation and use current infection records to predict which adjacent zones will see outbreaks next.
2. Each day, compare the simulation's predicted daily case counts per district against the actual new infection records reported by clinics.
3. If discrepancies exist, refine the model by adjusting transmission rate coefficients (or rethinking mobility assumptions) over successive daily iterations until the simulated spread reliably matches real-world data.

Mentor tip

Describe the iterative feedback loop: predict geographic spread -> compare daily predictions with actual outbreak data -> tune model parameters/coefficients.

(e)

4 marks

Targeted Allocation of Limited Vaccines (from the Risk Model): By identifying the exact demographic groups most vulnerable to severe illness, health authorities can prioritize distributing the scarce vaccine supply to high-risk citizens first and send them targeted early-warning health advisories.
Geographic Containment Measures (from the Spread Simulation): By predicting which city districts are immediately at risk of rapid transmission, authorities can proactively close schools, restrict public gatherings/transport, and deploy mobile medical clinics to those specific neighbourhoods before cases peak.

Mentor tip

Address both halves of the prompt: how the *patient risk model* guides vaccine prioritization, and how the *spatial spread simulation* guides localized containment (school closures, travel restrictions).

Question 7

14 marks

Bridge architecture CAD wireframe modelling, memory representation, and structural stress testing

Modelling and simulation

(a)

3 marks

The wireframe displays the structural skeleton of the bridge (span and support struts) as a network of connected lines and vertices associated with modifiable parameters (`width`, `length`, `thickness`, `material`).
The architect can adjust parameters either by typing new numerical dimensions into property fields or by interactively dragging vertices/lines on screen.
By applying geometric rotation, pan, and zoom transformations to the wireframe coordinates, the architect can inspect the bridge structure from any 3D angle or perspective.

Mentor tip

Explain how the wireframe represents structural lines/nodes, how parameters are modified (input cells or dragging vertices), and how 3D rotation allows viewing from any angle.

(b)

4 marks

Vertices and Edges: Each structural line (edge) in the wireframe is stored in memory as a mathematical vector defined by the 3D Cartesian coordinates $(x, y, z)$ of its two endpoints (vertices).
Topology / Connectivity Table: A table or list links vertices together to define which edges connect, cross, or form geometric primitives (triangles/polygons).
Structural Attributes: Material properties and parameters (such as strut thickness, length, and elasticity) are stored as attributes linked to each edge/object in the data structure.
Mathematical projection algorithms use these coordinate tables to compute intersections and determine visible lines from a given camera viewpoint.

Mentor tip

Mention 3D vertex endpoint coordinates $(x, y, z)$ , edge connectivity lists/vectors, linked physical parameters (thickness/material), and mathematical formulas for intersections/views.

(c)

3 marks

Minimal Computational Overhead: Translating a wireframe vector list from memory to the screen requires far less CPU/GPU processing and memory than a fully rendered solid view.
Real-Time Interactive Editing: Because the computer does not have to recalculate complex surface shading, textures, ray-traced lighting, or hidden-surface removal after every tweak, the architect can rotate the bridge and modify dimensions instantaneously without lag.

Mentor tip

Contrast the fast, low-memory vector recalculation of a wireframe with the heavy computational cost of re-rendering lighting, textures, and solid surfaces.

(d)

4 marks

Step 1 — Load Testing: Simulate both normal traffic loads and extreme maximum-capacity traffic congestion (heavy trucks bumper-to-bumper) across the bridge span.
Step 2 — Environmental Stress Testing: Subject the model simultaneously to extreme weather and seismic conditions, such as hurricane-force crosswinds (gales), earthquakes, and extreme thermal expansion/contraction (freezing cold and intense heat).
Step 3 — Structural Response Measurement: Measure physical stress, torsion, vibration resonance, and deflection/bending across the span and struts against safety thresholds.
Step 4 — Iterative Redesign: If any strut or span exceeds safe stress tolerances, modify the material or dimensions in the model and re-run the simulation until the design passes all safety scenarios.

Mentor tip

Include extreme traffic loads, extreme environmental/weather conditions, measuring structural response (bending/stress), and modifying/re-testing if limits are exceeded.

Question 8

9 marks

Feedforward neural network calculation and genetic algorithm weight optimization for OCR

Modelling and simulation

(a)

4 marks

1. **Input to Hidden Layer**: The two input nodes (`A = 0.1` and `B = 0.5`) transmit their values forward along weighted connections to each of the two nodes in the hidden layer.
2. **Hidden Layer Summation**: Each hidden node multiplies its incoming inputs by their respective connection weights and sums them: the top hidden node computes $(0.1 \times 0.5) + (0.5 \times 0.1) = 0.10$ , and the bottom hidden node computes $(0.1 \times 0.5) + (0.5 \times 0.2) = 0.15$ .
3. **Hidden to Output Layer**: The two hidden nodes send their calculated activations forward to the output node `C`, multiplied by the output layer weights (`0.1` and `0.2`).
4. **Output Determination**: Output node `C` sums these weighted signals to produce the final network output: $(0.10 \times 0.1) + (0.15 \times 0.2) = 0.01 + 0.03 = 0.04$ .

H_{1} = (0.1 \times 0.5) + (0.5 \times 0.1) = 0.10 H_{2} = (0.1 \times 0.5) + (0.5 \times 0.2) = 0.15 C = (0.10 \times 0.1) + (0.15 \times 0.2) = 0.04

Mentor tip

Reference the specific weights in the diagram to explain how inputs are multiplied by weights and summed at the hidden layer, then multiplied by output weights and summed at C.

(b)

5 marks

1. **Initial Population**: Generate multiple trial neural networks, each initialized with a random set of connection weights (represented as chromosomes).
2. **Training Set Execution**: Run each trial network across a labeled training dataset of scanned optical characters (letters/digits).
3. **Fitness Evaluation**: Evaluate each weight set using a predefined fitness function, such as the percentage of characters accurately recognized.
4. **Selection, Crossover, and Mutation**: Select the networks with the highest recognition accuracy, combine subsets of their weight matrices (crossover), and apply small random tweaks to individual weights (mutation) to create a new generation.
5. **Iterative Convergence**: Repeat the testing and evolution cycle over many generations until the network achieves an sufficiently high character recognition accuracy threshold.

Mentor tip

Map the 5 GA steps directly to OCR neural network weights: random weight sets -> test on character dataset -> evaluate recognition % fitness -> crossover/mutate best weights -> repeat until target accuracy is met.

Question 9

11 marks

Evolution of machine translation, chatbot machine learning, and human-robot gesture communication

Modelling and simulation

(a)

4 marks

1. **Early Direct / Rule-Based Translation**: Early translators relied on word-for-word dictionary lookup and rigid syntactic grammar rules (identifying nouns, verbs, adjectives).
2. **Syntactic & Semantic Ambiguity Challenges**: Rule-based systems struggled because natural language is context-dependent (semantics)—many words serve as both nouns and verbs or have idioms that fail literal word-by-word substitution.
3. **Phrase-Based & Corpus Systems**: Incorporating common multi-word phrases and idioms improved local fluency over pure word lookup.
4. **Modern Statistical & Neural Data-Driven Translation**: Advances in memory and processing power enabled modern translators to analyze massive bilingual text corpora (accumulated knowledge), using statistical probabilities and deep neural networks to translate whole sentences based on semantic context rather than isolated words.

Mentor tip

Trace the historical progression: word-by-word dictionary + grammar rules -> struggles with parts-of-speech and semantic ambiguity -> phrase matching -> modern corpus-based statistical/neural translation.

(b)

3 marks

Early chatbots relied on simple keyword spotting and repeating pre-scripted template responses (like ELIZA).
They progressed into domain-specific expert systems coupled with speech-to-text recognition.
Modern chatbots use machine learning and natural language processing to continuously learn from past user conversations, adapting their probability models and knowledge base to provide more natural, context-aware responses over time.

Mentor tip

Show the progression from static keyword repetition -> expert system rules / speech recognition -> adaptive machine learning from ongoing user interactions.

(c)

4 marks

Ambiguity of Spoken Natural Language: Human speech frequently omits strict syntax, relies on context-dependent semantics, and uses words with multiple meanings or homophones.
Probabilistic Machine Learning: Robots learn language via rules, heuristics, and statistical probabilities of word combinations over repeated interactions.
Disambiguation via Physical Gestures: Combining visual recognition of human physical signs (pointing, facial expressions, hand gestures) with spoken commands provides crucial non-verbal context that resolves verbal ambiguity (e.g., pointing at a specific tool while saying `'pick that up'`).
Reinforcement through Observation and Imitation: Watching a human demonstrate a physical movement and repeating the action reinforces the cognitive mapping between a spoken instruction and the required motor task.

Mentor tip

Connect four ideas: natural language ambiguity/semantics, how machines learn via rules/probabilities, how visual gestures disambiguate spoken commands, and how observing/repeating movements reinforces learning.

Option C: Web science · Option

Questions 10–13 · 65 marks

Question 10

14 marks

Internet vs WWW, TCP packet transmission, IPv4 to IPv6 upgrade, DNS impact, and file compression

Web science

(a)

2 marks

The **Internet** is the global physical hardware infrastructure—a network of interconnected networks (routers, cables, servers) that transports data packets using protocols like TCP/IP.
The **World Wide Web (WWW)** is an application-layer collection of interlinked hypertext documents, multimedia resources, and social services accessed *on top of* the internet via HTTP/HTTPS.

Mentor tip

Contrast the physical network infrastructure/transport layer (Internet) with the hypertext information/application service running over it (WWW).

(b)

3 marks

1. **Segmentation**: TCP breaks the large file into smaller numbered data packets (segments) sized appropriately for IP transmission.
2. **Connection & Reliable Delivery**: TCP establishes an end-to-end connection between the web server and client and manages flow control.
3. **Error Checking & Reassembly**: TCP verifies checksums, requests retransmission of any lost or corrupted packets, and reassembles the packets in the exact sequential order at the destination.

Mentor tip

Include packet segmentation, connection management, and error checking/retransmission/reassembly.

(c)

3 marks

The rapid global growth of internet users, smartphones, and Internet of Things (IoT) devices requires every connected device to have its own unique IP address.
The 32-bit `IPv4` protocol provides only $2^{32}$ ( $\approx 4.3 billion$ ) unique addresses, which have been exhausted.
Upgrading to the 128-bit `IPv6` protocol expands the address space to $2^{128}$ unique addresses, accommodating future device growth.

Mentor tip

Connect three points: rapid growth of connected devices -> each device needing a unique IP -> exhaustion of $2^{32}$ IPv4 addresses requiring $2^{128}$ IPv6.

(d)

1 mark

DNS server tables and record structures must be updated (adding `AAAA` records alongside `A` records) to store and return the longer 128-bit hexadecimal IPv6 address format.

Mentor tip

State clearly that DNS lookup tables/entries must be modified to store the new 128-bit address representation.

(e)

5 marks

Lossy Compression Trade-off: Permanently discards redundant or perceptually less noticeable data to achieve much smaller file sizes and significantly faster download speeds, but degrades original quality and cannot restore the exact original bytes.
Lossless Compression Trade-off: Compresses data using statistical redundancy without losing a single bit so the exact original file is reconstructed upon decompression, but results in larger file sizes and slower transfer times compared to lossy.
Evaluation / Conclusion: The choice depends entirely on the type of file being downloaded—if it is executable software, source code, or a text/spreadsheet document, **lossless** compression (e.g., ZIP) is mandatory because any missing bit corrupts the file; if it is streaming video, audio, or photography, **lossy** compression (e.g., MP4, JPEG) is preferable for fast web delivery.

Mentor tip

Discuss the size/speed vs quality/integrity trade-offs of both lossy (2 marks) and lossless (2 marks), then conclude that the optimal choice depends on the file type (1 mark).

Question 11

15 marks

ACAME cartoon portal: URL vs URI, IP authentication flaws, CSS advantages, and distributed servers

Web science

(a)(i)

1 mark

`minerva.hq.acame.net`

Mentor tip

Extract the exact host/domain segment between `http://` and the first single slash `/`.

(a)(ii)

1 mark

`/Products/index.html` (or `Products/index.html`)

Mentor tip

Include both the directory (`Products`) and file name (`index.html`) after the domain name.

(b)

2 marks

A Uniform Resource Identifier (`URI`) uniquely identifies a resource (`mailto:sly.coyote@acame.net` identifies an email recipient), whereas a `URL` must also specify the exact network location and retrieval protocol path to fetch the resource.
Because a `mailto:` link does not specify the receiving mail server's physical location, incoming port, or retrieval protocol (which is controlled entirely on the receiver's side), it is a URI but not a URL.

Mentor tip

Explain that `mailto:` identifies *who* the resource is (URI) but does not specify a fixed server file location or retrieval protocol path (URL).

(c)

2 marks

1. Dynamic / Shared IPs: Legitimate subscribers often have dynamically assigned IP addresses (via DHCP) or log in from different locations/devices (mobile networks, cafes, NAT routers), which would lock them out when their IP changes.
2. IP Spoofing: An attacker can forge (spoof) the source IP address in packet headers to impersonate an authorized subscriber and bypass authentication.

Mentor tip

Mention dynamic IP allocation (DHCP / roaming across devices) and security vulnerabilities like IP spoofing or shared public NAT addresses.

(d)(i)

2 marks

Faster Page Loading (or Responsive Display): External CSS stylesheets are downloaded once and cached by the browser across all pages of the site, and separating layout rules from HTML keeps page files smaller; furthermore, CSS media queries adapt the layout cleanly to fit smartphones, tablets, or desktops.

Mentor tip

Explain one clear user benefit: either faster loading via cached external stylesheets / smaller HTML, or responsive layout adaptation across device screens.

(d)(ii)

2 marks

Centralized Maintainability & Separation of Concerns: Because content (HTML) is separated from presentation (CSS), the developer can update the visual styling of hundreds of web pages simultaneously by editing a single `.css` file, saving development time and allowing graphic designers and backend coders to work in parallel.

Mentor tip

Highlight how editing a single shared CSS file updates site-wide styling instantly and separates HTML content from visual design.

(e)

5 marks

Technical Features & Benefits: A distributed server network mirrors cartoon files across multiple geographical nodes and balances traffic load; users are routed to the nearest or least congested server (or download fragments in parallel via P2P/CDN), resulting in faster download speeds and high fault tolerance if one server fails.
Management & Legal Complexities: Operating servers across multiple countries introduces varying national copyright laws, censorship regulations, and telecom infrastructure disparities.
Synchronization & Cost Overheads: Keeping newly released cartoons synchronized across all mirror nodes increases administrative overhead, and differences in regional server infrastructure can lead to fragmented control and inconsistent Quality of Service (QoS) for subscribers in different locations.

Mentor tip

Include technical features (mirroring, load balancing, geographic proximity redirection) as well as broader implications (synchronization overhead, varying national laws/copyrights, and regional QoS differences).

Question 12

16 marks

Dynamic country-town web form, open standards, white hat SEO, and Creative Commons licensing

Web science

(a)

3 marks

1. When the user selects a country in the first dropdown window, an event listener (`onchange`) triggers a client-side JavaScript function (or AJAX/servlet request).
2. The script passes the selected country name as a parameter to look up the associated list of towns (either from a client-side data array or by querying the server database asynchronously).
3. The script dynamically populates and updates the DOM options of the second dropdown window to display only the towns matching that country without reloading the entire page.

Mentor tip

Trace the three steps: user country selection invokes a script -> country passed as parameter to retrieve matching towns -> second window populated dynamically.

(b)

4 marks

Open standards (such as `HTTP`, `HTML`, `XML`, `SOAP`, and `W3C` specifications) define publicly agreed-upon rules and formats for exchanging information across the web.
They guarantee **interoperability**, allowing heterogeneous school websites built on completely different hardware platforms, operating systems, and server software to communicate seamlessly with the central portal.
Without open standards, ad-hoc proprietary formats would cause compatibility failures, broken dynamic scripts, and inconsistent search behaviour across different schools' systems.

Mentor tip

Emphasize interoperability across diverse platforms/systems, W3C standardization (HTTP/XML/SOAP), and avoiding proprietary compatibility failures.

(c)

3 marks

Technique — Meaningful `<meta>` Tags and Semantic Headings: Including accurate, descriptive keywords (such as `'Computer Science classes'`, town name, and school name) inside `<title>`, `<meta name="description">`, and `<h1>`/`<h2>` header tags.
Explanation: When search engine crawlers parse the page, clean HTML separated from CSS presentation allows indexers to immediately identify the page's core topic and match it accurately against student search queries, improving ranking legitimately.

Mentor tip

Name a specific white-hat SEO practice (e.g., relevant `<meta>`/title tags, well-structured keyword content, removing broken/orphan links, or quality inbound links) and explain how it aids crawling/indexing.

(d)

6 marks

What Creative Commons (CC) Is: Creative Commons is a standardized public copyright licensing framework that allows creators to retain ownership/copyright of their work while granting advance permission for others to share, reuse, or adapt the material under specified conditions.
Key License Conditions: Authors can mix modular conditions such as Attribution (`BY`), Non-Commercial (`NC`), No Derivatives (`ND`), or ShareAlike (`SA`) rather than locking content under strict `'All Rights Reserved'` copyright.
Application Example in School Context: A computer science teacher at one school creates Java programming worksheets and past-paper revision guides and publishes them on their school website under a `CC BY-NC-SA` license; teachers and students at other schools across the country can legally download, study, and adapt these resources for free classroom use (establishing a consistent national standard of learning material) provided they credit the original author and do not sell the notes commercially.

Mentor tip

Dedicate up to 4 points to explaining Creative Commons (retaining copyright while enabling conditional sharing via BY/NC/SA rules) and 2 points to a concrete school CS resource sharing example.

Question 13

20 marks

Bowtie web graph analysis, search ranking failures, folksonomies, and collective intelligence misinformation

Web science

(a)

2 marks

Trace the directed cycles in the graph where every node can reach every other node and return: `A, D, G, H, K, L, M, P`.

Mentor tip

Check mutual reachability carefully: `A -> G -> K -> D -> H -> L -> P -> M -> G -> D -> A` forms the strongly connected core `{A, D, G, H, K, L, M, P}`.

(b)

1 mark

Identify nodes reachable from the SCC that have no directed path leading back into the SCC: `E, I, N`.

Mentor tip

From SCC node `D`, edges lead out to `E -> I -> N` (and `H -> N`), with no outgoing arrows returning to the SCC.

(c)

2 marks

**No**.
Reason: Node `F` is part of the `IN` component because it leads directly into the SCC (`F -> D`), and since `J` links into `F` (`J -> F -> D`), `J` can also reach the SCC (so `J` is an `IN` node, whereas a tendril from `IN` must branch *outward* away from `IN` without reaching the SCC).

Mentor tip

Note the arrow direction: `J -> F -> D` means `J` has a directed path into the SCC, making it part of `IN` rather than a dead-end tendril.

(d)

2 marks

Add a directed edge from any `IN` node (`C`, `F`, `J`, or `O`) directly to any `OUT` node (`E`, `I`, or `N`)—for example, a directed edge from `C` to `E` (`C -> E`) or `O` to `I` (`O -> I`).
Justification: A **tube** is defined as a directed path that connects a node in the `IN` component directly to a node in the `OUT` component while completely bypassing the Strongly Connected Core (`SCC`).

Mentor tip

Pick any node in `{C, F, J, O}` and draw a directed edge to any node in `{E, I, N}`, explaining that a tube links IN to OUT without passing through the SCC.

(e)

6 marks

Reason 1 — Poor SEO / Missing Keywords & Metadata: If the web developer failed to include relevant keywords or descriptive `<meta>`/`<title>` tags, the indexer cannot match the page accurately to the user's search query, resulting in an artificially low rank.
Reason 2 — Newly Published Page / Lack of Backlinks (or Deep Web): A brand-new webpage has very few inbound links from authoritative sites (or has not yet been crawled/indexed if it sits in the deep web), causing link-based algorithms like PageRank to rank it poorly despite high-quality content.
Reason 3 — Black Hat SEO Manipulation / Search Engine Demotion: Either a competitor used black-hat link farms/keyword stuffing to temporarily outrank legitimate pages, or the page itself was penalized and demoted by the search engine for using manipulative SEO techniques.

Mentor tip

Provide three distinct reasons (e.g., poor keyword/metadata optimization, new page lacking authoritative in-links, deep web unindexed status, or black-hat SEO manipulation/penalties) and explain how each skews ranking.

(f)

2 marks

Lack of Controlled Vocabulary and Hierarchy: Because folksonomy tags are created informally by ordinary users without an authoritative taxonomy or dictionary, they suffer from synonyms, spelling variations, slang, and ambiguity (e.g., `'apple'` the fruit vs `'Apple'` the tech company), which reduces search precision.

Mentor tip

Highlight that user-generated tags lack a formal hierarchical taxonomy and suffer from imprecise language, synonyms, and personal jargon.

(g)

5 marks

Concept of Collective Intelligence & Social Aggregation: Collective intelligence arises when a cohesive group pools knowledge or follows influential figures around a shared interest; social networks rapidly aggregate users around emotional topics like serious illnesses through hashtags, folksonomies, and viral sharing.
Mechanism of Exploitation: Promoters of an untested 'miracle cure' can exploit desperate patients' hope and emotional vulnerability by coordinating likes, shares, testimonials, and user tags to manufacture an illusion of widespread public consensus and scientific legitimacy.
Algorithmic Amplification: Even sceptics and doctors who visit the hoax page to debate or debunk the claim inadvertently increase the site's traffic, engagement metrics, and inbound links, which search engines and social media feeds interpret as high authority—pushing the dangerous misinformation to the top of search rankings and potentially pressuring politicians or health agencies.

Mentor tip

Connect collective intelligence/group cohesion, social media aggregation (tags/likes/emotional sharing), and how viral traffic/backlinks (even from critics) artificially boost search ranking for unverified medical claims.

Option D: Object-oriented programming · Option

Questions 14–20 · 65 marks

Question 14

5 marks

TrainCompany constructor overloading and protected access modifier

Object-oriented programming

(a)

3 marks

This is an example of **polymorphism** via **constructor overloading**.
Both constructors share the class name `TrainCompany`, but they have distinct **parameter signatures** (`TrainCompany(String x, String y)` takes two `String` arguments, whereas `TrainCompany()` takes no arguments).
At compile time, the compiler differentiates between them by matching the arguments passed in the `new TrainCompany(...)` call to the corresponding parameter list.

Mentor tip

Mention constructor overloading / polymorphism, different parameter lists (signatures), and how the compiler matches the call arguments to the correct constructor.

(b)

2 marks

Declaring the accessor and mutator methods as `protected` restricts their visibility so they can only be called by classes within the **same package** or by **subclasses** (via inheritance) of `TrainCompany`.
External, unrelated classes in other packages would be unable to access or modify `TrainCompany` attributes through these methods.

Mentor tip

State clearly that `protected` restricts access to subclasses and classes within the same package/project.

Question 15

8 marks

Journey class data types, constructor implementation, and code trace

Object-oriented programming

(a)

2 marks

`routeCode`: `String` (stores alphanumeric identifiers like `"J100"`).
`delay`: `int` (or `double`, storing minutes late like `3`, `8`, `10`).
`weatherRelated`: `boolean` (stores `true` or `false`).

Mentor tip

All three types must be exact (`String`, `int`, `boolean`) to earn full marks.

(b)

3 marks

Write the public constructor with the exact class name `Journey` and three parameters matching the attributes, assigning each parameter to its instance variable:
```java
public Journey(String rCode, int d, boolean w) {
this.routeCode = rCode;
this.delay = d;
this.weatherRelated = w;
}
```

Mentor tip

Ensure the header is `public Journey(String ..., int ..., boolean ...)` with no return type and assign all three fields.

(c)

3 marks

1. `allCompanies[0].getCompanyCode()` outputs the code for `"Southern"`: `T290`.
2. `allCompanies[0]` had journeys `s` (index 0), `u` (index 1), and `J101` (index 2) added to it; therefore `allCompanies[0].getJourney(1).getDelay()` returns the delay of `u`: `10`.
3. `allCompanies[1]` (`"Northern"`) only had journey `t` added to it, so `allCompanies[1].getNumberOfJourneys()` outputs: `1`.

Mentor tip

Trace which company receives each journey carefully: `allCompanies[0]` gets `s` (index 0), `u` (index 1, delay 10), and `J101` (index 2), while `allCompanies[1]` gets `t` (count 1).

Question 16

7 marks

Calculating non-weather average delay in TrainCompany

Object-oriented programming

(a)

1 mark

`allCompanies[0]` has three journeys: `s` (delay `3`, `weatherRelated = false`), `u` (delay `10`, `weatherRelated = true` — excluded), and `J101` (delay `6`, `weatherRelated = false`).
The average of the non-weather delays is $(3 + 6) /2 = 4.5$ .

\frac{3 + 6}{2} = 4.5

Mentor tip

Exclude journey `u` because its `weatherRelated` flag is `true`, leaving $(3 + 6) /2 = 4.5$ .

(b)

6 marks

Initialize a running `double totalDelay = 0.0` and an `int count = 0` for non-weather journeys.
Loop from `0` up to `numberOfJourneys`, check `!journeyHistory[i].getWeatherRelated()`, accumulate `getDelay()` and increment `count`, then return `totalDelay / count`:
```java
public double averageDelay() {
double totalDelay = 0.0;
int count = 0;
for (int i = 0; i < numberOfJourneys; i++) {
if (!journeyHistory[i].getWeatherRelated()) {
totalDelay = totalDelay + journeyHistory[i].getDelay();
count++;
}
}
return totalDelay / count;
}
```

Mentor tip

Do not divide by `numberOfJourneys`! You must maintain a separate `count` of non-weather journeys and use accessor methods `getWeatherRelated()` and `getDelay()`.

Question 17

10 marks

Codes class UML diagram and longestDelay() lookup method

Object-oriented programming

(a)

3 marks

Construct the 3-compartment UML class diagram for `Codes` using `-` for `private` attributes and `+` for `public` methods:
```
+----------------------------------+
| Codes |
+----------------------------------+
| - routeName : String |
| - routeCode : String |
+----------------------------------+
| + Codes(a: String, b: String) |
| + getRouteCode() : String |
| + getRouteName() : String |
+----------------------------------+

Mentor tip

Include visibility symbols (`-` for private fields, `+` for public constructor/getters) and return types (`: String`).

(b)

7 marks

First, loop through the `numberOfJourneys` in `journeyHistory[]` to find the maximum delay among journeys where `!getWeatherRelated()` is true, recording its `maxCode`.
Second, loop through the `Codes[] c` array to match `maxCode` with `c[y].getRouteCode()` and return the corresponding `c[y].getRouteName()`:
```java
public String longestDelay(Codes[] c) {
int maxDelay = -1;
String maxCode = "";
for (int i = 0; i < numberOfJourneys; i++) {
if (!journeyHistory[i].getWeatherRelated() &&
journeyHistory[i].getDelay() > maxDelay) {
maxDelay = journeyHistory[i].getDelay();
maxCode = journeyHistory[i].getRouteCode();
}
}
String route = "";
for (int j = 0; j < c.length; j++) {
if (c[j] != null && c[j].getRouteCode().equals(maxCode)) {
route = c[j].getRouteName();
}
}
return route;
}
```

Mentor tip

Break the problem into two sequential loops: Loop 1 finds the `routeCode` of the longest non-weather delay in `journeyHistory`, and Loop 2 searches `Codes[] c` to translate that `routeCode` into its `routeName`.

Question 18

15 marks

Transport hierarchy inheritance, class dependency diagram, low coupling, and toString()

Object-oriented programming

(a)

4 marks

Create a general parent superclass (e.g., `TransportCompany`) containing all shared attributes (`companyName`, `companyCode`, `numberOfJourneys`, `journeyHistory[]`) and common methods (`addJourney()`, `averageDelay()`, `longestDelay()`).
Define specialized subclasses `TrainCompany`, `BusCompany`, and `AirplaneCompany` using `extends TransportCompany`.
Each subclass automatically inherits the shared attributes and delay-analysis methods from `TransportCompany` without duplicating code.
Each subclass can also declare its own mode-specific attributes (e.g., airport hub code or bus fleet size) and override inherited methods if calculation rules differ.

Mentor tip

Identify the new superclass (`TransportCompany`), the three subclasses (`Train`, `Bus`, `Airplane`), the common fields/methods placed in the superclass, and how subclasses inherit and extend/override them.

(b)(i)

4 marks

Draw a class relationship diagram linking all six classes (`TransportCompany`, `TrainCompany`, `BusCompany`, `AirplaneCompany`, `Journey`, and `Codes`) with labeled relationship arrows:
```
+--------------------+ has-a (contains) +---------+
| TransportCompany | ------------------------> | Journey |
+--------------------+ +---------+
^ ^ ^ |
is-a | is-a | is-a | uses |
+------+ | +--------+ +--------+
| | | v
+-------+ +--------+ +---------+ +-------+
| Train | | Bus | | Plane | ----> | Codes |
+-------+ +--------+ +---------+ uses +-------+
```
- **Inheritance (`is-a`)**: `TrainCompany`, `BusCompany`, and `AirplaneCompany` inherit from `TransportCompany`.
- **Aggregation (`has-a`)**: `TransportCompany` (or `TrainCompany`) contains an array of `Journey` objects.
- **Dependency (`uses`)**: `TransportCompany` / `TrainCompany` uses `Codes` as a parameter in `longestDelay(Codes[] c)` and `toString(Codes[] c)`.

Mentor tip

Clearly distinguish and label all three relationship types: 'is-a' (inheritance from Transport superclass), 'has-a' (aggregation with Journey), and 'uses' (dependency on Codes).

(b)(ii)

3 marks

High dependency (tight coupling) means that modifying the internal implementation or data types of one class forces programmers to rewrite dependent classes, increasing maintenance overhead and the risk of regression bugs.
Keeping dependencies to a minimum (loose coupling) allows individual developers to modify or reuse a class independently without breaking other modules.
Example: Because `TrainCompany.longestDelay(Codes[] c)` depends on `Codes`, if a programmer changes `routeCode` in `Codes` from a `String` to an `int`, `TrainCompany` will fail to compile until its lookup logic is also rewritten.

Mentor tip

Explain that changes in one class ripple into dependent classes (increasing maintenance cost), and give a concrete example involving `TrainCompany` and `Codes` or `Journey`.

(c)

4 marks

Construct `toString(Codes[] c)` by concatenating `companyName`, the return value of `averageDelay()`, and the return value of `longestDelay(c)` with the required separator labels:
```java
public String toString(Codes[] c) {
return companyName + " : Average Delay = " + averageDelay() +
" minutes : Longest Delay = " + longestDelay(c);
}
```

Mentor tip

Reuse `this.companyName`, `averageDelay()`, and `longestDelay(c)` directly inside the string concatenation and return the resulting `String`.

Question 19

7 marks

Static array inefficiencies and Binary Search Tree route lookup

Object-oriented programming

(a)

2 marks

Static arrays have a fixed capacity allocated at instantiation (`new Journey[100000]` and `new TrainCompany[3]`).
If a small regional train company only completes a few hundred journeys, pre-allocating `100,000` array slots wastes a large amount of RAM; conversely, if a major company exceeds `100,000` journeys (or a 4th company is added to `allCompanies[3]`), the array overflows and requires expensive copying into a newly allocated array.

Mentor tip

Point directly to `journeyHistory = new Journey[100000]` (wasted memory if mostly empty) or `allCompanies = new TrainCompany[3]` (overflow if more items are needed).

(b)

5 marks

1. **Data Structure Selection**: Store the `Codes` objects in a **Binary Search Tree (BST)** (or a Hash Table / sorted array for binary search) ordered alphabetically by `routeCode`.
2. **Tree Construction**: Insert each `Codes` object starting at the root node, placing objects with a lexicographically smaller `routeCode` into the left subtree and larger `routeCode` into the right subtree.
3. **Search Process**: When looking up a target `routeCode`, start at the root node and compare the target code with the current node's `routeCode`.
4. **Logarithmic Elimination**: Move to the left child if the target is smaller or the right child if larger, eliminating half of the remaining tree at each step ( $O (lo g n)$ time instead of $O (n)$ linear scan).
5. **Result Retrieval**: Once the matching `routeCode` node is reached, return its `getRouteName()` value.

Mentor tip

Describe both how the Binary Search Tree is ordered/built by `routeCode` and how searching traverses left/right from the root to halve the search space at each comparison.

Question 20

13 marks

Abstract Data Types (ADTs), LinkedList vs ArrayList efficiency, and deduplicating allCodes[]

Object-oriented programming

(a)

3 marks

Abstraction and Information Hiding: Library ADTs expose a documented public interface (API) with intuitive, standardized method names such as `add()`, `remove()`, and `get()`.
The programmer only needs to know the **method signature**—what parameters to pass in and what return value/effect to expect.
All low-level implementation details (such as internal pointer manipulation or dynamic array resizing) are encapsulated and hidden inside the library class.

Mentor tip

Connect descriptive method names/documentation, knowing required parameters and return types, and encapsulation hiding internal implementation details.

(b)

3 marks

Train journeys are continually appended as trains arrive throughout the year, resulting in frequent insertions.
Adding a new `Journey` node to a `LinkedList` takes constant $O (1)$ time by simply allocating a node and updating the tail pointer/reference.
In contrast, an `ArrayList` is backed by a contiguous array that periodically fills up, requiring an expensive $O (n)$ reallocation and copying of all existing references into a larger array.

Mentor tip

Contrast $O (1)$ pointer adjustment when appending to a `LinkedList` with the periodic array resizing and copying overhead of an `ArrayList`.

(c)

7 marks

Instantiate a new `ArrayList<Codes>`, add the first element `allCodes[0]`, and iterate through the remaining non-null elements of `allCodes[]`.
For each current element `allCodes[x]`, loop through all previously inspected elements (`0` to `x - 1`, or through the `ArrayList`) comparing `getRouteCode()`; if no duplicate is found, add `allCodes[x]` to the `ArrayList`:
```java
public ArrayList<Codes> convert() {
ArrayList<Codes> uniqueList = new ArrayList<Codes>();
if (allCodes[0] != null) {
uniqueList.add(allCodes[0]);
}
int x = 1;
while (x < allCodes.length && allCodes[x] != null) {
boolean duplicate = false;
for (int y = 0; y < x; y++) {
if (allCodes[x].getRouteCode().equals(allCodes[y].getRouteCode())) {
duplicate = true;
}
}
if (!duplicate) {
uniqueList.add(allCodes[x]);
}
x++;
}
return uniqueList;
}
```

Mentor tip

Ensure you reset `boolean duplicate = false;` at the start of every outer loop iteration, compare `getRouteCode()` values across all prior elements, and only call `.add(allCodes[x])` when `!duplicate` is true.

Our analysis

Where the marks are

Each part sorted by the topic it mostly tests. Databases carries the most marks on this paper.

Databases65 marks · 25%
Q1, Q2, Q3, Q4
Modelling and simulation65 marks · 25%
Q5, Q6, Q7, Q8, Q9
Web science65 marks · 25%
Q10, Q11, Q12, Q13
Object-oriented programming65 marks · 25%
Q14, Q15, Q16, Q17, Q18, Q19, Q20

Mentor insights

Traps to watch for

01
Databases: Healthcare organization object-oriented database, concurrency, da · Q4
Describe any two core OODB characteristics: encapsulation of data + methods, complex modularity/multimedia support, unique object identity (OID), transparent persistence, or inheritance hierarchies.
02
Modelling and simulation: Tropical insect population geometric growth and logistic survival · Q5
Show the substitution ( $100 \times 3^{2}$ ) clearly as well as the final value `900`.
03
Web science: Bowtie web graph analysis, search ranking failures, folksonomies, · Q13
Check mutual reachability carefully: `A -> G -> K -> D -> H -> L -> P -> M -> G -> D -> A` forms the strongly connected core `{A, D, G, H, K, L, M, P}`.
04
Object-oriented programming: Transport hierarchy inheritance, class dependency diagram, low co · Q18
Identify the new superclass (`TransportCompany`), the three subclasses (`Train`, `Bus`, `Airplane`), the common fields/methods placed in the superclass, and how subclasses inherit and extend/override them.

Solutions and tips are GeorgeTheTutor's own; the questions are not reproduced here. Not affiliated with or endorsed by the International Baccalaureate Organization.

Want someone to go through your paper with you?

Our maths mentors took these exams recently. One-to-one, they'll find where your marks are going and fix it before May.

Find your maths mentor More past papers

Worked solutions

IB Computer Science HL · Paper 2

Computer Science, Higher Level

Session: November 2016
Marks: 260
Duration: 1 hour 20 min
Calculator: Not allowed
Questions: 20

Q1 Q2 Q3 Q4 Q5 Q6 Q7 Q8 Q9 Q10 Q11 Q12 Q13 Q14 Q15 Q16 Q17 Q18 Q19 Q20

Keep your copy of the paper open alongside. We don't reproduce the questions: each part below is labelled to match the November 2016 Global paper, which your school or the IB can provide.

Practice mode

Hide our working until you've had a go.

Option A: Databases · Option

Questions 1–4 · 65 marks

Question 1

14 marks

College CourseTable data types, validation checks, and database queries

Databases

(a)

2 marks

Data consists of raw, unprocessed facts or figures without context (for example, the number `105` or string `'CS1201'`).
Information is data that has been processed, organized, and interpreted within a meaningful context so it is useful to a human user (for example, knowing that course `CS1201` is `'Java Programming'` and lasts `105 hours`).

Mentor tip

Contrast raw, unorganized values (data) with processed, contextualized meaning (information).

(b)

3 marks

`CourseID`: `String` / `VARCHAR` (alphanumeric text, e.g., `'CS1200'`).
`Course_Name`: `String` / `VARCHAR` (text string).
`Duration (Hours)`: `Integer` (or `Float`, representing whole hours like `10`, `105`).
`Cost`: `Float` / `Real` / `Decimal` / `Currency` (numeric value with decimal places, e.g., `30.00`).

Mentor tip

Avoid generic terms like 'number'—specify `Integer` for `Duration` and `Float`/`Decimal`/`Currency` for `Cost`.

(c)

2 marks

Data validation automatically checks data at the point of entry to ensure it is sensible, reasonable, and conforms to predefined format, type, and range rules.
This prevents corrupt or out-of-bounds values from entering the database, maintaining data integrity and preventing processing errors in downstream queries.

Mentor tip

Emphasize automated checking of input against rules (type/range/format) to maintain database integrity.

(d)(i)

1 mark

Format check (or length check): Ensure `CourseID` consists of exactly 6 characters starting with 2 uppercase letters followed by 4 digits (e.g., `LL9999`).

Mentor tip

A format mask (2 letters + 4 digits) or exact length check (6 characters) is ideal for `CourseID`.

(d)(ii)

1 mark

Range check (or type check): Ensure `Cost` is a non-negative numeric value within a sensible range (e.g., `Cost >= 0.00` and `Cost <= 1000.00`).

Mentor tip

Specify a non-negative range check (`>= 0`) for monetary attributes.

(e)(i)

3 marks

Step 1 (Projection): `SELECT Course_Name`.
Step 2 (Source Table): `FROM CourseTable`.
Step 3 (Filter Condition): `WHERE Duration >= 40 AND Duration <= 80` (which matches `'Java Programming – Advanced'` at 50 hours and `'Python Programming'` at 75 hours).

Mentor tip

Include all three query clauses clearly: the field to select (`Course_Name`), the table (`CourseTable`), and the range condition (`Duration >= 40 AND Duration <= 80`).

(e)(ii)

2 marks

Mentor tip

Name any core data manipulation operation (`INSERT`, `UPDATE`, or `DELETE`) and briefly describe how it modifies the table.

Question 2

17 marks

Three-level database schema architecture, DBA responsibilities, DDL, and data modelling

Databases

(a)

6 marks

1. **Conceptual Schema (Internal/Enterprise View)**: Defines the high-level preliminary design of all data entities and concepts required by the organization and how they relate to one another, independent of physical storage.
2. **Logical Schema (External/User View)**: Defines how relationships and data structures are formally organized into relational tables, attributes, primary/foreign keys, and customized user views.
3. **Physical Schema**: Defines the low-level implementation details of how data files, indexes, partitions, and byte blocks are physically stored on disk drives or solid-state media.

Mentor tip

Clearly name and describe all three schema levels: Conceptual (high-level domain entities), Logical (tables, keys, relationships, user views), and Physical (low-level disk storage and indexing).

(b)(i)

4 marks

Responsibility 1 — Security and Access Control: The DBA creates user accounts, assigns role-based permissions, and monitors audit logs to ensure unauthorized users cannot read or modify restricted records.
Responsibility 2 — Schema Maintenance, Backup, and Recovery: The DBA updates table structures (adding/modifying attributes or relations as business needs evolve) and schedules regular backups so the database can be restored swiftly after hardware or software failures.

Mentor tip

State two distinct DBA duties (e.g., managing user security/access rights and performing upgrades/backups) and expand on each.

(b)(ii)

3 marks

Data Definition Language (DDL) is a subset of SQL used by the DBA during the setup, modification, or removal phases of a database to define and alter structural schema objects.
The DBA uses DDL statements to create new tables, define primary/foreign keys, alter column types, or drop obsolete tables.
Example DDL command: `CREATE TABLE CourseTable (CourseID VARCHAR(6) PRIMARY KEY, Course_Name VARCHAR(50), Duration INT, Cost DECIMAL(6,2));` (or `ALTER TABLE` / `DROP TABLE`).

Mentor tip

Explain when and why the DBA uses DDL (to create, alter, or drop schema structures) and provide a concrete SQL DDL command (`CREATE TABLE`, `ALTER TABLE`, or `DROP TABLE`).

(c)

4 marks

1. **Data Redundancy**: Poorly structured relations duplicate the same information across multiple rows/tables, wasting storage space.
2. **Inconsistent or Incorrect Query Results**: Update anomalies cause copies of repeated data to fall out of sync, leading to contradictory reports.
3. **Missing Essential Data**: Crucial domain entities or attributes needed for organizational reporting may be omitted entirely from the schema.
4. **Inappropriate Data Types & Inflexibility**: Assigning wrong data types to fields impairs sorting/searching, and a rigid, unnormalized schema makes future structural modifications difficult and error-prone.

Mentor tip

List four distinct negative consequences of poor data modelling: redundancy, inconsistency/update anomalies, missing attributes for reports, and wrong data types or inflexibility.

Question 3

14 marks

Data redundancy, referential integrity, 2NF normalization of College table, and DBMS security

Databases

(a)

2 marks

Data redundancy occurs when the exact same piece of data is duplicated unnecessarily in multiple locations or rows within a database (or when a stored value could be derived/calculated from other fields).
This wastes physical storage space and creates the risk of data inconsistency during updates.

Mentor tip

Define redundancy as unnecessary duplication of identical data across multiple rows/tables and note its storage/inconsistency cost.

(b)

2 marks

Referential integrity is a relational property ensuring that relationships between linked tables remain consistent and unbroken.
Specifically, every non-null foreign key value in a child table must match an existing, valid primary key value in the referenced parent table (preventing orphan records).

Mentor tip

State clearly that every foreign key in one relation must correspond to an existing primary key in the related table.

(c)

6 marks

Step 1 (Ensure 1NF): Verify that all attributes in `College` contain atomic (indivisible) values and identify the composite primary key `(StudentID, Subject)` needed to uniquely identify each row.
Step 2 (Identify Partial Dependencies): Notice that `Name` and `Gender` depend only on `StudentID` (part of the composite key), whereas `ExamGrade` depends on both `StudentID` and `Subject`.
Step 3 (Decompose into Separate Tables): Split the table to remove partial dependencies so every non-key attribute depends on the whole primary key.
Step 4 (Assign Primary and Foreign Keys): Make `StudentID` the primary key of the `Student` table, and `(StudentID, Subject)` the composite primary key of the `StudentSubject` (or `Grades`) table, linking them via `StudentID`.
Resulting 2NF Schema:
`STUDENT` (`StudentID`*, `Name`, `Gender`)
`STUDENT_SUBJECT` (`StudentID`*, `Subject`*, `ExamGrade`)

Mentor tip

(d)

4 marks

Method 1 — Role-Based Access Control (RBAC): The DBMS requires user authentication (passwords/PINs) and assigns granular read/write permissions so students can only view their own grades while teachers/administrators can enter updates.
Method 2 — Audit Trails (or Encryption): The DBMS automatically records an immutable audit log of every user login, query, and record modification (who changed what and when) to deter and trace unauthorized tampering; additionally, data encryption protects stored files from disk theft.

Mentor tip

Describe two distinct DBMS security mechanisms (e.g., access rights/passwords, audit trails, encryption, or backup/locking) with a clear explanation of each.

Question 4

20 marks

Healthcare organization object-oriented database, concurrency, data warehouse ETL, and data mining

Databases

(a)

4 marks

Characteristic 1 — Encapsulation & Complex Modularity: An OODB bundles patient attributes (text records, high-resolution X-ray images, audio notes) together with the methods that manipulate them into self-contained objects, and builds complex medical histories from smaller component objects.
Characteristic 2 — Object Identity & Inheritance: Every stored object has a unique system-generated Object Identifier (OID) independent of its attribute values, and classes can be organized into inheritance hierarchies (e.g., `InPatient` and `OutPatient` inheriting from `Patient`).

Mentor tip

Describe any two core OODB characteristics: encapsulation of data + methods, complex modularity/multimedia support, unique object identity (OID), transparent persistence, or inheritance hierarchies.

(b)

2 marks

Concurrency is the ability of a database to allow multiple users (doctors, nurses, administrators) to access and query shared records simultaneously.
While many users can read the same patient record concurrently, record locking ensures that only one user can edit/write to a record at a time—holding uncommitted edits in a temporary buffer so other users only see consistent saved data.

Mentor tip

Contrast simultaneous multi-user read access with exclusive single-user write/edit locking until changes are committed.

(c)

4 marks

1. **Data Cleansing & Format Standardization**: Converting inconsistent data formats across the 20 hospitals and 200 clinics into a single standard (e.g., converting dates from `DD/MM/YYYY` to `YYYY-MM-DD`).
2. **Merging and Joining**: Combining related patient, clinic, evacuation, and insurance records from disparate source databases into unified warehouse records.
3. **Filtering / Selection & Validation**: Extracting only relevant attributes required for analytics and validating fields to reject or fix corrupt/missing values.
4. **Aggregation & Derivation**: Calculating summary metrics (such as total treatment cost or length of stay) and sorting records before loading.

Mentor tip

Identify four distinct ETL transformation operations: format standardization/cleansing, merging/joining sources, filtering/selecting fields, and aggregation/deriving calculated values.

(d)(i)

2 marks

Mentor tip

Connect unified longitudinal medical history across clinics/hospitals to improved diagnosis and evidence-based treatment outcomes for the patient.

(d)(ii)

2 marks

Mentor tip

Highlight how service providers (doctors, administrators, insurers) use aggregated historical data to benchmark best practices, improve resource allocation, or streamline insurance claims.

(e)(i)

4 marks

Classification assigns patient records into **predefined target categories** based on historical training data (supervised); for example, using a patient's age, blood pressure, and cholesterol to classify them into `'High Risk'` or `'Low Risk'` for heart disease.
Cluster Analysis groups patient records into **previously unknown clusters** based on attribute similarity without predefined labels (unsupervised); for example, discovering natural groupings of chronic disease patients by geographic region, lifestyle, and prescription history.

Mentor tip

Define both techniques (predefined classes in classification vs discovering similarity groups in clustering) and provide a concrete healthcare example for each.

(e)(ii)

2 marks

Deviation (anomaly) detection identifies unusual statistical outliers or sudden spikes that depart from normal baseline health patterns.
For example, detecting a sudden anomalous spike in pediatric gastrointestinal or respiratory cases in one specific district alerts the healthcare organization early to investigate local water contamination or an emerging epidemic.

Mentor tip

Explain that deviation detection spots statistical anomalies/outliers early, and give a concrete public health example (e.g., localized outbreak or environmental hazard).

Option B: Modelling and simulation · Option

Questions 5–9 · 65 marks

Question 5

16 marks

Tropical insect population geometric growth and logistic survival rate models

Modelling and simulation

(a)

2 marks

Substitute $P_{0} = 100$ , $k = 3$ , and $n = 2$ into the geometric growth formula $P_{n} = P_{0} k^{n}$ :
$P_{2} = 100 \times 3^{2} = 100 \times 9 = 900$ insects.

P_{2} = 100 \times 3^{2} = 900

Mentor tip

Show the substitution ( $100 \times 3^{2}$ ) clearly as well as the final value `900`.

(b)

3 marks

Set up a two-column spreadsheet table where Column A holds the month number (`0` to `10` in cells `ColA2:A12`) and Column B holds the population (`B2 = 100` for Month 0):
```
| A | B |
----+-------------+--------------+
1 | Month (n) | Population |
2 | 0 | 100 |
3 | 1 | =B2 * 3 |
4 | 2 | =B3 * 3 |
.. | ... | ... |
12 | 10 | =B11 * 3 |
```
Enter the initial population `100` in cell `B2`, enter the recursive formula `=B2 * 3` (or `=100 * (3^A3)`) in cell `B3`, and replicate (copy/drag) the formula down through row 12 for the first 10 months.

Mentor tip

Draw the cell grid showing row/column labels, the initial value in `B2`, the formula in `B3`, and state that the formula is copied down for 10 rows.

(c)

2 marks

State a clear assumption about how the survival rate of `0.4` interacts with the monthly multiplier (for example, assuming the net monthly multiplier is $k \times 0.4$ , or assuming reproduction factor $k = 2$ combined with $0.4$ twice as in $100 \times 0.8 = 64$ , or multiplying each month's population formula by `* 0.4`).
In the spreadsheet, modify the formula in cell `B3` to multiply the previous month's population by both the growth factor and the survival constant `0.4` (e.g., `=B2 * k * 0.4`), and copy this formula down across all 10 monthly rows.

Mentor tip

State your assumption explicitly (e.g., applying the 0.4 survival factor at the end of each monthly reproductive cycle) and show how the cell formula is updated and copied down.

(d)

5 marks

Initialize the survival rate `X = 0.4` and constant `R = 3`, then loop across the first 10 months, outputting the survival rate and updating `X` using $x_{n + 1} = r x_{n} (1 - x_{n})$ :
```
R = 3
X = 0.4
loop MONTH from 1 to 10
output "Month ", MONTH, ": ", X
X = R * X * (1 - X)
end loop
```

x_{n + 1} = r x_{n} (1 - x_{n})

Mentor tip

Ensure all 5 algorithmic elements are present: initializing `R = 3` and `X = 0.4`, looping 10 times, calculating `R * X * (1 - X)`, updating `X`, and outputting the rate each month.

(e)

4 marks

In the **Constant survival rate** row, the population declines monotonically every month (`100, 64, 51, ..., 11`) towards extinction ( $0$ ).
In the **Changing survival rate** row, the population initially drops from `100` to `72` and then oscillates in a stable equilibrium between `61` and `71`.
To compare accuracy, ecologists can sample the actual island insect population over several months and compare field counts against both trajectories.
If the real-world species persists in a stable ecological balance rather than dying out rapidly, the changing survival rate (logistic feedback) model is validated as more accurate.

Mentor tip

Question 6

15 marks

City influenza epidemic risk modelling, simulation testing, and public health response

Modelling and simulation

(a)

2 marks

Collect standardized medical records from hospitals and clinics for patients who have contracted the flu (recording age, gender, pre-existing conditions, and symptom severity/duration).
Perform statistical correlation analysis across these patient records to identify which demographic and health traits appear most frequently in severe cases.

Mentor tip

Mention both gathering patient demographic/severity records from clinics and analyzing correlations among affected individuals.

(b)

4 marks

Collate the clinical data on severe cases to assign numerical risk weights or boolean rules to the key risk factors (`Age`, `Gender`, and `Current_Health` / pre-existing conditions).
Define a mathematical risk-scoring model or classification tiers (e.g., High Risk if `Age > 65` AND `PreExistingCondition == true`).
Query the city's census or healthcare population database using these model rules to categorize every resident by how many risk factors they possess.
Sum the counts in the high-risk categories to estimate the total number of vulnerable citizens who urgently require the limited vaccine.

Mentor tip

Trace the 4 steps: collate clinical data -> formalize rules on age, gender, and health -> apply the rules to city population records -> count the resulting high-risk group.

(c)

2 marks

Mentor tip

Identify a specific limitation (such as omitted environmental/occupational variables or inaccurate reporting data) and explain how it reduces prediction accuracy.

(d)

3 marks

1. Divide the city into a geographic grid or district zones in the simulation and use current infection records to predict which adjacent zones will see outbreaks next.
2. Each day, compare the simulation's predicted daily case counts per district against the actual new infection records reported by clinics.
3. If discrepancies exist, refine the model by adjusting transmission rate coefficients (or rethinking mobility assumptions) over successive daily iterations until the simulated spread reliably matches real-world data.

Mentor tip

Describe the iterative feedback loop: predict geographic spread -> compare daily predictions with actual outbreak data -> tune model parameters/coefficients.

(e)

4 marks

Targeted Allocation of Limited Vaccines (from the Risk Model): By identifying the exact demographic groups most vulnerable to severe illness, health authorities can prioritize distributing the scarce vaccine supply to high-risk citizens first and send them targeted early-warning health advisories.
Geographic Containment Measures (from the Spread Simulation): By predicting which city districts are immediately at risk of rapid transmission, authorities can proactively close schools, restrict public gatherings/transport, and deploy mobile medical clinics to those specific neighbourhoods before cases peak.

Mentor tip

Question 7

14 marks

Bridge architecture CAD wireframe modelling, memory representation, and structural stress testing

Modelling and simulation

(a)

3 marks

The wireframe displays the structural skeleton of the bridge (span and support struts) as a network of connected lines and vertices associated with modifiable parameters (`width`, `length`, `thickness`, `material`).
The architect can adjust parameters either by typing new numerical dimensions into property fields or by interactively dragging vertices/lines on screen.
By applying geometric rotation, pan, and zoom transformations to the wireframe coordinates, the architect can inspect the bridge structure from any 3D angle or perspective.

Mentor tip

Explain how the wireframe represents structural lines/nodes, how parameters are modified (input cells or dragging vertices), and how 3D rotation allows viewing from any angle.

(b)

4 marks

Vertices and Edges: Each structural line (edge) in the wireframe is stored in memory as a mathematical vector defined by the 3D Cartesian coordinates $(x, y, z)$ of its two endpoints (vertices).
Topology / Connectivity Table: A table or list links vertices together to define which edges connect, cross, or form geometric primitives (triangles/polygons).
Structural Attributes: Material properties and parameters (such as strut thickness, length, and elasticity) are stored as attributes linked to each edge/object in the data structure.
Mathematical projection algorithms use these coordinate tables to compute intersections and determine visible lines from a given camera viewpoint.

Mentor tip

Mention 3D vertex endpoint coordinates $(x, y, z)$ , edge connectivity lists/vectors, linked physical parameters (thickness/material), and mathematical formulas for intersections/views.

(c)

3 marks

Minimal Computational Overhead: Translating a wireframe vector list from memory to the screen requires far less CPU/GPU processing and memory than a fully rendered solid view.
Real-Time Interactive Editing: Because the computer does not have to recalculate complex surface shading, textures, ray-traced lighting, or hidden-surface removal after every tweak, the architect can rotate the bridge and modify dimensions instantaneously without lag.

Mentor tip

Contrast the fast, low-memory vector recalculation of a wireframe with the heavy computational cost of re-rendering lighting, textures, and solid surfaces.

(d)

4 marks

Step 1 — Load Testing: Simulate both normal traffic loads and extreme maximum-capacity traffic congestion (heavy trucks bumper-to-bumper) across the bridge span.
Step 2 — Environmental Stress Testing: Subject the model simultaneously to extreme weather and seismic conditions, such as hurricane-force crosswinds (gales), earthquakes, and extreme thermal expansion/contraction (freezing cold and intense heat).
Step 3 — Structural Response Measurement: Measure physical stress, torsion, vibration resonance, and deflection/bending across the span and struts against safety thresholds.
Step 4 — Iterative Redesign: If any strut or span exceeds safe stress tolerances, modify the material or dimensions in the model and re-run the simulation until the design passes all safety scenarios.

Mentor tip

Include extreme traffic loads, extreme environmental/weather conditions, measuring structural response (bending/stress), and modifying/re-testing if limits are exceeded.

Question 8

9 marks

Feedforward neural network calculation and genetic algorithm weight optimization for OCR

Modelling and simulation

(a)

4 marks

1. **Input to Hidden Layer**: The two input nodes (`A = 0.1` and `B = 0.5`) transmit their values forward along weighted connections to each of the two nodes in the hidden layer.
2. **Hidden Layer Summation**: Each hidden node multiplies its incoming inputs by their respective connection weights and sums them: the top hidden node computes $(0.1 \times 0.5) + (0.5 \times 0.1) = 0.10$ , and the bottom hidden node computes $(0.1 \times 0.5) + (0.5 \times 0.2) = 0.15$ .
3. **Hidden to Output Layer**: The two hidden nodes send their calculated activations forward to the output node `C`, multiplied by the output layer weights (`0.1` and `0.2`).
4. **Output Determination**: Output node `C` sums these weighted signals to produce the final network output: $(0.10 \times 0.1) + (0.15 \times 0.2) = 0.01 + 0.03 = 0.04$ .

H_{1} = (0.1 \times 0.5) + (0.5 \times 0.1) = 0.10 H_{2} = (0.1 \times 0.5) + (0.5 \times 0.2) = 0.15 C = (0.10 \times 0.1) + (0.15 \times 0.2) = 0.04

Mentor tip

Reference the specific weights in the diagram to explain how inputs are multiplied by weights and summed at the hidden layer, then multiplied by output weights and summed at C.

(b)

5 marks

1. **Initial Population**: Generate multiple trial neural networks, each initialized with a random set of connection weights (represented as chromosomes).
2. **Training Set Execution**: Run each trial network across a labeled training dataset of scanned optical characters (letters/digits).
3. **Fitness Evaluation**: Evaluate each weight set using a predefined fitness function, such as the percentage of characters accurately recognized.
4. **Selection, Crossover, and Mutation**: Select the networks with the highest recognition accuracy, combine subsets of their weight matrices (crossover), and apply small random tweaks to individual weights (mutation) to create a new generation.
5. **Iterative Convergence**: Repeat the testing and evolution cycle over many generations until the network achieves an sufficiently high character recognition accuracy threshold.

Mentor tip

Question 9

11 marks

Evolution of machine translation, chatbot machine learning, and human-robot gesture communication

Modelling and simulation

(a)

4 marks

1. **Early Direct / Rule-Based Translation**: Early translators relied on word-for-word dictionary lookup and rigid syntactic grammar rules (identifying nouns, verbs, adjectives).
2. **Syntactic & Semantic Ambiguity Challenges**: Rule-based systems struggled because natural language is context-dependent (semantics)—many words serve as both nouns and verbs or have idioms that fail literal word-by-word substitution.
3. **Phrase-Based & Corpus Systems**: Incorporating common multi-word phrases and idioms improved local fluency over pure word lookup.
4. **Modern Statistical & Neural Data-Driven Translation**: Advances in memory and processing power enabled modern translators to analyze massive bilingual text corpora (accumulated knowledge), using statistical probabilities and deep neural networks to translate whole sentences based on semantic context rather than isolated words.

Mentor tip

(b)

3 marks

Early chatbots relied on simple keyword spotting and repeating pre-scripted template responses (like ELIZA).
They progressed into domain-specific expert systems coupled with speech-to-text recognition.
Modern chatbots use machine learning and natural language processing to continuously learn from past user conversations, adapting their probability models and knowledge base to provide more natural, context-aware responses over time.

Mentor tip

Show the progression from static keyword repetition -> expert system rules / speech recognition -> adaptive machine learning from ongoing user interactions.

(c)

4 marks

Ambiguity of Spoken Natural Language: Human speech frequently omits strict syntax, relies on context-dependent semantics, and uses words with multiple meanings or homophones.
Probabilistic Machine Learning: Robots learn language via rules, heuristics, and statistical probabilities of word combinations over repeated interactions.
Disambiguation via Physical Gestures: Combining visual recognition of human physical signs (pointing, facial expressions, hand gestures) with spoken commands provides crucial non-verbal context that resolves verbal ambiguity (e.g., pointing at a specific tool while saying `'pick that up'`).
Reinforcement through Observation and Imitation: Watching a human demonstrate a physical movement and repeating the action reinforces the cognitive mapping between a spoken instruction and the required motor task.

Mentor tip

Option C: Web science · Option

Questions 10–13 · 65 marks

Question 10

14 marks

Internet vs WWW, TCP packet transmission, IPv4 to IPv6 upgrade, DNS impact, and file compression

Web science

(a)

2 marks

The **Internet** is the global physical hardware infrastructure—a network of interconnected networks (routers, cables, servers) that transports data packets using protocols like TCP/IP.
The **World Wide Web (WWW)** is an application-layer collection of interlinked hypertext documents, multimedia resources, and social services accessed *on top of* the internet via HTTP/HTTPS.

Mentor tip

Contrast the physical network infrastructure/transport layer (Internet) with the hypertext information/application service running over it (WWW).

(b)

3 marks

1. **Segmentation**: TCP breaks the large file into smaller numbered data packets (segments) sized appropriately for IP transmission.
2. **Connection & Reliable Delivery**: TCP establishes an end-to-end connection between the web server and client and manages flow control.
3. **Error Checking & Reassembly**: TCP verifies checksums, requests retransmission of any lost or corrupted packets, and reassembles the packets in the exact sequential order at the destination.

Mentor tip

Include packet segmentation, connection management, and error checking/retransmission/reassembly.

(c)

3 marks

The rapid global growth of internet users, smartphones, and Internet of Things (IoT) devices requires every connected device to have its own unique IP address.
The 32-bit `IPv4` protocol provides only $2^{32}$ ( $\approx 4.3 billion$ ) unique addresses, which have been exhausted.
Upgrading to the 128-bit `IPv6` protocol expands the address space to $2^{128}$ unique addresses, accommodating future device growth.

Mentor tip

Connect three points: rapid growth of connected devices -> each device needing a unique IP -> exhaustion of $2^{32}$ IPv4 addresses requiring $2^{128}$ IPv6.

(d)

1 mark

DNS server tables and record structures must be updated (adding `AAAA` records alongside `A` records) to store and return the longer 128-bit hexadecimal IPv6 address format.

Mentor tip

State clearly that DNS lookup tables/entries must be modified to store the new 128-bit address representation.

(e)

5 marks

Lossy Compression Trade-off: Permanently discards redundant or perceptually less noticeable data to achieve much smaller file sizes and significantly faster download speeds, but degrades original quality and cannot restore the exact original bytes.
Lossless Compression Trade-off: Compresses data using statistical redundancy without losing a single bit so the exact original file is reconstructed upon decompression, but results in larger file sizes and slower transfer times compared to lossy.
Evaluation / Conclusion: The choice depends entirely on the type of file being downloaded—if it is executable software, source code, or a text/spreadsheet document, **lossless** compression (e.g., ZIP) is mandatory because any missing bit corrupts the file; if it is streaming video, audio, or photography, **lossy** compression (e.g., MP4, JPEG) is preferable for fast web delivery.

Mentor tip

Discuss the size/speed vs quality/integrity trade-offs of both lossy (2 marks) and lossless (2 marks), then conclude that the optimal choice depends on the file type (1 mark).

Question 11

15 marks

ACAME cartoon portal: URL vs URI, IP authentication flaws, CSS advantages, and distributed servers

Web science

(a)(i)

1 mark

`minerva.hq.acame.net`

Mentor tip

Extract the exact host/domain segment between `http://` and the first single slash `/`.

(a)(ii)

1 mark

`/Products/index.html` (or `Products/index.html`)

Mentor tip

Include both the directory (`Products`) and file name (`index.html`) after the domain name.

(b)

2 marks

A Uniform Resource Identifier (`URI`) uniquely identifies a resource (`mailto:sly.coyote@acame.net` identifies an email recipient), whereas a `URL` must also specify the exact network location and retrieval protocol path to fetch the resource.
Because a `mailto:` link does not specify the receiving mail server's physical location, incoming port, or retrieval protocol (which is controlled entirely on the receiver's side), it is a URI but not a URL.

Mentor tip

Explain that `mailto:` identifies *who* the resource is (URI) but does not specify a fixed server file location or retrieval protocol path (URL).

(c)

2 marks

1. Dynamic / Shared IPs: Legitimate subscribers often have dynamically assigned IP addresses (via DHCP) or log in from different locations/devices (mobile networks, cafes, NAT routers), which would lock them out when their IP changes.
2. IP Spoofing: An attacker can forge (spoof) the source IP address in packet headers to impersonate an authorized subscriber and bypass authentication.

Mentor tip

Mention dynamic IP allocation (DHCP / roaming across devices) and security vulnerabilities like IP spoofing or shared public NAT addresses.

(d)(i)

2 marks

Mentor tip

Explain one clear user benefit: either faster loading via cached external stylesheets / smaller HTML, or responsive layout adaptation across device screens.

(d)(ii)

2 marks

Mentor tip

Highlight how editing a single shared CSS file updates site-wide styling instantly and separates HTML content from visual design.

(e)

5 marks

Technical Features & Benefits: A distributed server network mirrors cartoon files across multiple geographical nodes and balances traffic load; users are routed to the nearest or least congested server (or download fragments in parallel via P2P/CDN), resulting in faster download speeds and high fault tolerance if one server fails.
Management & Legal Complexities: Operating servers across multiple countries introduces varying national copyright laws, censorship regulations, and telecom infrastructure disparities.
Synchronization & Cost Overheads: Keeping newly released cartoons synchronized across all mirror nodes increases administrative overhead, and differences in regional server infrastructure can lead to fragmented control and inconsistent Quality of Service (QoS) for subscribers in different locations.

Mentor tip

Question 12

16 marks

Dynamic country-town web form, open standards, white hat SEO, and Creative Commons licensing

Web science

(a)

3 marks

1. When the user selects a country in the first dropdown window, an event listener (`onchange`) triggers a client-side JavaScript function (or AJAX/servlet request).
2. The script passes the selected country name as a parameter to look up the associated list of towns (either from a client-side data array or by querying the server database asynchronously).
3. The script dynamically populates and updates the DOM options of the second dropdown window to display only the towns matching that country without reloading the entire page.

Mentor tip

Trace the three steps: user country selection invokes a script -> country passed as parameter to retrieve matching towns -> second window populated dynamically.

(b)

4 marks

Open standards (such as `HTTP`, `HTML`, `XML`, `SOAP`, and `W3C` specifications) define publicly agreed-upon rules and formats for exchanging information across the web.
They guarantee **interoperability**, allowing heterogeneous school websites built on completely different hardware platforms, operating systems, and server software to communicate seamlessly with the central portal.
Without open standards, ad-hoc proprietary formats would cause compatibility failures, broken dynamic scripts, and inconsistent search behaviour across different schools' systems.

Mentor tip

Emphasize interoperability across diverse platforms/systems, W3C standardization (HTTP/XML/SOAP), and avoiding proprietary compatibility failures.

(c)

3 marks

Technique — Meaningful `<meta>` Tags and Semantic Headings: Including accurate, descriptive keywords (such as `'Computer Science classes'`, town name, and school name) inside `<title>`, `<meta name="description">`, and `<h1>`/`<h2>` header tags.
Explanation: When search engine crawlers parse the page, clean HTML separated from CSS presentation allows indexers to immediately identify the page's core topic and match it accurately against student search queries, improving ranking legitimately.

Mentor tip

(d)

6 marks

What Creative Commons (CC) Is: Creative Commons is a standardized public copyright licensing framework that allows creators to retain ownership/copyright of their work while granting advance permission for others to share, reuse, or adapt the material under specified conditions.
Key License Conditions: Authors can mix modular conditions such as Attribution (`BY`), Non-Commercial (`NC`), No Derivatives (`ND`), or ShareAlike (`SA`) rather than locking content under strict `'All Rights Reserved'` copyright.
Application Example in School Context: A computer science teacher at one school creates Java programming worksheets and past-paper revision guides and publishes them on their school website under a `CC BY-NC-SA` license; teachers and students at other schools across the country can legally download, study, and adapt these resources for free classroom use (establishing a consistent national standard of learning material) provided they credit the original author and do not sell the notes commercially.

Mentor tip

Dedicate up to 4 points to explaining Creative Commons (retaining copyright while enabling conditional sharing via BY/NC/SA rules) and 2 points to a concrete school CS resource sharing example.

Question 13

20 marks

Bowtie web graph analysis, search ranking failures, folksonomies, and collective intelligence misinformation

Web science

(a)

2 marks

Trace the directed cycles in the graph where every node can reach every other node and return: `A, D, G, H, K, L, M, P`.

Mentor tip

Check mutual reachability carefully: `A -> G -> K -> D -> H -> L -> P -> M -> G -> D -> A` forms the strongly connected core `{A, D, G, H, K, L, M, P}`.

(b)

1 mark

Identify nodes reachable from the SCC that have no directed path leading back into the SCC: `E, I, N`.

Mentor tip

From SCC node `D`, edges lead out to `E -> I -> N` (and `H -> N`), with no outgoing arrows returning to the SCC.

(c)

2 marks

**No**.
Reason: Node `F` is part of the `IN` component because it leads directly into the SCC (`F -> D`), and since `J` links into `F` (`J -> F -> D`), `J` can also reach the SCC (so `J` is an `IN` node, whereas a tendril from `IN` must branch *outward* away from `IN` without reaching the SCC).

Mentor tip

Note the arrow direction: `J -> F -> D` means `J` has a directed path into the SCC, making it part of `IN` rather than a dead-end tendril.

(d)

2 marks

Add a directed edge from any `IN` node (`C`, `F`, `J`, or `O`) directly to any `OUT` node (`E`, `I`, or `N`)—for example, a directed edge from `C` to `E` (`C -> E`) or `O` to `I` (`O -> I`).
Justification: A **tube** is defined as a directed path that connects a node in the `IN` component directly to a node in the `OUT` component while completely bypassing the Strongly Connected Core (`SCC`).

Mentor tip

Pick any node in `{C, F, J, O}` and draw a directed edge to any node in `{E, I, N}`, explaining that a tube links IN to OUT without passing through the SCC.

(e)

6 marks

Reason 1 — Poor SEO / Missing Keywords & Metadata: If the web developer failed to include relevant keywords or descriptive `<meta>`/`<title>` tags, the indexer cannot match the page accurately to the user's search query, resulting in an artificially low rank.
Reason 2 — Newly Published Page / Lack of Backlinks (or Deep Web): A brand-new webpage has very few inbound links from authoritative sites (or has not yet been crawled/indexed if it sits in the deep web), causing link-based algorithms like PageRank to rank it poorly despite high-quality content.
Reason 3 — Black Hat SEO Manipulation / Search Engine Demotion: Either a competitor used black-hat link farms/keyword stuffing to temporarily outrank legitimate pages, or the page itself was penalized and demoted by the search engine for using manipulative SEO techniques.

Mentor tip

(f)

2 marks

Mentor tip

Highlight that user-generated tags lack a formal hierarchical taxonomy and suffer from imprecise language, synonyms, and personal jargon.

(g)

5 marks

Concept of Collective Intelligence & Social Aggregation: Collective intelligence arises when a cohesive group pools knowledge or follows influential figures around a shared interest; social networks rapidly aggregate users around emotional topics like serious illnesses through hashtags, folksonomies, and viral sharing.
Mechanism of Exploitation: Promoters of an untested 'miracle cure' can exploit desperate patients' hope and emotional vulnerability by coordinating likes, shares, testimonials, and user tags to manufacture an illusion of widespread public consensus and scientific legitimacy.
Algorithmic Amplification: Even sceptics and doctors who visit the hoax page to debate or debunk the claim inadvertently increase the site's traffic, engagement metrics, and inbound links, which search engines and social media feeds interpret as high authority—pushing the dangerous misinformation to the top of search rankings and potentially pressuring politicians or health agencies.

Mentor tip

Option D: Object-oriented programming · Option

Questions 14–20 · 65 marks

Question 14

5 marks

TrainCompany constructor overloading and protected access modifier

Object-oriented programming

(a)

3 marks

This is an example of **polymorphism** via **constructor overloading**.
Both constructors share the class name `TrainCompany`, but they have distinct **parameter signatures** (`TrainCompany(String x, String y)` takes two `String` arguments, whereas `TrainCompany()` takes no arguments).
At compile time, the compiler differentiates between them by matching the arguments passed in the `new TrainCompany(...)` call to the corresponding parameter list.

Mentor tip

Mention constructor overloading / polymorphism, different parameter lists (signatures), and how the compiler matches the call arguments to the correct constructor.

(b)

2 marks

Declaring the accessor and mutator methods as `protected` restricts their visibility so they can only be called by classes within the **same package** or by **subclasses** (via inheritance) of `TrainCompany`.
External, unrelated classes in other packages would be unable to access or modify `TrainCompany` attributes through these methods.

Mentor tip

State clearly that `protected` restricts access to subclasses and classes within the same package/project.

Question 15

8 marks

Journey class data types, constructor implementation, and code trace

Object-oriented programming

(a)

2 marks

`routeCode`: `String` (stores alphanumeric identifiers like `"J100"`).
`delay`: `int` (or `double`, storing minutes late like `3`, `8`, `10`).
`weatherRelated`: `boolean` (stores `true` or `false`).

Mentor tip

All three types must be exact (`String`, `int`, `boolean`) to earn full marks.

(b)

3 marks

Write the public constructor with the exact class name `Journey` and three parameters matching the attributes, assigning each parameter to its instance variable:
```java
public Journey(String rCode, int d, boolean w) {
this.routeCode = rCode;
this.delay = d;
this.weatherRelated = w;
}
```

Mentor tip

Ensure the header is `public Journey(String ..., int ..., boolean ...)` with no return type and assign all three fields.

(c)

3 marks

1. `allCompanies[0].getCompanyCode()` outputs the code for `"Southern"`: `T290`.
2. `allCompanies[0]` had journeys `s` (index 0), `u` (index 1), and `J101` (index 2) added to it; therefore `allCompanies[0].getJourney(1).getDelay()` returns the delay of `u`: `10`.
3. `allCompanies[1]` (`"Northern"`) only had journey `t` added to it, so `allCompanies[1].getNumberOfJourneys()` outputs: `1`.

Mentor tip

Trace which company receives each journey carefully: `allCompanies[0]` gets `s` (index 0), `u` (index 1, delay 10), and `J101` (index 2), while `allCompanies[1]` gets `t` (count 1).

Question 16

7 marks

Calculating non-weather average delay in TrainCompany

Object-oriented programming

(a)

1 mark

`allCompanies[0]` has three journeys: `s` (delay `3`, `weatherRelated = false`), `u` (delay `10`, `weatherRelated = true` — excluded), and `J101` (delay `6`, `weatherRelated = false`).
The average of the non-weather delays is $(3 + 6) /2 = 4.5$ .

\frac{3 + 6}{2} = 4.5

Mentor tip

Exclude journey `u` because its `weatherRelated` flag is `true`, leaving $(3 + 6) /2 = 4.5$ .

(b)

6 marks

Initialize a running `double totalDelay = 0.0` and an `int count = 0` for non-weather journeys.
Loop from `0` up to `numberOfJourneys`, check `!journeyHistory[i].getWeatherRelated()`, accumulate `getDelay()` and increment `count`, then return `totalDelay / count`:
```java
public double averageDelay() {
double totalDelay = 0.0;
int count = 0;
for (int i = 0; i < numberOfJourneys; i++) {
if (!journeyHistory[i].getWeatherRelated()) {
totalDelay = totalDelay + journeyHistory[i].getDelay();
count++;
}
}
return totalDelay / count;
}
```

Mentor tip

Do not divide by `numberOfJourneys`! You must maintain a separate `count` of non-weather journeys and use accessor methods `getWeatherRelated()` and `getDelay()`.

Question 17

10 marks

Codes class UML diagram and longestDelay() lookup method

Object-oriented programming

(a)

3 marks

Construct the 3-compartment UML class diagram for `Codes` using `-` for `private` attributes and `+` for `public` methods:
```
+----------------------------------+
| Codes |
+----------------------------------+
| - routeName : String |
| - routeCode : String |
+----------------------------------+
| + Codes(a: String, b: String) |
| + getRouteCode() : String |
| + getRouteName() : String |
+----------------------------------+

Mentor tip

Include visibility symbols (`-` for private fields, `+` for public constructor/getters) and return types (`: String`).

(b)

7 marks

First, loop through the `numberOfJourneys` in `journeyHistory[]` to find the maximum delay among journeys where `!getWeatherRelated()` is true, recording its `maxCode`.
Second, loop through the `Codes[] c` array to match `maxCode` with `c[y].getRouteCode()` and return the corresponding `c[y].getRouteName()`:
```java
public String longestDelay(Codes[] c) {
int maxDelay = -1;
String maxCode = "";
for (int i = 0; i < numberOfJourneys; i++) {
if (!journeyHistory[i].getWeatherRelated() &&
journeyHistory[i].getDelay() > maxDelay) {
maxDelay = journeyHistory[i].getDelay();
maxCode = journeyHistory[i].getRouteCode();
}
}
String route = "";
for (int j = 0; j < c.length; j++) {
if (c[j] != null && c[j].getRouteCode().equals(maxCode)) {
route = c[j].getRouteName();
}
}
return route;
}
```

Mentor tip

Question 18

15 marks

Transport hierarchy inheritance, class dependency diagram, low coupling, and toString()

Object-oriented programming

(a)

4 marks

Create a general parent superclass (e.g., `TransportCompany`) containing all shared attributes (`companyName`, `companyCode`, `numberOfJourneys`, `journeyHistory[]`) and common methods (`addJourney()`, `averageDelay()`, `longestDelay()`).
Define specialized subclasses `TrainCompany`, `BusCompany`, and `AirplaneCompany` using `extends TransportCompany`.
Each subclass automatically inherits the shared attributes and delay-analysis methods from `TransportCompany` without duplicating code.
Each subclass can also declare its own mode-specific attributes (e.g., airport hub code or bus fleet size) and override inherited methods if calculation rules differ.

Mentor tip

(b)(i)

4 marks

Draw a class relationship diagram linking all six classes (`TransportCompany`, `TrainCompany`, `BusCompany`, `AirplaneCompany`, `Journey`, and `Codes`) with labeled relationship arrows:
```
+--------------------+ has-a (contains) +---------+
| TransportCompany | ------------------------> | Journey |
+--------------------+ +---------+
^ ^ ^ |
is-a | is-a | is-a | uses |
+------+ | +--------+ +--------+
| | | v
+-------+ +--------+ +---------+ +-------+
| Train | | Bus | | Plane | ----> | Codes |
+-------+ +--------+ +---------+ uses +-------+
```
- **Inheritance (`is-a`)**: `TrainCompany`, `BusCompany`, and `AirplaneCompany` inherit from `TransportCompany`.
- **Aggregation (`has-a`)**: `TransportCompany` (or `TrainCompany`) contains an array of `Journey` objects.
- **Dependency (`uses`)**: `TransportCompany` / `TrainCompany` uses `Codes` as a parameter in `longestDelay(Codes[] c)` and `toString(Codes[] c)`.

Mentor tip

Clearly distinguish and label all three relationship types: 'is-a' (inheritance from Transport superclass), 'has-a' (aggregation with Journey), and 'uses' (dependency on Codes).

(b)(ii)

3 marks

High dependency (tight coupling) means that modifying the internal implementation or data types of one class forces programmers to rewrite dependent classes, increasing maintenance overhead and the risk of regression bugs.
Keeping dependencies to a minimum (loose coupling) allows individual developers to modify or reuse a class independently without breaking other modules.
Example: Because `TrainCompany.longestDelay(Codes[] c)` depends on `Codes`, if a programmer changes `routeCode` in `Codes` from a `String` to an `int`, `TrainCompany` will fail to compile until its lookup logic is also rewritten.

Mentor tip

Explain that changes in one class ripple into dependent classes (increasing maintenance cost), and give a concrete example involving `TrainCompany` and `Codes` or `Journey`.

(c)

4 marks

Construct `toString(Codes[] c)` by concatenating `companyName`, the return value of `averageDelay()`, and the return value of `longestDelay(c)` with the required separator labels:
```java
public String toString(Codes[] c) {
return companyName + " : Average Delay = " + averageDelay() +
" minutes : Longest Delay = " + longestDelay(c);
}
```

Mentor tip

Reuse `this.companyName`, `averageDelay()`, and `longestDelay(c)` directly inside the string concatenation and return the resulting `String`.

Question 19

7 marks

Static array inefficiencies and Binary Search Tree route lookup

Object-oriented programming

(a)

2 marks

Static arrays have a fixed capacity allocated at instantiation (`new Journey[100000]` and `new TrainCompany[3]`).
If a small regional train company only completes a few hundred journeys, pre-allocating `100,000` array slots wastes a large amount of RAM; conversely, if a major company exceeds `100,000` journeys (or a 4th company is added to `allCompanies[3]`), the array overflows and requires expensive copying into a newly allocated array.

Mentor tip

Point directly to `journeyHistory = new Journey[100000]` (wasted memory if mostly empty) or `allCompanies = new TrainCompany[3]` (overflow if more items are needed).

(b)

5 marks

1. **Data Structure Selection**: Store the `Codes` objects in a **Binary Search Tree (BST)** (or a Hash Table / sorted array for binary search) ordered alphabetically by `routeCode`.
2. **Tree Construction**: Insert each `Codes` object starting at the root node, placing objects with a lexicographically smaller `routeCode` into the left subtree and larger `routeCode` into the right subtree.
3. **Search Process**: When looking up a target `routeCode`, start at the root node and compare the target code with the current node's `routeCode`.
4. **Logarithmic Elimination**: Move to the left child if the target is smaller or the right child if larger, eliminating half of the remaining tree at each step ( $O (lo g n)$ time instead of $O (n)$ linear scan).
5. **Result Retrieval**: Once the matching `routeCode` node is reached, return its `getRouteName()` value.

Mentor tip

Describe both how the Binary Search Tree is ordered/built by `routeCode` and how searching traverses left/right from the root to halve the search space at each comparison.

Question 20

13 marks

Abstract Data Types (ADTs), LinkedList vs ArrayList efficiency, and deduplicating allCodes[]

Object-oriented programming

(a)

3 marks

Abstraction and Information Hiding: Library ADTs expose a documented public interface (API) with intuitive, standardized method names such as `add()`, `remove()`, and `get()`.
The programmer only needs to know the **method signature**—what parameters to pass in and what return value/effect to expect.
All low-level implementation details (such as internal pointer manipulation or dynamic array resizing) are encapsulated and hidden inside the library class.

Mentor tip

Connect descriptive method names/documentation, knowing required parameters and return types, and encapsulation hiding internal implementation details.

(b)

3 marks

Train journeys are continually appended as trains arrive throughout the year, resulting in frequent insertions.
Adding a new `Journey` node to a `LinkedList` takes constant $O (1)$ time by simply allocating a node and updating the tail pointer/reference.
In contrast, an `ArrayList` is backed by a contiguous array that periodically fills up, requiring an expensive $O (n)$ reallocation and copying of all existing references into a larger array.

Mentor tip

Contrast $O (1)$ pointer adjustment when appending to a `LinkedList` with the periodic array resizing and copying overhead of an `ArrayList`.

(c)

7 marks

Instantiate a new `ArrayList<Codes>`, add the first element `allCodes[0]`, and iterate through the remaining non-null elements of `allCodes[]`.
For each current element `allCodes[x]`, loop through all previously inspected elements (`0` to `x - 1`, or through the `ArrayList`) comparing `getRouteCode()`; if no duplicate is found, add `allCodes[x]` to the `ArrayList`:
```java
public ArrayList<Codes> convert() {
ArrayList<Codes> uniqueList = new ArrayList<Codes>();
if (allCodes[0] != null) {
uniqueList.add(allCodes[0]);
}
int x = 1;
while (x < allCodes.length && allCodes[x] != null) {
boolean duplicate = false;
for (int y = 0; y < x; y++) {
if (allCodes[x].getRouteCode().equals(allCodes[y].getRouteCode())) {
duplicate = true;
}
}
if (!duplicate) {
uniqueList.add(allCodes[x]);
}
x++;
}
return uniqueList;
}
```

Mentor tip

Our analysis

Where the marks are

Each part sorted by the topic it mostly tests. Databases carries the most marks on this paper.

Databases65 marks · 25%
Q1, Q2, Q3, Q4
Modelling and simulation65 marks · 25%
Q5, Q6, Q7, Q8, Q9
Web science65 marks · 25%
Q10, Q11, Q12, Q13
Object-oriented programming65 marks · 25%
Q14, Q15, Q16, Q17, Q18, Q19, Q20

Mentor insights

Traps to watch for

01
Databases: Healthcare organization object-oriented database, concurrency, da · Q4
Describe any two core OODB characteristics: encapsulation of data + methods, complex modularity/multimedia support, unique object identity (OID), transparent persistence, or inheritance hierarchies.
02
Modelling and simulation: Tropical insect population geometric growth and logistic survival · Q5
Show the substitution ( $100 \times 3^{2}$ ) clearly as well as the final value `900`.
03
Web science: Bowtie web graph analysis, search ranking failures, folksonomies, · Q13
Check mutual reachability carefully: `A -> G -> K -> D -> H -> L -> P -> M -> G -> D -> A` forms the strongly connected core `{A, D, G, H, K, L, M, P}`.
04
Object-oriented programming: Transport hierarchy inheritance, class dependency diagram, low co · Q18
Identify the new superclass (`TransportCompany`), the three subclasses (`Train`, `Bus`, `Airplane`), the common fields/methods placed in the superclass, and how subclasses inherit and extend/override them.

Solutions and tips are GeorgeTheTutor's own; the questions are not reproduced here. Not affiliated with or endorsed by the International Baccalaureate Organization.

Want someone to go through your paper with you?

Our maths mentors took these exams recently. One-to-one, they'll find where your marks are going and fix it before May.

Find your maths mentor More past papers