Background Concept

In binary floating-point representation, a number is stored as two parts:

• the mantissa (also called significand), which stores the significant bits of the number
• the exponent, which stores how far the binary point has been moved

In this question, both mantissa and exponent use two's complement.

For a normalised two's complement mantissa:

• a positive number must begin 01
• a negative number must begin 10

That rule means the first two bits must be different. For a positive value, we shift the binary point until the first 1 is immediately after the sign bit 0.

The exponent records how many places the binary point was moved:

• shift left to normalise → positive exponent
• shift right to normalise → negative exponent

The exponent itself must then be written in the allowed number of bits, here 4 bits, using two's complement.

Understanding the Question

You are given a very small positive binary fraction:

0.00000001110101101

You must write it in this floating-point system with:

• a 12-bit mantissa
• a 4-bit exponent
• normalised form

So you need to:

1. move the binary point until the mantissa is normalised
2. count how many places you moved it
3. write the mantissa in 12 bits
4. write the exponent in 4-bit two's complement

Approach

Because the number is positive, the normalised mantissa must start 01....

So the method is:

1. find the first 1 in the fraction
2. move the binary point so that this 1 becomes the first fractional bit after the sign bit
3. count the shift
4. pad or trim the mantissa to 12 bits total
5. convert the exponent into 4-bit two's complement

Step-by-Step Reasoning

Start with:

0.00000001110101101

The first 1 appears after six 0s. To make the number normalised, move the binary point 7 places to the right so the number becomes:

0.1110101101

This is normalised because it starts with 0.1, so the first two bits are different: 01.

Now write the mantissa using 12 bits total. Since the sign bit is included, we need:

• 0 as the sign bit
• 11101011010 as the next 11 bits

So the mantissa is:

011101011010

Because the binary point was moved 7 places to the right, the exponent is -7.

Now convert -7 to 4-bit two's complement:

• +7 in 4 bits is 0111
• invert → 1000
• add 1 → 1001

So the exponent is:

1001

Final representation:

• Mantissa: 011101011010
• Exponent: 1001

Key Takeaways

• In two's complement floating-point, a normalised positive mantissa starts 01.
• The exponent tells you how many places the binary point moved.
• Shifting the binary point right gives a negative exponent.
• Always check the mantissa length carefully, including the sign bit.

Common Mistakes

• Using an unnormalised mantissa: for example leaving leading zeros after the sign bit.
• Wrong sign on the exponent: moving the binary point right means the exponent is negative here.
• Forgetting the sign bit in the mantissa length: 12 bits means all 12 stored bits, not 12 bits after the point.
• Writing -7 in ordinary binary instead of two's complement: the exponent must be 1001, not 0111.

Things to Be Careful About

• Count the binary-point shifts exactly; one extra or one fewer changes the exponent.
• Make sure the mantissa has exactly 12 bits.
• The exponent has exactly 4 bits, so you must use 4-bit two's complement, not 8-bit or ordinary signed notation.
• For positive mantissas in this syllabus, the first two bits in normalised form should be 01.

Background Concept

To store a denary value in binary floating-point form, you normally do three jobs:

1. convert the denary number to binary
2. normalise it so the mantissa has the correct form
3. store mantissa and exponent in the required bit lengths

Here the system uses:

• 12 bits for the mantissa
• 4 bits for the exponent
• two's complement for both

A normalised two's complement mantissa must have its first two bits different:

• positive: 01...
• negative: 10...

For negative values, a common method is:

• first find the normalised positive mantissa
• then convert that 12-bit mantissa into two's complement to get the negative mantissa

The exponent just stores the power of 2 needed after normalisation.

Understanding the Question

You must represent -76.1875 in this floating-point system and show working.

That means you are expected to show:

• the binary conversion of 76.1875
• the normalised form
• the negative mantissa in two's complement
• the exponent in 4-bit two's complement

Because the number is negative, you must be especially careful not to leave the mantissa as a positive one.

Approach

A reliable approach is:

1. ignore the minus sign for a moment and convert 76.1875 to binary
2. normalise the positive binary value
3. write the 12-bit positive mantissa
4. convert that mantissa to two's complement to make it negative
5. convert the exponent to 4-bit two's complement

This works well because the normalisation step is easier to see with the positive version first.

Step-by-Step Reasoning

First convert the integer part:

76 = 64 + 8 + 4

So:

76 = 1001100

Now convert the fractional part 0.1875:

• 0.1875 = 0.125 + 0.0625
• 0.125 = 2^-3
• 0.0625 = 2^-4

So:

0.1875 = 0.0011

Combine them:

76.1875 = 1001100.0011

Now normalise the positive value. Move the binary point 7 places left:

1001100.0011 = 0.10011000011 × 2^7

This is normalised because the mantissa begins 01.

Now write the positive mantissa in 12 bits total:

010011000011

That is:

• sign bit 0
• followed by 10011000011

But the original number is negative, so the mantissa must be the two's complement negative version of this 12-bit pattern.

Take two's complement of 010011000011:

• invert bits: 101100111100
• add 1: 101100111101

So the negative mantissa is:

101100111101

Now write the exponent. The shift was 7 places, so the exponent is +7.

In 4-bit two's complement, +7 is simply:

0111

So the final representation is:

• Mantissa: 101100111101
• Exponent: 0111

This is valid because the mantissa starts 10, which is the correct normalised form for a negative two's complement mantissa.

Key Takeaways

• Convert the denary number to binary before worrying about normalisation.
• For mixed numbers, convert the integer part and fractional part separately, then combine them.
• In two's complement floating-point, a negative normalised mantissa starts 10.
• A good method for a negative value is to normalise the positive version first, then take the two's complement of the mantissa.

Common Mistakes

