Background Concept

Storage units use two different prefix systems.

• Binary prefixes are based on powers of 2. Examples are kibibyte (KiB), mebibyte (MiB) and gibibyte (GiB).
• Decimal prefixes are based on powers of 10. Examples are kilobyte (KB), megabyte (MB), gigabyte (GB) and terabyte (TB).

This matters because computers work in binary, so some units are based on $2^{10} = 1024$, while others are based on 1000.

Useful facts here are:

• $1$ KiB = $1024$ bytes
• $1$ GB = $1000$ MB
• $1$ TB = $1000$ GB

Understanding the Question

This part gives four blanks to complete:

1. identify what kind of prefix a kibibyte uses
2. convert 3 kibibytes into bytes
3. identify what kind of prefix a megabyte uses
4. convert 2 terabytes into gigabytes

The key clue is the spelling:

• kibibyte means binary prefix
• megabyte means decimal prefix

Approach

Use the unit name to decide whether the prefix system is binary or decimal.

• For kibibyte, use 1024 bytes per KiB.
• For terabyte to gigabyte, use decimal scaling, so multiply by 1000.

Then fill in the four missing values directly.

Step-by-Step Reasoning

First blank:

• A kibibyte belongs to the binary-prefix family.
• So the first answer is binary.

Second blank:

• $1$ KiB = $1024$ bytes
• $3$ KiB = $3 \times 1024 = 3072$ bytes
• So the second answer is 3072.

Third blank:

• A megabyte belongs to the decimal-prefix family.
• So the third answer is decimal.

Fourth blank:

• $1$ TB = $1000$ GB
• $2$ TB = $2 \times 1000 = 2000$ GB
• So the fourth answer is 2000.

Key Takeaways

• Kibi-, mebi-, gibi- are binary prefixes.
• Kilo-, mega-, giga-, tera- are decimal prefixes.
• Always check whether the question is using binary or decimal units before converting.

Common Mistakes

• Writing decimal for kibibyte. This is wrong because kibi is specifically a binary prefix.
• Using 1000 instead of 1024 for kibibytes.
• Confusing gigabytes and gibibytes.
• Writing 2048 for 2 TB to GB by incorrectly using binary scaling.

Things to Be Careful About

• Read the unit name exactly: kibibyte is not the same as kilobyte.
• In exam questions, answers to blanks normally need just the word or number, not a full sentence.
• Do not mix binary and decimal systems in the same conversion unless the question explicitly asks for it.

Background Concept

Hexadecimal is base 16, so each digit represents a power of 16. The hexadecimal digits are:

• 0 to 9 for values 0 to 9
• A for 10
• B for 11
• C for 12
• D for 13
• E for 14
• F for 15

To convert from denary to hexadecimal, repeatedly divide by 16 and use the remainders.

Understanding the Question

The question asks for the denary number 241 to be written in hexadecimal.

Since the answer is only worth 1 mark, the examiner is looking for the correct final hex value.

Approach

Divide 241 by 16:

• the quotient gives the left hex digit
• the remainder gives the right hex digit

Then convert any value from 10 to 15 into the matching hex letter.

Step-by-Step Reasoning

Start with 241.

Divide by 16:

• $241 \div 16 = 15$ remainder $1$

So the hexadecimal number has:

• first digit = 15
• second digit = 1

Now convert 15 into hexadecimal:

• 15 = F

So the digits are:

• F followed by 1

Therefore, 241 in hexadecimal is F1.

You can check it by converting back:

• $F1_{16} = 15 \times 16 + 1 = 240 + 1 = 241$

Key Takeaways

• Denary to hexadecimal conversion uses division by 16.
• Remainders become the hexadecimal digits.
• Values 10 to 15 must be written as A to F.

Common Mistakes

• Writing 151 by keeping 15 as a denary number instead of converting it to F.
• Reversing the digits and writing 1F.
• Forgetting that hexadecimal uses letters for values greater than 9.

Things to Be Careful About

• Read the digits in the correct order: quotient digit first, remainder digit second for a two-digit result.
• Make sure you are converting to hexadecimal, not binary.
• In a 1-mark question, a wrong hex letter loses the whole mark.

Background Concept

Binary addition is done using a fixed number of bits, such as 8 bits or 16 bits. A fixed-width binary system can only represent a limited range of values.

An overflow happens when the result of an addition goes outside that range. In other words, the answer would need more bits than are available.

For example, with 8 bits for unsigned numbers, the largest value is 255. If an addition produces 256 or more, overflow occurs.

Understanding the Question

The question does not ask you to perform a calculation. It asks for the meaning of overflow in binary addition.

So the correct response is a short definition, not an example or a method.

Approach

State the essential idea:

• there is a fixed number of bits available
• the sum does not fit into those bits