• Using sign-and-magnitude instead of two's complement: simply putting a 1 at the front is not enough.
• Normalising incorrectly: 1001100.0011 is not already normalised in this format.
• Using the wrong exponent: after moving the binary point left by 7 places, the exponent is +7, not -7.
• Forgetting the fractional binary conversion: 0.1875 must become 0.0011.
• Writing a positive mantissa for a negative number: the final mantissa must be the two's complement negative pattern.

Things to Be Careful About

• Keep the mantissa to exactly 12 bits.
• Do not forget that the sign bit is part of the mantissa length.
• Use 4-bit two's complement for the exponent, not a larger size.
• Check the normalisation rule at the end: positive should begin 01, negative should begin 10.
• In questions like this, if the binary value fits exactly, do not invent extra rounding.

Background Concept

A protocol is an agreed set of rules used when devices communicate over a network. These rules cover things such as how data is formatted, when it is sent, how errors are checked, and what should happen if something goes wrong.

Computer systems are often made by different manufacturers and may use different hardware or software internally. Communication only works reliably if both ends agree on the same standards. Protocols are what make that possible.

In networking, protocols are often organised into layers. Each layer handles a particular part of the communication process, for example application services, addressing, routing, or transmission.

Understanding the Question

This question asks why protocols are essential, not just what a protocol is. So the answer needs to explain why communication would fail or be unreliable without them.

For 2 marks, the likely marking points are:

• protocols are a set of agreed rules or standards
• those rules allow different systems to exchange and understand data correctly

Approach

A good approach is:

1. State that protocols define the rules for communication.
2. Explain the effect of having those rules: both devices can send, receive and interpret the data properly.

That is enough for a focused 2-mark response.

Step-by-Step Reasoning

The first idea is that communication needs structure. If one computer sends data in one format and another expects a different format, the message may be unreadable or misinterpreted.

So protocols are essential because they define things like:

• data format
• timing
• error checking
• how messages begin and end

The second idea is interoperability. Different computer systems can still communicate if they all use the same protocol. That means the receiver knows how to decode the message and what actions to take.

Putting those together gives the full explanation:

• protocols provide agreed rules
• agreed rules allow accurate and reliable communication between systems

Key Takeaways

• A protocol is a standard set of communication rules.
• Protocols are necessary so devices can exchange data in a form both sides understand.
• Without protocols, communication between systems would be unreliable or impossible.

Common Mistakes

• Saying only "protocols are used on networks". That names the topic but does not explain why they are essential.
• Giving examples such as HTTP or SMTP without explaining the general purpose of protocols.
• Talking only about security. Some protocols include security, but the core idea here is agreed communication rules.

Things to Be Careful About

• Use the word "rules" or "standards" clearly.
• Make sure you mention that both systems must follow the same rules.
• Focus on communication and interpretation of data, not unrelated network hardware details.

Background Concept

Email uses application-layer protocols. Different protocols are designed for different tasks in the email process.

The main ones in this syllabus are:

• SMTP: Simple Mail Transfer Protocol, used for sending email
• POP3: Post Office Protocol version 3, used for retrieving email, often by downloading it from the server
• IMAP: Internet Message Access Protocol, used for accessing and managing email on the server

The question already gives POP3, so it wants two other protocols involved in sending or receiving email.

Understanding the Question

You must identify and describe two protocols other than POP3 that are used in email communication.

That means each protocol needs:

• its name
• what it is used for

The best pair is:

• SMTP for sending
• IMAP for receiving/accessing

This gives clear coverage of both directions of email communication.

Approach

Choose two valid protocols from the email set in the syllabus. Then give a precise description of each one.

A strong answer avoids vague descriptions such as "used for email" and instead says what part of the process the protocol handles.

Step-by-Step Reasoning

First, think about the email process.

When an email is sent:

• the user's device sends the message to a mail server
• mail servers may then pass it on to other mail servers
• this is handled by SMTP

So SMTP should be described as a sending protocol.

When an email is received or checked:

• the user needs to access messages stored on the mail server
• with IMAP, messages stay on the server and can be synchronised across multiple devices

So IMAP should be described as a receiving/access protocol.

A concise full-mark pair is therefore:

• SMTP: used for sending email from client to server and server to server
• IMAP: used for receiving/accessing email while keeping messages on the server

Key Takeaways

• SMTP is for sending mail.
• POP3 and IMAP are for receiving/accessing mail.
• IMAP is especially associated with leaving messages on the server and synchronising across devices.

Common Mistakes

• Giving POP3 as one of the answers even though the question says "two other" protocols.
• Naming non-email protocols such as HTTP or FTP.
• Saying IMAP "sends" email. It is used for accessing received mail.
• Writing only the protocol name with no description.

Things to Be Careful About

• Make sure each protocol is actually related to email.
• Be precise with the role: SMTP sends; IMAP retrieves/accesses.
• For IMAP, mentioning that messages remain on the server is a strong descriptive point.

Background Concept

In packet switching, a message is broken into smaller units called packets before being sent across a network. Each packet can travel independently, sometimes even by different routes.

A packet normally contains:

• the data payload
• source and destination addresses
• sequence information
• error-checking information such as a checksum

At the destination, the packets are collected, checked and reassembled into the original message.

Understanding the Question

The question is specifically asking for two ways packet switching ensures a complete message is received. So the answer should focus on reliability features, not just on speed or efficient use of the network.

The strongest two points are:

1. sequence numbers or packet numbers for reordering and spotting missing packets
2. error checking with retransmission of missing/corrupt packets

Approach

Think about what could go wrong when packets travel separately:

• they may arrive out of order
• some may be lost
• some may be corrupted

Then identify which packet-switching features solve those problems.

Step-by-Step Reasoning

Because packets travel independently, the destination cannot assume they will arrive in the same order they were sent.

So packets include a sequence number or similar control field. This lets the receiving system:

• place packets back into the correct order
• notice if a packet in the sequence is missing

That is one way a complete message can be ensured.

Next, packets may be damaged during transmission or may never arrive.

So packets also use error checking, for example a checksum. The receiving system can test whether the packet is correct. If a packet is missing or fails the check, it can be requested again or retransmitted.

That is the second reliability feature.

Together, these features mean the receiver can:

• detect missing parts
• reject damaged parts
• obtain replacement packets
• rebuild the full original message correctly

Key Takeaways

• Packet switching breaks messages into packets that travel independently.
• Sequence numbers help with ordering and detecting missing packets.
• Error checking and retransmission help ensure the final message is complete and correct.

Common Mistakes

• Saying only that packets can take different routes. That explains flexibility, but not directly how a complete message is ensured.
• Describing destination addresses only. Addresses help delivery, but the question is about receiving the complete message.
• Forgetting to mention retransmission after error detection.
• Giving two points that are really the same idea stated twice.

Things to Be Careful About

• Focus on completeness and reliability, not just efficiency.
• Use clear wording such as "sequence number", "missing packet", "error checking", and "retransmission".
• If mentioning headers, explain what information in the header actually helps ensure completeness.

Background Concept

A scheduling routine is the rule the operating system uses to decide which process gets the CPU next. In a multitasking system, several processes may be ready to run at the same time, so the scheduler must choose an order.

Common scheduling routines include:

• First come, first served (FCFS): processes are run in the order they arrive.
• Round robin: each process gets a small fixed time slice, then the CPU moves to the next process.
• Shortest job first: the process needing the least CPU time is chosen first.
• Priority scheduling: the process with the highest priority is chosen first.

For an "identify" question, the examiner usually wants just valid names, not descriptions.

Understanding the Question

This part asks for two scheduling routines used by an operating system. Since it says identify, you only need to name them correctly. No explanation is required unless the question explicitly says describe or explain.

Approach

The best approach is to recall standard CPU scheduling methods from the syllabus and give any two accepted examples. Choose the most common ones to avoid ambiguity.

Step-by-Step Reasoning

Two well-known scheduling routines are:

1. First come, first served (FCFS)

   • Processes are dealt with in arrival order.
   • This is a valid scheduling routine.

2. Round robin

   • Each process gets a time slice in turn.
   • This is also a valid scheduling routine.

Since the question only asks to identify two, listing these two names is enough for full marks.

Key Takeaways

• A scheduling routine is a method the OS uses to choose the next process for the CPU.
• For identify questions, correct names are enough.
• Learn the standard scheduling methods by name.

Common Mistakes

• Describing instead of naming: this wastes time when only identification is needed.
• Giving non-scheduling OS functions: for example, memory management or file handling are OS functions, but they are not scheduling routines.
• Using vague terms: writing "time sharing" may be too imprecise unless clearly accepted; specific routine names are safer.

Things to Be Careful About

• Make sure each answer is actually a scheduling routine.
• Give two different routines, not the same idea written twice.
• Use standard terminology such as FCFS and round robin.

Background Concept

One important role of an operating system is to hide hardware complexity. This is called abstraction. The user should be able to use the computer without needing to know exactly how the processor, memory, storage devices, or peripherals work at a low level.

The OS sits between the user/application software and the hardware. It provides simpler, standard ways to interact with the system.

Two major ways it does this are:

• User interface: gives the user a simple way to issue commands.
• Device drivers: allow software to communicate with hardware without the user needing device-specific knowledge.

Understanding the Question

This part asks for two ways that hardware complexity is hidden from the user, and it says describe, so naming a feature is not enough. Each point needs development: what the OS feature is and how it hides the hardware detail.

The focus is not just "what the OS does" in general, but specifically how the OS prevents the user from having to deal directly with hardware-level details.

Approach

Choose two clear examples of abstraction provided by the operating system, then explain the hardware detail each one hides.

A strong pair of examples is:

1. GUI / user interface
2. Device drivers

These are both standard syllabus examples and directly answer the question.

Step-by-Step Reasoning

1. User interface / GUI

A computer's hardware works through electrical signals, machine instructions, memory addresses, and device control operations. An ordinary user cannot realistically work at that level.

The operating system hides this complexity by providing a user interface, such as a GUI:

• the user clicks icons, selects menus, and types simple commands
• the OS translates these actions into the necessary low-level operations
• the user does not need to know how the processor executes instructions or how devices are controlled internally

So the GUI hides the underlying hardware processes behind an easier visual interface.

2. Device drivers

Different printers, keyboards, storage devices, and other peripherals all work in different ways. Their control signals and commands are hardware-specific.

The operating system uses device drivers to hide this complexity:

• a driver is software that knows how to communicate with a particular device
• the OS or application sends a general request, such as print or read
• the driver translates that request into the exact low-level instructions needed by that hardware

This means the user does not need to know anything about the internal working of the device.

These two examples both show the OS acting as a layer between the user and the hardware.

Key Takeaways

• The OS provides abstraction, hiding low-level hardware detail.
• A GUI hides machine-level and hardware-level operations behind icons, menus, and windows.
• Device drivers hide the specific control methods of individual peripherals.
• When a question says describe, explain both the feature and how it hides complexity.

Common Mistakes

• Only naming the feature: for example, writing just "GUI" or "drivers" without saying how they hide hardware complexity.
• Giving general OS tasks without linking to abstraction: for example, saying "memory management" without explaining what complexity is hidden from the user.
• Describing application software instead of the OS: the question is about the operating system's role.
• Talking about speed or security: these may be true benefits, but they do not directly answer how hardware complexity is hidden.

Things to Be Careful About

• Make sure each point is a way hardware complexity is hidden, not just any OS function.
• Include the idea that the user does not need to know low-level details.
• Use precise wording such as user interface/GUI and device drivers.
• Since the question asks for two ways, give two separate developed points rather than repeating the same idea in different words.