That is enough for full credit in a one-mark definition question.

Step-by-Step Reasoning

When two binary numbers are added:

1. the CPU works within a fixed bit length
2. the result may need an extra bit
3. if that extra bit cannot be stored in the allowed width, the result cannot be represented properly

That situation is called overflow.

A concise exam answer is:

• the result is too large to fit in the available number of bits

Key Takeaways

• Overflow is about exceeding the representable range.
• It happens because binary values are stored using a fixed number of bits.
• In exam definitions, mention the idea of the result not fitting.

Common Mistakes

• Saying only "there is a carry". A carry on its own is not always enough as a definition unless it is clearly linked to the result not fitting in the bit length.
• Describing underflow or negative numbers instead of overflow.
• Writing about memory capacity instead of binary arithmetic.

Things to Be Careful About

• Use the phrase available number of bits or fixed number of bits.
• Keep the answer general; you do not need to mention signed or unsigned unless the question asks.
• Do not confuse overflow with simply making an arithmetic mistake.

Background Concept

A bitmap image stores its picture as a grid of pixels. Each pixel needs some storage, and the total file size depends mainly on:

• the number of pixels in the image
• the amount of data stored for each pixel

The number of pixels comes from the resolution:

Then the file size is found by multiplying the total number of pixels by the storage needed per pixel. If the question gives bytes per pixel directly, that can be used immediately. If it gives bits per pixel, you would divide by 8 to convert bits to bytes.

For an estimate in megabytes, exam questions usually use:

Understanding the Question

The photograph is a bitmap image with:

• width = 4000 pixels
• height = 3000 pixels
• bit depth given as 4 bytes per pixel

The question asks for an estimate of the file size in megabytes and says to show the working. So we need to:

1. find the number of pixels
2. multiply by 4 bytes for each pixel
3. convert the result into megabytes

Approach

Use the standard bitmap-size method:

1. calculate total pixels from resolution
2. multiply by storage per pixel
3. convert bytes to MB

Because the question already gives 4 bytes, there is no need to convert from bits first.

Step-by-Step Reasoning

First find the total number of pixels:

So the photograph contains 12 million pixels.

Each pixel uses 4 bytes, so total storage is:

Now convert bytes to megabytes:

So the estimated file size is 48 megabytes.

Key Takeaways

• Bitmap size depends on resolution and colour depth.
• Resolution gives the number of pixels.
• File size is total pixels multiplied by storage per pixel.
• Always convert to the units asked for at the end.

Common Mistakes

• Multiplying only one dimension by 4 instead of multiplying the total number of pixels by 4.
• Forgetting to convert the final answer into megabytes.
• Treating 4 bytes as 4 bits, which would make the answer far too small.
• Writing 12 MB by using 4000 \times 3000 and forgetting the 4 bytes per pixel.

Things to Be Careful About

• Read carefully whether the question gives bits or bytes per pixel.
• Keep the units consistent throughout the working.
• Since this asks for an estimate in megabytes, use a sensible MB conversion and present the final answer clearly as MB.

Background Concept

The file size of a bitmap image depends mainly on how much pixel data must be stored. Two of the biggest factors are:

• resolution: the number of pixels in the image
• colour depth (bit depth): how many bits are used for each pixel

If either of these is reduced, the total amount of data needed also falls.

Understanding the Question

The question asks for two elements of a bitmap image that can be changed to reduce file size. So we are looking for properties of the image itself, not compression methods.

The two standard answers are the image dimensions/resolution and the colour depth.

Approach

Think of the bitmap size formula:

• number of pixels
• storage per pixel

To reduce file size, reduce one or both of those.

Step-by-Step Reasoning

1. Resolution / image dimensions
   If the width or height is reduced, the image contains fewer pixels. Fewer pixels means less data to store.

2. Colour depth / bit depth
   If fewer bits are used per pixel, each pixel needs less storage. That reduces the total file size.

These are the two key image elements that directly affect bitmap size.

Key Takeaways

• Bitmap size is strongly affected by resolution and colour depth.
• Lower resolution means fewer pixels.
• Lower colour depth means less data per pixel.

Common Mistakes

• Giving compression as one of the two elements. Compression can reduce file size, but it is not an element of the bitmap itself here.
• Writing "format" without explaining a bitmap property.
• Repeating the same idea twice, such as "width" and "height" separately instead of naming resolution.

Things to Be Careful About

• Use accepted terms such as resolution, image dimensions, colour depth, or bit depth.
• Make sure the two answers are distinct.
• Do not confuse colour depth with the number of colours displayed on screen in general; here it means storage used per pixel.

Background Concept

This question tests how to trace simple assembly-language instructions using different addressing modes.

The important idea is that the opcode tells you both the operation and how to interpret the operand:

• Immediate addressing means use the value itself, for example LDM #50 loads the number 50 directly.
• Direct addressing means the operand is a memory address, so you go to that address and use the value stored there.
• Indirect addressing means the operand gives an address that contains another address. You must follow the pointer one extra step.
• Indexed addressing means add the operand address to the current value in the index register IX, then use that calculated address.

Arithmetic instructions then update the register named in the instruction. In this question, most arithmetic changes the ACC, while LDR changes IX.

Understanding the Question

You are given:

• a memory table showing what value is stored at each address
• starting values for ACC and IX
• four short assembly programs

For each program, you must work out the final contents of ACC after all instructions have been executed.

A key point is that each program is separate. You trace one program from the given starting state, then move to the next one. Also, you must pay close attention to the addressing mode used by each load instruction:

• LDM uses the number directly
• LDD uses one memory lookup
• LDI uses two memory lookups
• LDX uses address + IX

Approach

The safest approach is to execute one instruction at a time.

For each line:

1. Identify the instruction type.
2. Decide which addressing mode is being used.
3. If memory is involved, look up the required address carefully.
4. Update ACC or IX.
5. Continue until the end of that small program.

This avoids common mistakes such as treating LDI like LDD, or forgetting that LDR changes IX rather than ACC.

Step-by-Step Reasoning

Program 1

Code:

• LDM #50
• INC ACC
• SUB #1

LDM #50 is immediate addressing, so load 50 straight into ACC.

• ACC = 50

INC ACC adds 1 to ACC.

• ACC = 51

SUB #1 subtracts 1 from ACC.

• ACC = 50

Final answer for Program 1: 50

Program 2

Code:

• LDI 51
• ADD 52

LDI 51 is indirect addressing.

First lookup:

• address 51 contains 50

Second lookup:

• address 50 contains 48

So after LDI 51:

• ACC = 48

Now ADD 52 means add the contents of address 52.

• address 52 contains 49

So:

• ACC = 48 + 49 = 97

Final answer for Program 2: 97

Program 3

Code:

• LDR #2
• LDX 50
• DEC ACC

LDR #2 loads 2 into the index register.

• IX = 2

LDX 50 is indexed addressing. Calculate the effective address:

Now look up address 52:

• address 52 contains 49

So:

• ACC = 49

DEC ACC subtracts 1 from ACC.

• ACC = 48

Final answer for Program 3: 48

Program 4

Code:

• LDD 52
• SUB 54
• INC ACC

LDD 52 is direct addressing, so go straight to address 52.

• address 52 contains 49

So:

• ACC = 49

SUB 54 subtracts the contents of address 54.

• address 54 contains 6

So:

• ACC = 49 - 6 = 43

INC ACC adds 1.

• ACC = 44

Final answer for Program 4: 44

Key Takeaways

• Always identify the addressing mode before using the operand.
• LDD = one lookup, LDI = two lookups.
• LDX needs a calculated address using IX.
• Trace instructions one by one and update registers immediately.

Common Mistakes

• Treating LDI as if it were LDD. With LDI, you must follow the address stored at the first address.
• Forgetting that LDR changes IX, not ACC.
• Using the operand itself as data when direct or indexed addressing is required.
• Not recalculating the indexed address before loading from memory.
• Forgetting the final INC or DEC instruction and stopping too early.

Things to Be Careful About

• Read the # symbol carefully: it means immediate denary value, not a memory address.
• For indexed addressing, use operand + IX, not ACC + IX.
• Make sure you use the memory table exactly as given.
• Keep the programs separate; do not carry results from one program into the next unless the question says to do so.

Background Concept

Bit manipulation instructions work on the binary pattern stored in a register, one bit at a time.

The key operations here are:

• LSL: logical shift left. Every bit moves left. Bits that fall off the left end are lost, and zeros are inserted on the right.
• XOR: exclusive OR. For each bit position, the result is 1 if the two bits are different, otherwise 0.
• AND: for each bit position, the result is 1 only if both bits are 1.

Useful bit rules:

• 1 AND x = x
• 0 AND x = 0
• 1 XOR 1 = 0
• 1 XOR 0 = 1
• 0 XOR 0 = 0

A very helpful shortcut in this question is that the accumulator starts as 11111111 each time. That makes some operations easier to see immediately.

Understanding the Question

You are given:

• memory contents at addresses 100 to 104
• the accumulator initially set to 11111111
• three separate instructions to test

The question explicitly says the accumulator is reloaded with 11111111 before each instruction, so each row is independent. You do not carry the result from instruction 1 into instruction 2.

You must write the 8-bit binary contents of ACC after each instruction finishes.

Approach

For each instruction:

1. Start from 11111111.
2. If the instruction uses a memory address, fetch the binary value stored at that address.
3. Apply the bitwise operation column by column across the 8 bits.
4. Keep the answer as an 8-bit binary number.

Because all values are 8 bits wide, make sure you keep all leading zeros where needed.

Step-by-Step Reasoning

Instruction 1: LSL #2

Start with:

• 11111111

A logical left shift by 2 moves every bit two places left. The two leftmost bits are discarded, and two zeros appear on the right.

So:

• 11111111 → 11111100

Final answer: 11111100

Instruction 2: XOR 100

Start again with:

• 11111111

Address 100 contains:

• 00001101

Now XOR bit by bit:

11111111
00001101
-------- XOR
11110010

Why? In each column:

• if the bits are different, result = 1
• if the bits are the same, result = 0

Since XOR with 1 flips a bit, 11111111 XOR 00001101 gives the inverse of 00001101, which is 11110010.

Final answer: 11110010

Instruction 3: AND 103

Start again with:

• 11111111

Address 103 contains:

• 00110111

Now AND bit by bit:

11111111
00110111
-------- AND
00110111

This happens because AND with 1 leaves a bit unchanged. Since the accumulator is all 1s, the result is exactly the other value.

Final answer: 00110111

Key Takeaways

• A logical left shift moves bits left and fills the right with zeros.
• XOR with 11111111 flips every bit.
• AND with 11111111 leaves the other binary value unchanged.
• Always treat each bit position independently in bitwise operations.

Common Mistakes

• Forgetting that the accumulator is reloaded before each instruction.
• Shifting left but filling the right with ones instead of zeros.
• Losing leading zeros in answers such as 00110111.
• Confusing XOR with OR. XOR only gives 1 when bits are different.
• Using the address number itself instead of the value stored at that address.

Things to Be Careful About

• Keep all results to 8 bits.
• Read the memory table carefully: for example, XOR 100 means use the contents at address 100, not binary 100.
• For shifts, bits shifted off the end are discarded.
• For AND and XOR, line the bits up in the correct columns before combining them.

Background Concept

In a relational database, a relationship describes how records in one table connect to records in another. The most common cardinalities are one-to-one, one-to-many and many-to-many.

A one-to-many relationship means one record in the first table can be linked to many records in the second table, but each record in the second table links back to only one record in the first table. This is usually implemented by storing the primary key of the "one" table as a foreign key in the "many" table.

Understanding the Question

The table SHOW stores information about each show, and the table PERFORMANCE stores individual scheduled performances. The stem says that each show can take place on multiple dates, and the sample PERFORMANCE structure includes ShowID inside the PERFORMANCE table.

So the question is asking for the relationship between the show itself and its performances.

Approach

Use the wording in the scenario:

• one show can happen several times
• each performance is for one show

That immediately gives the relationship type.

Step-by-Step Reasoning

A row in SHOW represents a single show, for example one production title.

A row in PERFORMANCE represents one scheduled instance of a show on a particular date and time.

Because the same ShowID can appear in several PERFORMANCE rows, one show can be connected to many performances.

However, each PERFORMANCE row contains only one ShowID, so each performance belongs to just one show.

That means:

• SHOW is the one side
• PERFORMANCE is the many side

So the relationship is one-to-many from SHOW to PERFORMANCE.

Key Takeaways

• Read the wording carefully: phrases like "each X can have multiple Y" usually indicate one-to-many.
• The table containing the foreign key is usually on the many side of the relationship.

Common Mistakes

• Writing many-to-many because a show appears several times. That is wrong because each individual performance still belongs to only one show.
• Reversing the wording and saying one-to-many from PERFORMANCE to SHOW. The correct direction is from SHOW to PERFORMANCE.

Things to Be Careful About

• Cardinality direction matters. Saying "many performances to one show" describes the same link from the other direction, but the clearest exam wording here is one SHOW to many PERFORMANCE records.
• Base your answer on the data model, not just on the English scenario.

Background Concept

SQL DDL, or Data Definition Language, is used to define the structure of a database. The main command here is CREATE TABLE, which lists the field names, data types and any constraints.

Important database design terms:

• Primary key: uniquely identifies each record in a table.
• Foreign key: a field that matches the primary key of another table, creating a relationship.
• Data type: defines what kind of data can be stored, such as text, date or time.

Understanding the Question

You are asked to define the table PERFORMANCE using SQL. The stem already gives the field names:

• PerformanceID
• ShowID
• ShowDate
• StartTime

You also know from the overall design that ShowID links back to the SHOW table, so it should be a foreign key. PerformanceID should uniquely identify each performance, so it should be the primary key.

Approach

Build the table definition in this order:

1. Start with CREATE TABLE PERFORMANCE.
2. Add each field with a sensible data type.
3. Make PerformanceID the primary key.
4. Make ShowID a foreign key referencing SHOW(ShowID).

Step-by-Step Reasoning

PerformanceID stores values such as 0001, so it needs a text-based type rather than an integer if you want to preserve the leading zeros exactly as shown. CHAR(4) is suitable because the examples are four characters long.

ShowID stores codes such as MK12 and OP3. A text type is needed. VARCHAR(4) is suitable because the codes are short and may vary in length.

ShowDate stores a calendar date, so DATE is the appropriate type.

StartTime stores a time of day, so TIME is appropriate.

Then add the keys:

• PRIMARY KEY (PerformanceID) ensures each performance record is unique.
• FOREIGN KEY (ShowID) REFERENCES SHOW(ShowID) enforces that every performance must refer to a valid show already stored in SHOW.

Putting that together gives a correct CREATE TABLE statement.

Key Takeaways

• Use CREATE TABLE for database structure.
• Choose data types that match the stored values.
• Use a primary key for uniqueness.
• Use a foreign key to enforce valid links between tables.

Common Mistakes

• Using INTEGER for PerformanceID when the sample values have leading zeros. That can lose the formatting shown.
• Forgetting the primary key. Then the table has no guaranteed unique identifier.
• Forgetting the foreign key on ShowID. Then the relationship to SHOW is not enforced.
• Using an unsuitable type such as text for ShowDate or StartTime when proper date/time types are available.

Things to Be Careful About

• Exact SQL data type names can vary slightly between DBMSs, but the chosen types must still be sensible.
• The foreign key must reference the matching field in the parent table: SHOW(ShowID).
• Keep SQL keywords in upper case and field names exactly as given in the question.

Background Concept

When SQL needs to summarise data, it uses aggregate functions such as COUNT(), SUM() and AVG(). If you want one result per category, you combine the aggregate with GROUP BY.

A join is needed when the information you want is spread across more than one table. Here:

• PERFORMANCE tells you how many scheduled performances there are.
• SHOW gives you the show name, stored as Title.

Understanding the Question

The question wants the number of times each show is scheduled. It also says the result must include the show name, not just the show code, and a suitable field name for the count.

So you must:

• link SHOW and PERFORMANCE using ShowID
• count how many performance records belong to each show
• display the title of the show
• give the count column a meaningful alias

Approach

The correct SQL pattern is:

1. SELECT the show title.
2. Use COUNT(...) to count performances.
3. JOIN the tables on ShowID.
4. GROUP BY the title so one row is returned per show.
5. Use AS to name the calculated field.

Step-by-Step Reasoning

SHOW.Title is selected because the question asks for the show name.

COUNT(PERFORMANCE.PerformanceID) counts how many performance rows exist for each show. COUNT(*) would also work in many cases, but counting the performance identifier makes the intention very clear.

The INNER JOIN connects each performance row to its matching show row:

• SHOW.ShowID = PERFORMANCE.ShowID

Without the join, you could count performances, but you would not be able to display the show title from the SHOW table.

GROUP BY SHOW.Title tells SQL to gather together all rows with the same title and produce one summary row per title.

AS NumberScheduled gives a suitable heading to the calculated result column, as required by the question.

The result is a table like:

• title of show
• number of scheduled performances for that show

Key Takeaways

• Use JOIN when required data is stored in different tables.
• Use COUNT() to count related rows.
• Use GROUP BY when you want one summary row per item.
• Use AS to provide a clear output field name.

Common Mistakes

• Counting by ShowID without joining to SHOW, which misses the required show name.
• Forgetting GROUP BY, which would make the query invalid or return only one total count.
• Grouping by the wrong field.
• Omitting the alias for the count field, even though the question asks for a suitable field name.

Things to Be Careful About

• The join condition must use the matching key field: ShowID.
• Every non-aggregated selected field must be grouped appropriately.
• An INNER JOIN returns only shows that actually have performances. That matches the wording about shows that are scheduled.

Background Concept

A good relational database design stores each type of thing in its own table. In this question, the existing tables already represent:

• a show
• a seat
• a performance

But the scenario also includes customers making bookings, so more entities are needed.

A booking is usually treated as its own entity because it is not just a customer and not just a seat. It represents a transaction: a particular customer booking particular seats for a particular performance.

A junction table is used to resolve a many-to-many relationship. For example:

• one booking can contain many seats
• one seat can be involved in many bookings across different performances

That many-to-many relationship cannot be stored directly in a single field, so a separate linking table is needed.

Understanding the Question

The stem already gives three tables:

• SHOW
• SEAT
• PERFORMANCE

The new information says:

• customers give first name, last name and email address
• one booking can include multiple seats