Background Concept

A digital certificate is an electronic document used to link a public key to a particular person, organisation or server. It is normally issued by a trusted Certificate Authority (CA). The purpose of the certificate is to let other users trust that a public key really belongs to the claimed owner.

Common contents of a digital certificate include:

• the public key
• the name or identity of the owner
• the name of the issuing Certificate Authority
• an expiry date or validity period
• a serial number
• the CA's digital signature

The exact list can vary, so in questions like this there are usually several acceptable answers.

Understanding the Question

This part asks for two items that are commonly found in a digital certificate. It does not ask for a full definition of a certificate or for an explanation of how it works. So the best approach is to give two clear examples of certificate contents.

Approach

Recall the main job of a certificate: it binds an identity to a public key. That immediately suggests two very safe answers:

• the owner's public key
• the owner's identity or name

These are among the most central fields and are very likely to be credited.

Step-by-Step Reasoning

A certificate must contain the public key, because that is the key other people need in order to encrypt to the owner or verify the owner's digital signature.

A certificate must also contain the identity of the owner, because without that, the public key would not be linked to any named person or organisation.

So two valid items are:

• the owner's public key
• the owner's identity/name

Other answers could also be valid in many mark schemes, such as the issuing CA, expiry date, serial number or CA signature.

Key Takeaways

• A digital certificate links a public key to an identity.
• The most important certificate fields are usually the public key and owner identity.
• Several other administrative and security fields may also appear.

Common Mistakes

• Giving items that are not normally certificate contents, such as a private key. A private key is never placed in a digital certificate.
• Writing vague answers like "security details" without naming an actual field.
• Describing what a certificate does instead of naming what it contains.

Things to Be Careful About

• The question says "Identify two", so short item names are enough.
• Do not include the private key.
• Choose standard fields that are definitely part of a certificate, such as the public key, owner name, CA name or expiry date.

Background Concept

A digital signature is used to prove authenticity and integrity. The sender creates the signature using their private key, and the receiver verifies it using the sender's public key.

That creates an important problem: how does the receiver know that the public key being used really belongs to the claimed sender? If an attacker substituted a different public key, the receiver could be misled.

This is where a digital certificate is used. A digital certificate contains the owner's public key and identity, and it is digitally signed by a trusted Certificate Authority (CA). The CA acts as a trusted third party that confirms the link between that identity and that public key.

Understanding the Question

This part asks why a digital certificate is required to validate a digital signature. The key phrase is "validate a digital signature". Validation is not just the mechanical act of checking the mathematics of the signature; it also means being confident that the public key used for checking is the correct, trusted one.

So the explanation needs to connect three ideas:

• a digital signature is verified with a public key
• the certificate supplies and identifies that public key
• the CA's signature makes the public key trustworthy

Approach

Start from the verification process. A signature must be checked with the sender's public key. Then explain the trust issue: without a certificate, anyone could claim a public key belongs to the sender. Finally explain how the certificate solves that by being issued and signed by a trusted CA.

Step-by-Step Reasoning

To validate a digital signature, the receiver uses the sender's public key.

However, simply having a public key is not enough. The receiver must know that:

• it really belongs to the claimed sender
• it has not been changed or replaced

A digital certificate provides the sender's public key together with identity information about the owner.

The certificate is itself digitally signed by a trusted Certificate Authority. Because the CA is trusted, the receiver can check the certificate and trust that the public key inside it is genuine.

So the certificate is required because it proves the connection between the sender and the public key used to verify the signature. Without that, the signature check could be performed using a false public key and would not be trustworthy.

Key Takeaways

• Digital signatures are verified using a public key.
• A certificate links that public key to a named owner.
• Trust comes from the Certificate Authority's signature on the certificate.
• Signature validation depends not only on the algorithm, but also on trusting the key.

Common Mistakes

• Saying the certificate contains the private key. It does not; only the public key is shared.
• Saying the certificate creates the digital signature. The sender's private key creates the signature; the certificate only helps others trust the corresponding public key.
• Explaining encryption instead of signature verification. This question is about proving authenticity, not keeping data secret.
• Missing the role of the Certificate Authority. Without mentioning trust in the public key, the explanation is incomplete.

Things to Be Careful About

• Use the correct key roles: private key signs, public key verifies.
• Make it clear that the certificate identifies who owns the public key.
• The strongest explanation includes the idea of trust or authenticity provided by the CA.
• Do not confuse "validation" of the signature with "validation" of user input or data checking; here it means confirming the signature is genuine.

Background Concept

A truth table shows the output of a logic circuit for every possible combination of inputs. With three inputs, there are $2^3 = 8$ possible rows.

To complete a truth table for a circuit, the safest method is to work from left to right through the circuit:

• find the outputs of any NOT gates first
• use those values to find the outputs of the OR gates
• use those results at the final gate

In this circuit, the labelled intermediate values are important:

• $P$ is the output of the NOT gate on $A$
• $Q$ is the output of the NOT gate on $C$
• $R$ is the output of the upper OR gate
• $S$ is the output of the lower OR gate
• $Z$ is the final output

Understanding the Question

You are given the circuit and a partly blank truth table. The table already lists the eight possible combinations of $A$, $B$ and $C$. Your task is to calculate the internal signals $P$, $Q$, $R$, $S$ and then the final output $Z$ for each row.

The working-space columns are a clue that you should not jump straight to $Z$. You should calculate the intermediate gate outputs first.

From the circuit:

• $P = \overline{A}$
• $Q = \overline{C}$
• the top OR gate gives $R = P + B + Q$
• the bottom OR gate gives $S = A + B + Q$
• the final AND gate gives $Z = R \cdot B \cdot S$

Approach

Use one row at a time.