So the question is asking you to identify what extra tables are needed to store customers and bookings properly, and then explain how those tables connect to the existing tables.

Approach

Think about the real-world objects and events:

1. A customer exists independently, so create a CUSTOMER table.
2. A booking is an event made by one customer for one performance, so create a BOOKING table.
3. A booking can contain multiple seats, so create a junction table between BOOKING and SEAT.

Then describe the links using primary keys and foreign keys.

Step-by-Step Reasoning

First, add a CUSTOMER table.

This stores the customer's details once, instead of repeating them every time they book:

• CustomerID
• FirstName
• LastName
• EmailAddress

CustomerID should be the primary key.

Second, add a BOOKING table.

A booking needs its own identifier because one customer may make several bookings, and each booking should be recorded separately. A sensible structure is:

• BookingID
• CustomerID
• PerformanceID

BookingID is the primary key.

CustomerID is a foreign key linking back to CUSTOMER. This creates a one-to-many relationship:

• one customer can make many bookings
• each booking belongs to one customer

PerformanceID is a foreign key linking to PERFORMANCE. This gives:

• one performance can have many bookings
• each booking is for one performance

Third, deal with the fact that one booking can include multiple seats.

If you tried to store several seat IDs in one field, that would break good relational design. Instead, add a junction table such as:

• BOOKINGSEAT(BookingID, SeatID)

This table records one seat per row for a given booking.

So if a booking includes three seats, there will be three rows in BOOKINGSEAT with the same BookingID and different SeatID values.

This creates the links:

• BookingID in BOOKINGSEAT is a foreign key to BOOKING
• SeatID in BOOKINGSEAT is a foreign key to SEAT

That resolves the many-to-many relationship:

• one booking can have many seats
• one seat can appear in many booking-seat records over time

Because the BOOKING table already stores PerformanceID, each seat booking is tied to a specific performance through its booking.

Key Takeaways

• Separate entities such as customers, bookings and seats into different tables.
• Use a booking table to model the act of making a booking.
• Use a junction table whenever one record can be linked to many records and vice versa.
• Use primary keys for uniqueness and foreign keys for relationships.

Common Mistakes

• Adding only a CUSTOMER table and forgetting that bookings also need to be stored.
• Linking customers directly to seats. That misses the important fact that a booking is for a particular performance.
• Storing multiple seat IDs in one field. That is poor relational design and makes querying difficult.
• Missing the junction table, even though one booking can contain multiple seats.

Things to Be Careful About

• A seat such as row E seat 2 is a physical seat, so SEAT stores the seat itself, not whether it is booked on a particular date.
• The booking must be tied to a performance, otherwise the system cannot tell which performance the seats were booked for.
• In a full implementation, you would usually also enforce a rule to prevent the same seat being booked twice for the same performance.
• Keep the role of each table clear: CUSTOMER stores people, BOOKING stores booking transactions, and BOOKINGSEAT stores which seats are included in each booking.

Background Concept

A star topology is a network layout in which every device has its own separate connection to a central device, usually a switch. Devices are not connected directly to each other by one shared cable.

This means data sent by one device first travels to the centre of the star, and then the central device handles onward transmission.

Understanding the Question

The question says part of the wired LAN uses a star topology and asks how packets are transmitted between two devices.

So the key point is the route the packet takes. In a star, the packet does not travel straight through a single shared backbone cable as it would in a bus topology. It goes through the central connecting device.

Approach

To answer this, describe the packet path in two stages:

1. from the source device to the central device
2. from the central device to the destination device

That two-step path is the main feature being tested.

Step-by-Step Reasoning

Suppose device A wants to send a packet to device B.

• Device A is connected by its own cable to the central device.
• The packet is sent from A to that central device.
• The central device examines where the packet should go.
• It then forwards the packet to device B through B's connection.

So the communication path is:

source device -> central device -> destination device

That is why failure of the central device can affect the whole star network, even though failure of one outer cable usually affects only one device.

Key Takeaways

• In a star topology, devices communicate through the centre.
• Each device has its own link to the central device.
• Packet flow is not device-to-device directly across one shared cable.

Common Mistakes

• Saying devices are connected directly to each other. That describes a mesh-style idea, not a star.
• Describing a shared backbone cable. That belongs to bus topology.
• Naming the central device only, without explaining that the packet goes to it first and is then forwarded on.

Things to Be Careful About

• Use the wording of the topology correctly: the packet is sent via the central device.
• If you mention a switch, that is fine, but the essential mark is the two-stage path.
• Do not confuse the physical layout of the cables with the logical route of the packet.

Background Concept

An IP address identifies a device on a network.

A static IP address stays the same rather than being changed automatically.

A private IP address is one reserved for internal networks such as home or office LANs. Private addresses are not routed across the public internet.