1. Copy the input values $A$, $B$, $C$.
2. Invert $A$ to get $P$.
3. Invert $C$ to get $Q$.
4. Use $P$, $B$, $Q$ in the top OR gate to get $R$.
5. Use $A$, $B$, $Q$ in the bottom OR gate to get $S$.
6. AND together $R$, $B$ and $S$ to get $Z$.

A useful shortcut appears once you start: because $B$ goes directly into the final AND gate, if $B = 0$ then $Z$ must be 0. Also, when $B = 1$, both OR gates must output 1, so $Z$ becomes 1. That means this whole circuit behaves like $Z = B$.

Step-by-Step Reasoning

Start with the first row, $A=0, B=0, C=0$.

• $P = \overline{A} = 1$
• $Q = \overline{C} = 1$
• $R = P + B + Q = 1 + 0 + 1 = 1$
• $S = A + B + Q = 0 + 0 + 1 = 1$
• $Z = R \cdot B \cdot S = 1 \cdot 0 \cdot 1 = 0$

Second row, $A=0, B=0, C=1$.

• $P = 1$
• $Q = 0$
• $R = 1 + 0 + 0 = 1$
• $S = 0 + 0 + 0 = 0$
• $Z = 1 \cdot 0 \cdot 0 = 0$

Third row, $A=0, B=1, C=0$.

• $P = 1$
• $Q = 1$
• $R = 1 + 1 + 1 = 1$
• $S = 0 + 1 + 1 = 1$
• $Z = 1 \cdot 1 \cdot 1 = 1$

Fourth row, $A=0, B=1, C=1$.

• $P = 1$
• $Q = 0$
• $R = 1 + 1 + 0 = 1$
• $S = 0 + 1 + 0 = 1$
• $Z = 1 \cdot 1 \cdot 1 = 1$

Fifth row, $A=1, B=0, C=0$.

• $P = 0$
• $Q = 1$
• $R = 0 + 0 + 1 = 1$
• $S = 1 + 0 + 1 = 1$
• $Z = 1 \cdot 0 \cdot 1 = 0$

Sixth row, $A=1, B=0, C=1$.

• $P = 0$
• $Q = 0$
• $R = 0 + 0 + 0 = 0$
• $S = 1 + 0 + 0 = 1$
• $Z = 0 \cdot 0 \cdot 1 = 0$

Seventh row, $A=1, B=1, C=0$.

• $P = 0$
• $Q = 1$
• $R = 0 + 1 + 1 = 1$
• $S = 1 + 1 + 1 = 1$
• $Z = 1 \cdot 1 \cdot 1 = 1$

Eighth row, $A=1, B=1, C=1$.

• $P = 0$
• $Q = 0$
• $R = 0 + 1 + 0 = 1$
• $S = 1 + 1 + 0 = 1$
• $Z = 1 \cdot 1 \cdot 1 = 1$

So the completed truth table is correct.

Key Takeaways

• Complete logic-circuit truth tables by finding intermediate gate outputs first.
• NOT gates are usually the easiest starting point.
• OR outputs are 1 if any input is 1.
• AND outputs are 1 only if all inputs are 1.
• A direct input into a final AND gate can sometimes reveal a shortcut for the final output.

Common Mistakes

• Forgetting to invert $A$ or $C$ before using them in later gates.
• Treating OR like AND and writing 1 only when all inputs are 1.
• Missing that the final gate has three inputs, not two.
• Copying one wrong value in the working columns and then carrying the error through the row.

Things to Be Careful About

• Use the actual labelled signals from the diagram: $P$, $Q$, $R$, $S$, then $Z$.
• Read the wires carefully so you know which signals feed each gate.
• Make sure you complete all 8 rows because three inputs always give eight combinations.
• Keep the row order exactly as given in the table.

Background Concept

A graph consists of vertices (points or nodes) connected by edges. If the edges have weights, those weights can represent distance, time or cost. A shortest-path algorithm is used to find the path with the smallest total weight between two vertices.

In this syllabus, common AI graph-search algorithms include Dijkstra's algorithm and A* search. Dijkstra's algorithm finds the shortest path in a weighted graph by repeatedly selecting the unvisited vertex with the smallest current distance and updating neighbouring distances.

Understanding the Question

The question asks for one AI algorithm that can find the shortest distance between two points on a graph. It does not ask for a description, only the name of one suitable algorithm.

So the task is simply to recall one correct algorithm from this topic.

Approach

Recognise that “shortest distance between two points on a graph” means a shortest-path problem. Then name a valid algorithm from the AI graph-search topic.

A correct choice is Dijkstra's algorithm.

Step-by-Step Reasoning

The key clue is the phrase “shortest distance” on a “graph”. That immediately points to shortest-path algorithms.

From the syllabus, acceptable algorithms include:

• Dijkstra's algorithm
• A* search

Only one is needed. Writing “Dijkstra's algorithm” is enough for the mark.

Key Takeaways

• A graph shortest-path problem is solved using algorithms such as Dijkstra's or A*.
• For a one-mark identify question, the algorithm name alone is usually sufficient.

Common Mistakes

• Naming a general AI method such as machine learning or a neural network. These are AI techniques, but they are not shortest-path algorithms.
• Giving a search method that does not guarantee the shortest weighted path, unless the mark scheme allows it.
• Describing the algorithm instead of naming it, but forgetting to include the actual algorithm name.

Things to Be Careful About

• The question asks for one algorithm, so one correct name is enough.
• Make sure the algorithm is specifically suitable for graph path-finding.
• Read the wording carefully: “shortest distance” suggests a weighted shortest-path method, not just any traversal of a graph.

Background Concept

Deep Learning is a branch of machine learning. Machine learning is where a computer system learns patterns from data instead of having every rule written explicitly by a programmer.

Deep Learning specifically uses artificial neural networks with many layers. A neural network is made of connected processing units called neurons. These connections have weights, and the values of those weights determine how strongly signals influence the next layer.