When the two ideas are combined, a static private IP address is a fixed internal network address.

Understanding the Question

The question says the office devices have static private IP addresses and asks what that means.

So the answer must include both parts of the phrase:

• static = fixed / does not change
• private = for internal network use / not public internet addressing

Approach

Break the term into its two components and define each briefly in one sentence.

Step-by-Step Reasoning

Start with static:

• the address remains the same
• it is not dynamically changed each time the device connects

Then add private:

• it is used inside the organisation's LAN
• it is not a public internet address

Putting those together gives the full meaning: a fixed address intended for internal network use only.

Key Takeaways

• Static refers to whether the address changes.
• Private refers to where the address is valid and routable.
• A complete definition of a compound term should cover both words.

Common Mistakes

• Defining only static and forgetting private.
• Defining only private and forgetting that the address stays the same.
• Saying "secret address" for private. Private means internal-use addressing, not hidden or encrypted.

Things to Be Careful About

• Include both ideas for full accuracy.
• Do not say a private address is unique across the whole internet; it is only meaningful within the private network context.
• Keep the definition short and precise, since this is a 1-mark terminology question.

Background Concept

A navigation system in a robot depends on sensors. A sensor is an input device that detects a physical property and sends data to the control system. In a moving robot, sensors are used to detect things such as distance, direction, position, speed, or nearby obstacles. The controller then uses that information to decide how the robot should move.

In Cambridge questions, you are usually rewarded for giving a sensible sensor and a clear purpose linked to the scenario. The purpose must match navigation, not some unrelated use.

Understanding the Question

The robot is moving through a restaurant to reach a customer's table. The question asks for two sensors that could be built into the robot and the purpose of each one in navigation.

So the answer needs two complete pairings:

• the name of a sensor
• what that sensor helps the robot do while travelling to the table

Because the setting is a restaurant, useful navigation tasks include avoiding chairs or people, measuring distance, and keeping the robot facing the correct way.

Approach

Think about what information a robot needs in order to move safely and accurately:

• it needs to know whether something is in front of it
• it needs to know which way it is facing or turning

So a good strategy is to choose one sensor for obstacle detection and one sensor for direction/orientation. Then state each purpose precisely.

Step-by-Step Reasoning

An ultrasonic sensor is a strong choice because it is commonly used for proximity sensing. It sends out sound waves and measures the time taken for the echo to return. From that, the robot can estimate distance to an object. In a restaurant, that allows it to detect tables, chairs, walls, or people and avoid collisions.

A gyroscope is also a valid choice because it measures orientation or rate of rotation. As the robot turns through the restaurant, the gyroscope helps it stay on the correct path and avoid drifting away from the intended direction.

Other answers could also be valid if the purpose is sensible, for example:

• infrared sensor for obstacle or line detection
• camera for recognising routes or objects
• wheel rotation sensor for measuring movement distance
• accelerometer for movement changes

The key is that the purpose must be clearly tied to navigation.

Key Takeaways

• Sensors provide input data to a robot's control system.
• For navigation, good answers usually involve distance sensing and direction sensing.
• Always pair the sensor with a specific purpose, not just the sensor name.

Common Mistakes

• Naming a sensor without giving its purpose.
• Giving a device that is not really a sensor, such as a motor or screen.
• Stating a vague purpose such as "helps the robot move" instead of saying what is detected.
• Giving a purpose unrelated to navigation, such as measuring temperature.

Things to Be Careful About

• Make sure each row has both parts: sensor and purpose.
• The purpose must be specific to the restaurant navigation scenario.
• If you use a less common sensor, make sure the explanation is still believable and accurate.

Background Concept

Artificial Intelligence is used when a computer system performs tasks that normally require human intelligence. In communication with people, two important AI techniques are speech recognition and natural language processing.

Speech recognition converts spoken sounds into words or text. Natural language processing then works out the meaning of those words, such as a request, question, or instruction. A system may also use speech synthesis to produce a spoken reply.

Understanding the Question

Here, customers speak to the restaurant robot to order food and drinks. The question asks how AI is used in that communication process.

So this is not asking about navigation or movement. It is specifically asking how the robot understands human speech and responds appropriately.

Approach

A good explanation follows the communication chain:

1. capture the spoken input
2. recognise the speech
3. interpret the meaning
4. produce a suitable response

That sequence matches the way AI would support a spoken ordering system.

Step-by-Step Reasoning

First, the customer speaks to the robot. The robot must receive that sound through a microphone and convert it into digital data.

Next, AI-based speech recognition is used to match the sound patterns to words. This is the stage where the robot decides what was said.

After that, natural language processing is used to interpret the meaning of the sentence. For example, it must distinguish between items being ordered and other conversation. It may identify key information such as the food item, the drink item, quantity, or special requests.