A simple neural network may have an input layer, one hidden layer and an output layer. A deep neural network has multiple hidden layers. These extra layers allow the system to learn more complex and abstract patterns.

Training usually involves presenting many examples to the network, comparing the output with the correct answer, calculating the error, and then adjusting the weights. A common method for this is back propagation.

Understanding the Question

The question asks you to describe Deep Learning, not just name it. That means you need several clear points about what it is and how it works.

Good answers should cover:

• what Deep Learning is
• what structure it uses
• how it learns
• what makes it useful

Because it is worth 5 marks, one short sentence is not enough. You need a fuller description with several separate valid ideas.

Approach

A strong way to answer is to build the description in layers:

1. Define Deep Learning as a type of machine learning.
2. State that it uses artificial neural networks.
3. Explain that it is “deep” because it has many hidden layers.
4. Explain that it is trained using data by adjusting weights.
5. State that it can learn complex features or patterns automatically.

This structure gives enough separate points for a 5-mark answer.

Step-by-Step Reasoning

Start with the definition:

• Deep Learning is a type of machine learning. This is important because it places it in the correct area of AI.

Then explain the model used:

• It is based on artificial neural networks. That tells the examiner what computational structure is being used.

Next explain why it is called “deep”:

• The network contains many layers, especially multiple hidden layers between input and output. These layers allow the network to process data in stages.

Then explain learning or training:

• The network is trained using large amounts of data.
• It produces an output, compares that output with the expected result, and measures the error.
• The weights between neurons are then adjusted, often by back propagation, so future outputs are more accurate.

Finally explain the benefit:

• Because of its layered structure, Deep Learning can automatically detect and learn complex patterns in data.
• This means the programmer does not need to manually specify every feature or rule.
• It is especially useful for tasks such as image recognition, speech recognition and natural language processing.

For this question, you do not need to go into mathematical detail. The key is to describe the idea clearly and include several distinct facts.

Key Takeaways

• Deep Learning is a subset of machine learning.
• It uses artificial neural networks with multiple hidden layers.
• It learns by training on data and adjusting connection weights.
• Back propagation is a common training method.
• Its strength is automatic learning of complex features and patterns.

Common Mistakes

• Saying Deep Learning is the same as all AI. It is only one area within AI.
• Describing a normal program with fixed rules instead of a system that learns from data.
• Forgetting to mention the multiple hidden layers, which is the key idea behind “deep”.
• Saying it stores all answers directly rather than learning by changing weights.
• Giving examples like robots or chatbots without actually describing the Deep Learning method.

Things to Be Careful About

• Distinguish between machine learning in general and Deep Learning in particular.
• Use the term “artificial neural network” accurately.
• Make sure you mention learning from data, not just producing outputs.
• If you mention back propagation, spell out that it is used to adjust weights based on error.
• For a describe question, include several linked points rather than one vague definition.

Background Concept

Compilation happens in stages. One early stage is lexical analysis. The lexical analyser reads the raw source code as a stream of characters and breaks it into meaningful units called tokens. Examples of tokens are keywords, variable names, numeric constants, operators and punctuation symbols.

For example, a line such as Total = Count + 1 is not most useful to the compiler as individual characters. The lexical analyser groups it into token-sized pieces such as identifier, assignment symbol, identifier, plus symbol and integer constant. Once the code has been tokenised, the next stage, usually syntax analysis, can check whether those tokens appear in a valid order.

Understanding the Question

This question asks for the purpose of lexical analysis, not a full description of the whole compiler. So the answer should focus on what this stage does and why it is needed.

For 2 marks, the safest response is usually:

• what lexical analysis does to the source code
• what happens to the result of that process

Approach

A good way to answer is to name the two core ideas:

1. scan and split into tokens
2. provide those tokens for later compiler stages / detect invalid items

That gives a complete but concise outline.

Step-by-Step Reasoning

The source program begins as plain text. The compiler cannot efficiently work on it character by character all the way through, so lexical analysis is used.

First, the lexical analyser reads the characters of the source code.

Next, it groups sequences of characters into valid lexical units. For example:

• IF becomes a keyword token
• Counter becomes an identifier token
• + becomes an operator token
• 25 becomes a numeric constant token

If something does not form a valid token, that is a lexical error and can be reported at this stage.

After tokenisation, those tokens are passed on to the next compiler stage, typically syntax analysis, which checks whether the token sequence follows the language grammar.

So the purpose is both to turn raw source text into tokens and to prepare the program for further compilation checks.

Key Takeaways

• Lexical analysis is an early stage of compilation.
• It converts a stream of characters into tokens.
• These tokens are then used by later stages such as syntax analysis.
• Invalid lexical items can be detected here.

Common Mistakes

• Confusing lexical analysis with syntax analysis. Lexical analysis identifies tokens; syntax analysis checks whether the token sequence fits the grammar.
• Saying it "executes the program". Compilation stages translate and analyse code; they do not run the finished program.
• Giving only examples of tokens without explaining the actual purpose.

Things to Be Careful About

• Use the word tokens explicitly, because that is the key technical term.
• Keep the answer about compilation stages, not interpretation.
• If you mention errors, make sure they are invalid lexical items, not general logic errors in the program.

Background Concept

Reverse Polish Notation (RPN), also called postfix notation, writes each operator after its operands. This removes the need for brackets when the expression order is fixed.

Examples:

• A + B becomes A B +
• (A + B) * C becomes A B + C *

RPN is useful because it can be evaluated easily using a stack. Operands are pushed onto the stack, and when an operator is reached, the required operands are popped, the operation is carried out, and the result is pushed back.

Understanding the Question

The question gives the infix expression:

(2 - 6) * (13 + 7) / 5

and asks for the RPN form. The brackets are important because they show which operations happen first. The task is not to evaluate the expression; it is to rewrite it so that each operator appears after the values it works on.

Approach

Break the infix expression into smaller parts:

1. convert the first bracketed expression
2. convert the second bracketed expression
3. combine them with the multiplication operator
4. place the division by 5 at the end

This works because RPN follows the execution order directly.

Step-by-Step Reasoning

Start with the first bracket:

(2 - 6)

In RPN, the operands come first, then the operator:

2 6 -

Now the second bracket:

(13 + 7)

In RPN:

13 7 +

Now these two bracketed results are multiplied together:

(2 - 6) * (13 + 7)

So write the RPN for the first result, then the RPN for the second result, then *:

2 6 - 13 7 + *

Finally, the whole result is divided by 5, so append 5 /:

2 6 - 13 7 + * 5 /

That is the complete postfix form.

Key Takeaways

• In RPN, operators come after their operands.
• Convert bracketed sections first.
• When combining subexpressions, write both completed operand expressions before the operator.
• Division and subtraction still keep operand order, so the sequence matters.

Common Mistakes

• Writing the operator too early, for example 2 - 6 instead of 2 6 -.
• Losing the effect of brackets and treating the expression as simple left-to-right text.
• Reversing subtraction or division order. 2 6 - means 2 - 6, not 6 - 2.
• Forgetting the final / 5 part.

Things to Be Careful About

• Preserve the original operand order for non-commutative operations like - and /.
• Do not include brackets in the final RPN expression.
• Make sure the final operator / comes after the 5, because it divides the previous whole result by 5.

Background Concept

RPN expressions are evaluated using a stack.

The rule is:

• if the next item is an operand, push it onto the stack
• if the next item is an operator, pop the top two values, apply the operator in the correct order, then push the result

Order matters for subtraction and division:

• if the stack pops x then y, the calculation is y - x or y / x
• it is not x - y or x / y

This is why stack tracing must be done carefully.

Understanding the Question

The RPN expression is:

d a b + * c a - /

with:

• a = 6
• b = 12
• c = 15
• d = 5

So the expression actually becomes:

5 6 12 + * 15 6 - /

The question specifically asks to show the changing contents of the stack as the expression is evaluated. That means we should show the state of the stack after each token is processed.

Approach

Work left to right through the RPN expression.

For each symbol:

• if it is a value, push it
• if it is +, -, * or /, pop the top two values, calculate the result, then push the result back

After every step, record the stack contents from bottom to top.

Step-by-Step Reasoning

First substitute the values:

d a b + * c a - /

becomes:

5 6 12 + * 15 6 - /

Now trace it.

1. Read 5

   • push 5
   • stack: [5]

2. Read 6

   • push 6
   • stack: [5, 6]

3. Read 12

   • push 12
   • stack: [5, 6, 12]

4. Read +

   • pop 12 and 6
   • calculate 6 + 12 = 18
   • push 18
   • stack: [5, 18]

5. Read *

   • pop 18 and 5
   • calculate 5 * 18 = 90
   • push 90
   • stack: [90]

6. Read 15

   • push 15
   • stack: [90, 15]

7. Read 6

   • push 6
   • stack: [90, 15, 6]

8. Read -

   • pop 6 and 15
   • calculate 15 - 6 = 9
   • push 9
   • stack: [90, 9]

9. Read /

   • pop 9 and 90
   • calculate 90 / 9 = 10
   • push 10
   • stack: [10]

So the final value of the whole RPN expression is 10.

Key Takeaways

• RPN is naturally evaluated with a stack.
• Operands are pushed; operators cause two pops and one push.
• For subtraction and division, preserve the correct operand order.
• A stack trace shows the changing state after each token.

Common Mistakes

• Reversing the operand order for - or /. For example, using 6 - 15 instead of 15 - 6.
• Forgetting to push the result back after an operation.
• Recording too many or too few stack states. The stack should change after each symbol processed.
• Mixing up top and bottom of the stack in the diagram.

Things to Be Careful About

• Substitute the variable values correctly before tracing.
• After an operator, two values are removed and only one result is returned, so the stack height usually decreases by one.
• Keep the stack contents in order from bottom to top.
• The final stack should contain exactly one value if the RPN expression is valid.

Background Concept

Recursion is a programming technique where a subroutine solves a problem by calling itself. Instead of solving the whole problem in one step, it repeatedly solves smaller versions of the same problem until it reaches a case that can be answered immediately.

Recursive calls are normally managed using a stack. Each time the function is called, the current state is stored so that when the deeper call finishes, execution can return to the earlier call. This is why recursion is closely linked to stacks.

For recursion to work correctly, three ideas are essential:

1. the routine must call itself,
2. there must be a base case to stop further calls,
3. each call must move closer to that base case.

Understanding the Question

The question says that a stack is used to implement recursion and asks for the three essential features of recursion.

This means it is not asking for an example program, nor for a description of stack frames in detail. It wants the fundamental characteristics that make a recursive algorithm valid.

Because the question specifically asks for three features, the safest answer is to give the standard three core points.

Approach

Think of what must be true for any recursive solution:

• it repeats by calling itself,
• it must not continue forever, so it needs a stopping condition,
• it must get closer to that stopping condition each time.

These three points are general and apply no matter what the recursive problem is, such as factorial, tree traversal or binary search written recursively.

Step-by-Step Reasoning

First, recursion requires self-reference:

• a procedure or function must call itself, directly or indirectly.

Without this, it is not recursion.

Second, it needs a base case:

• this is the simplest case of the problem, where the answer is known immediately and no further recursive call is made.

For example, in factorial, 0! = 1 is a base case.

Third, each recursive call must reduce the problem:

• the input or state must become smaller, simpler or closer to the stopping condition.

For example, factorial changes n to n - 1; a tree traversal moves to a subtree; a recursive search reduces the search interval.