Finally, the robot responds. It might confirm the order, ask the customer to repeat something unclear, or request missing details. If it speaks back, speech synthesis can convert the robot's response into audio.

These are the main AI ideas the examiner is looking for: understanding spoken language and producing an intelligent reply.

Key Takeaways

• Speech recognition identifies the words that were spoken.
• Natural language processing works out what the customer means.
• AI can then choose and generate a suitable response.

Common Mistakes

• Saying only that "AI lets the robot talk" without explaining how.
• Confusing AI with simple input devices only.
• Describing navigation sensors instead of spoken communication.
• Forgetting the interpretation stage and mentioning only audio capture.

Things to Be Careful About

• Mention both understanding the input and responding to it.
• Use terms like speech recognition and natural language processing accurately.
• Keep the answer focused on the customer ordering scenario, not on general AI theory.

Background Concept

A control system is a system that automatically manages a process. It usually contains:

• sensors to measure what is happening
• a controller to make decisions
• actuators to carry out actions

Feedback means that the system does not just send out instructions once. Instead, it measures the actual result and sends that information back to the controller. The controller can then decide whether a correction is needed.

Understanding the Question

The robot's navigation system is being treated as a control system. The question asks specifically how feedback is used.

So the answer must explain the feedback loop, not just define a control system. The important idea is that the system checks the current state and then adjusts its behaviour.

Approach

Use the standard control-system sequence:

1. sensor measures current condition
2. reading is sent back to controller
3. controller compares actual value with desired value
4. controller changes actuator output if needed

That gives a complete description of feedback.

Step-by-Step Reasoning

Suppose the robot is meant to move in a straight line. A sensor may detect that it is too close to an obstacle or turning slightly off course.

That sensor reading is fed back to the controller. The controller compares the actual situation with the intended situation, such as the target direction or safe distance.

If there is a difference, often called an error, the controller changes the output to the actuators. For a robot, that may mean slowing one wheel, turning, or stopping.

So feedback is the process that allows the system to keep correcting itself while it is operating.

Key Takeaways

• Feedback is information about the actual output of the system.
• The controller uses feedback to compare actual and desired conditions.
• Corrections are made through the actuators.

Common Mistakes

• Saying only that sensors are used, without mentioning the controller comparison.
• Confusing feedback with output.
• Describing manual control by a human instead of automatic correction by the system.

Things to Be Careful About

• Include both the sensor reading and the corrective action.
• Words like compare, adjust, or correct are important in this type of answer.
• Do not describe feedback as a one-time input; it is part of a continuous loop.

Background Concept

A touchscreen is both an output device and an input device. It shows information on the screen and also detects where the user touches it.

Different touchscreen technologies exist, but the basic idea is the same: the screen senses the position of the touch and sends those coordinates to the computer system. The system then decides which on-screen item has been selected.

In many syllabus answers, a generic explanation is accepted as long as it clearly explains detection of touch, finding the position, and using that position as input.

Understanding the Question

The robot has a touchscreen that the customer uses to make a payment. The question asks for the principal operation of a touchscreen.

That means you should describe the main process of how the device detects a touch and turns it into a usable input. You do not need to discuss payment processing itself.

Approach

A strong answer follows this order:

1. describe the screen layers or sensing surface
2. explain what happens when the user touches the screen
3. explain how the position is calculated
4. explain how that becomes a selected command

This structure covers the full operation from physical touch to computer input.

Step-by-Step Reasoning

The screen contains transparent sensing layers placed over the display. These layers are designed so that the system can detect a touch at a particular point.

When a user touches the screen, the touch causes a change. In a resistive screen, layers may be pushed together. In a capacitive screen, the electrical field or capacitance changes. The exact technology can vary, but the key point is that the system can detect the touch location.

The touchscreen controller measures this change and works out the X and Y coordinates of the point touched.

Those coordinates are sent to the processor. The software then checks which button, icon, or menu option is displayed at that position. It interprets the touch as a selection and carries out the related action.

For a payment screen, that might mean pressing a number, selecting a payment option, or confirming the transaction.

Key Takeaways

• A touchscreen senses where the user touches the screen.
• The position is converted into coordinates.
• The software links those coordinates to a screen object and performs the input action.

Common Mistakes

• Saying only that the user touches the screen and it works, with no mechanism.
• Describing a mouse or keyboard instead of a touchscreen.
• Forgetting to mention that the coordinates are calculated.
• Talking about how the image is displayed rather than how input is detected.

Things to Be Careful About

• Do not get stuck on one specific touchscreen type unless you can describe it accurately.
• Make sure your answer includes both detection and interpretation.
• The question asks about operation, so a process description is better than a definition only.