If this progress does not happen, the routine may never reach the base case and will recurse forever until stack overflow occurs.

So the three essential features are exactly those three points.

Key Takeaways

• Recursion means a routine calls itself.
• A valid recursive solution must include a base case.
• Each recursive step must reduce the problem so the base case is eventually reached.
• Stacks are used to remember earlier calls while deeper calls are running.

Common Mistakes

• Saying only "uses a stack" as one of the essential features. That is related to implementation, but the core features of recursion are the self-call, base case and progress towards that base case.
• Giving an example such as factorial instead of stating the general features.
• Mentioning a loop as a feature of recursion. Recursion does not require a loop.
• Forgetting that the problem must get smaller each time. Without that, the recursion may not terminate.

Things to Be Careful About

• The question asks for features of recursion, not advantages or disadvantages.
• "Calls itself" alone is not enough for full marks; you also need the stopping condition and reduction of the problem.
• When wording the third point, make it clear that each call moves towards the base case, not just that it repeats.
• If you mention the stack, treat it as supporting detail rather than one of the three essential features unless the mark scheme specifically asks about implementation.

Background Concept

This question uses simple accumulator-based assembly language. An accumulator processor has one main working register, ACC. Most arithmetic happens in ACC, so the usual pattern is:

1. load a value into ACC
2. carry out an operation on ACC
3. store the result back to memory

The instructions given here are enough for a basic calculation:

• LDM #n loads an immediate denary value into ACC
• LDD address loads the contents stored at that address into ACC
• SUB address subtracts the contents of that address from ACC
• STO address stores the current ACC value into that address

A label can stand for a memory address. That means a line such as Constant: 100 creates a named memory location containing 100. This is how constants and variables are usually initialised in such questions.

Understanding the Question

You are asked to do three things:

• create a named constant containing the denary value 100
• subtract that constant from the value stored at address 632
• store the result in a variable called Answer

The question also specifically says to show the initialisation of the constant and Answer in the table. That means the constant and Answer should be shown as labelled memory locations with starting contents.

The value at address 632 must be read from memory, not typed in directly, so LDD 632 is needed.

Approach

Use the normal accumulator sequence:

• load the value stored at address 632 into ACC
• subtract the contents of the constant's address from ACC
• store the result in Answer

Then define the two labelled data items:

• a constant label holding 100
• Answer initialised to 0

There is no need to use LDM #100 here, because the question asks for the constant to be shown in the initialisation table, so the value can simply be stored as labelled data.

Step-by-Step Reasoning

First, define a constant label. Any sensible name is acceptable, such as Constant or Hundred. The important point is that it stores the value 100.

So the data declaration is:

• Constant 100

Next, define Answer as a variable. Before the program runs, it needs an initial value in memory. 0 is the normal initial value.

So the second data declaration is:

• Answer 0

Now write the instructions.

1. LDD 632

   • This loads into ACC whatever value is stored at memory address 632.
   • It is correct because the question says the value is contained in address 632.

2. SUB Constant

   • This subtracts the contents of the labelled memory location Constant from ACC.
   • Since Constant stores 100, the machine performs: $$ACC \leftarrow ACC - 100$$

3. STO Answer

   • This stores the result now in ACC into the memory location labelled Answer.

So the full solution is a three-instruction sequence plus the two initialised memory locations.

Key Takeaways

• In accumulator assembly, arithmetic is usually load, operate, then store.
• A label can be used as a named memory address for a constant or variable.
• LDD is used when the value must be fetched from a memory address.
• SUB label subtracts the contents stored at that labelled location, not the label name itself.

Common Mistakes

• Using LDM #632 instead of LDD 632. That would load the number 632, not the contents of address 632.
• Writing SUB #100. The given instruction set does not include immediate subtraction.
• Forgetting to store the result with STO Answer.
• Not initialising Answer in the table when the question explicitly asks for it.
• Treating the constant as an instruction rather than a labelled data value.

Things to Be Careful About

• # means an immediate denary value, so only use it with LDM here.
• Constant must be a labelled memory location containing 100, not just a comment or name in the code.
• Answer is a variable name, so it must also correspond to a memory location.
• Follow the exact order: load from 632, subtract the constant, then store the result.

Background Concept

After assembly instructions are written, you may be asked to work out the final contents of memory. On an accumulator machine, that means following the instruction sequence and updating ACC step by step.

If the program does:

• load a value into ACC
• subtract another stored value
• store the result

then the final variable contains the arithmetic result left in ACC.

Understanding the Question

Part (b) tells you that address 632 contains 45. In part (a), the program subtracts the constant 100 from whatever is in address 632 and stores the result in Answer.

So here you are simply evaluating:

and stating the final value in Answer.

Approach

Take the instructions from part (a) mentally:

• LDD 632 puts 45 in ACC
• SUB Constant subtracts 100
• STO Answer stores the result

So just calculate the subtraction carefully, including the sign.

Step-by-Step Reasoning

Start with:

• address 632 contains 45
• Constant contains 100

Execute the steps:

1. LDD 632

   • ACC = 45

2. SUB Constant

   • subtract 100 from ACC
   • $$45 - 100 = -55$$
   • now ACC = -55

3. STO Answer

   • store -55 in Answer

So the final value of Answer is -55.

Key Takeaways

• To find the result of assembly code, follow each instruction in order.
• Always distinguish between an address and the value stored at that address.
• Subtracting a larger number from a smaller one gives a negative result.

Common Mistakes

• Writing 55 instead of -55. The sign matters.
• Subtracting in the wrong order as 100 - 45.
• Forgetting that address 632 contains 45; the program uses the contents, not the address number itself.

Things to Be Careful About

• The operation is value at 632 minus constant, not the other way round.
• Keep track of the accumulator after each instruction.
• Give the final stored value in Answer, not just the intermediate ACC without context.