Background Concept

Binary floating-point stores a number in two parts: a mantissa and an exponent. The mantissa holds the significant digits of the number, and the exponent tells us how far to shift the binary point.

In this question, both parts use two's complement. For a positive mantissa in two's complement floating-point, the number is usually written as a signed binary fraction with the binary point immediately after the sign bit. So a 10-bit mantissa such as 0111100101 is read as 0.111100101.

The value of the whole floating-point number is:

A normalised positive mantissa in two's complement begins 01..., which this one does, so it is already in normalised form.

Understanding the Question

You are given a complete floating-point number in this format:

• 10-bit mantissa
• 6-bit exponent
• two's complement for both

You must convert that stored binary value into an ordinary denary number and show the working. That means:

1. decode the mantissa,
2. decode the exponent,
3. combine them using the floating-point rule.

The mantissa shown is 0111100101 and the exponent shown is 001011.

Approach

First treat the mantissa as a binary fraction with the point after the sign bit. Because the sign bit is 0, the mantissa is positive.

Then convert the exponent from 6-bit two's complement into denary. Since its first bit is also 0, it is a positive exponent and can be read directly.

Finally multiply the mantissa value by $2^{\text{exponent}}$.

Step-by-Step Reasoning

The mantissa is:

0111100101

Because this is a positive two's complement mantissa, read it as:

0.111100101

Now convert that binary fraction to denary:

• first 1 = $\frac{1}{2}$
• second 1 = $\frac{1}{4}$
• third 1 = $\frac{1}{8}$
• fourth 1 = $\frac{1}{16}$
• fifth bit is 0, so add nothing
• sixth bit is 0, so add nothing
• seventh 1 = $\frac{1}{128}$
• eighth bit is 0, so add nothing
• ninth 1 = $\frac{1}{512}$

So:

Now decode the exponent:

001011

This is a 6-bit two's complement number. Since the first bit is 0, it is positive, so its denary value is simply:

Now apply the floating-point rule:

Since $2^{11} = 2048$:

So the denary value represented by this floating-point number is 1940.

Key Takeaways

• In this syllabus, the mantissa is treated as a signed binary fraction.
• For a positive two's complement exponent, you can read it directly as an ordinary binary integer.
• Floating-point conversion always follows the pattern: decode mantissa, decode exponent, then multiply by $2^{\text{exponent}}$.
• A normalised positive mantissa in two's complement starts with 01.

Common Mistakes

• Reading the mantissa as an integer instead of a fraction. The binary point is after the sign bit, not at the end.
• Forgetting that the exponent is in two's complement and just assuming all exponents are unsigned.
• Using the wrong power, for example multiplying by $2^{10}$ instead of $2^{11}$.
• Misreading the mantissa bits and missing one of the fractional place values.

Things to Be Careful About

• Keep the mantissa and exponent separate; they are decoded differently.
• Check the first bit of each part before deciding how to interpret it in two's complement.
• Do not try to renormalise the number here; the question says it is already normalised.
• When converting binary fractions, line up each bit with the correct place value: $\frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \frac{1}{16}, \dots$

Background Concept

To store a denary number in binary floating-point form, you first convert the number to binary, then rewrite it in normalised form, and finally store the mantissa and exponent in the required bit lengths.

In this system:

• the mantissa has 10 bits,
• the exponent has 6 bits,
• both use two's complement.

For a positive normalised mantissa in two's complement, the first two bits are 01. The mantissa is stored as a signed binary fraction, so the binary point sits after the sign bit.

Understanding the Question

You must represent +26.6875 in the given floating-point format. That means you need to:

1. convert 26.6875 to binary,
2. normalise it so it fits the mantissa format,
3. write the exponent in 6-bit two's complement.

Because the number is positive, both the mantissa sign and the exponent sign will be positive as well.

Approach

Start by converting the whole-number part and the fractional part separately:

• 26 to binary,
• 0.6875 to binary.

Then combine them into one binary number.

Next, shift the binary point until the mantissa is in normalised two's complement form for a positive number, which means starting 0.1... and specifically 01... in the stored bits.

Count how many places the point moved: that becomes the exponent. Finally write the mantissa as 10 bits and the exponent as a 6-bit two's complement value.

Step-by-Step Reasoning

First convert 26 to binary:

Now convert 0.6875 to binary. Using binary fraction place values:

• $0.5$ fits, so first fractional bit is 1
• remainder is $0.1875$
• $0.25$ does not fit, so next bit is 0
• $0.125$ fits, so next bit is 1
• remainder is $0.0625$
• $0.0625$ fits, so next bit is 1

So:

Combine the integer and fraction parts:

Now normalise it for this floating-point system. We want the mantissa to be a signed fraction. Move the binary point left until the value is between $0.5$ and $1$ for a positive number:

Why exponent 5? Because the binary point moved 5 places to the left.

Now write the mantissa bits. The sign bit is 0 because the number is positive, followed by the fractional bits 110101011.

So the 10-bit mantissa is:

0110101011

Now write the exponent +5 in 6-bit two's complement. Since it is positive, this is ordinary binary padded to 6 bits:

000101

So the final floating-point representation is:

• Mantissa: 0110101011
• Exponent: 000101

Key Takeaways

• Convert the integer and fractional parts separately when changing denary to binary.
• For this floating-point format, the mantissa is stored as a signed binary fraction.
• Normalising means shifting the binary point and recording that shift in the exponent.
• Positive exponents in two's complement are just ordinary binary with leading zeros.

Common Mistakes

• Writing the mantissa as 1101010110 or another integer-like form instead of as a signed fraction.
• Using the wrong exponent because of miscounting how many places the binary point moved.
• Forgetting to pad the exponent to the full 6 bits.
• Stopping the fraction conversion too early and losing the exact .1011 part.
• Giving an unnormalised mantissa such as 11010.1011 directly in the mantissa field.

Things to Be Careful About

• Count mantissa bits exactly: 10 bits total, including the sign bit.
• The exponent must be exactly 6 bits.
• Make sure the positive normalised mantissa begins 01, which 0110101011 does.
• Do not add extra trailing bits beyond the mantissa length unless rounding is required; here the value fits exactly.

Background Concept

Protocols are agreed sets of rules that allow devices and software to communicate correctly. In the TCP/IP protocol suite, the Application Layer provides services directly used by user applications such as web browsers and email clients.

Each application-layer protocol has a specific purpose:

• HTTP stands for HyperText Transfer Protocol. It is used for requesting and delivering web pages and other web resources.
• IMAP stands for Internet Message Access Protocol. It is used by an email client to access email messages stored on a mail server.

The key idea is that a protocol is not just "for the Internet" in general; it has a particular job.

Understanding the Question

This question names two protocols, HTTP and IMAP, and asks you to state the purpose of each one.

That wording is a clue that the answer should be short and precise. You do not need to explain packet structure, layers in detail, or how the protocols work internally. You just need to say what each protocol is used for.

Approach

The best approach is:

1. Recognise both as application-layer protocols.
2. Match each protocol to the service it provides.
3. Write one clear purpose statement for each.

A good answer uses the correct context:

• HTTP -> web pages / web resources / browser-server communication
• IMAP -> email access / messages on a mail server

Step-by-Step Reasoning

For HTTP:

• A browser needs a way to ask a web server for a page.
• The server then sends the requested page or other resource back.
• So the purpose of HTTP is to allow requesting and transferring web content.

For IMAP:

• An email client needs a way to view and organise messages that are stored on a mail server.
• IMAP lets the user access those messages without necessarily downloading and removing them from the server.
• So the purpose of IMAP is to access and manage email on the mail server.

A concise exam answer does not need all of those supporting details, but that is the reasoning behind the correct statements.

Key Takeaways

• HTTP is for web page and web resource transfer.
• IMAP is for accessing and managing email stored on a server.
• When a question says state the purpose, give a short functional description, not a long explanation.

Common Mistakes

• Saying HTTP is used to send emails. That is incorrect; email protocols include SMTP, POP3, and IMAP.
• Saying IMAP sends emails. IMAP is mainly for accessing and managing received email; SMTP is used for sending.
• Giving only vague answers such as used on the Internet. That is too general to earn the mark.
• Confusing IMAP with POP3. POP3 usually downloads email from the server, whereas IMAP is focused on server-based access and synchronisation.

Things to Be Careful About

• Mention web pages/resources for HTTP, not just "data".
• Mention email messages on a mail server for IMAP, not just "communication".
• Keep the answer specific to the protocol named.
• Do not drift into lower-layer protocols such as TCP or IP, because the question is about the Application Layer.

Background Concept

BitTorrent is an application-layer protocol used for peer-to-peer (P2P) file sharing. In peer-to-peer sharing, each computer in the network can act as both a client and a server.

This is different from the traditional client-server model, where one central server sends the whole file to every user. In BitTorrent:

• a file is broken into small pieces or chunks
• users obtain different chunks from different peers
• users also share chunks they already have with others

This makes distribution efficient, especially for large files and many users.

Understanding the Question

The question asks you to describe how files are shared using the BitTorrent protocol.

So you are not being asked to define BitTorrent in one phrase. You need to explain the process of sharing:

• what happens to the file first
• who the file is downloaded from
• how peers help one another
• what happens at the end

Those process steps are what usually earn the marks.

Approach

A strong way to answer is to describe the sharing process in sequence:

1. The file is divided into chunks.
2. The user connects to other peers who have some or all of the file.
3. Different chunks are downloaded from different peers.
4. The user also uploads chunks to others while downloading.
5. The chunks are put back together into the complete file.

That sequence matches how BitTorrent works and covers the main examinable ideas.

Step-by-Step Reasoning

1. The original file is split into pieces

   • BitTorrent does not normally send the whole file in one uninterrupted stream from one machine.
   • Instead, the file is divided into many smaller chunks.
   • This allows separate parts to be distributed independently.

2. Peers are used instead of one central source

   • A user wanting the file joins a set of computers sharing it.
   • These computers are called peers.
   • Some peers may already have the whole file; others may only have certain chunks.

3. Different chunks can come from different peers

   • The user can download multiple chunks from multiple sources.
   • This often makes downloading faster than relying on one server.
   • It also spreads the load across many machines.

4. Uploading happens at the same time

   • Once a peer has received a chunk, it can start sharing that chunk with other peers.
   • So participants are not just receiving data; they are also contributing data.
   • This is one of the main defining features of peer-to-peer systems.

5. The file is reassembled

   • After all chunks have been received, the software combines them in the correct order.
   • The result is the original complete file.

Some longer explanations also mention a tracker or metadata file that helps locate peers, or seeds that have the entire file. Those points are correct, but the core marks are usually for the chunking, peer-to-peer downloading, simultaneous uploading, and reassembly process.

Key Takeaways

• BitTorrent is a peer-to-peer file-sharing protocol.
• Files are shared as chunks, not usually as one single transfer.
• A user can download from many peers at once.
• A user also uploads chunks to others while downloading.
• The chunks are reassembled to recreate the complete file.

Common Mistakes

• Describing BitTorrent as if it were a single central server sending the file to everyone. That misses the peer-to-peer nature.
• Forgetting to mention that the file is split into chunks. This is a key idea.
• Saying users only download and never upload. In BitTorrent, peers typically do both.
• Not stating that the chunks are combined to form the original file at the end.
• Confusing BitTorrent with protocols like HTTP or FTP, which are not peer-to-peer file-sharing protocols in the same way.

Things to Be Careful About

• Use the term peers correctly: these are the computers sharing the file.
• Make clear that pieces can come from multiple peers, not just one.
• If you mention seeds, remember a seed has the complete file; if you mention a tracker, it helps peers find each other.
• Keep the explanation about how sharing works, not about whether BitTorrent is legal or illegal; the protocol itself is just a method of distribution.

Background Concept

Circuit switching and packet switching are two different ways of sending data across a network.

In circuit switching, a complete route is set up before data is sent. That route stays reserved for the whole communication session. This means the sender and receiver effectively have a dedicated connection for that period.

In packet switching, the message is broken into packets. Each packet is sent separately across the network and may share links with packets from many other users. The network does not keep one path permanently reserved.

A benefit is an advantage of a method, not just a feature. So for this kind of question, you need to turn the feature into a useful outcome.

Understanding the Question

This part asks for:

• one benefit of circuit switching
• one benefit of packet switching

So you must give one correct advantage for each method. You do not need a long explanation, but the point must clearly be a benefit.

For circuit switching, the key clue is the idea of a dedicated path. For packet switching, the key clue is shared use of network links.

Approach

Use the main feature of each method and convert it into an advantage:

• Circuit switching: dedicated route (\rightarrow) guaranteed bandwidth / continuous transmission / predictable performance.
• Packet switching: shared route (\rightarrow) better use of bandwidth / more efficient / suitable for many users.

Then state each benefit clearly in one line.

Step-by-Step Reasoning

For circuit switching:

• A route is established before communication starts.
• That route stays reserved for the connection.
• Because nobody else uses that reserved path during the session, the connection has predictable capacity.
• So a valid benefit is that bandwidth is guaranteed or that transmission is continuous with little delay variation.

For packet switching:

• Data is split into packets.
• Packets share network links with other traffic.
• The link is not reserved for one user all the time.
• Therefore the network can be used more efficiently.
• So a valid benefit is that bandwidth is used more efficiently.

That is why the answer gives one advantage linked to each switching method.

Key Takeaways

• Circuit switching is associated with a dedicated path and predictable transmission.
• Packet switching is associated with shared paths and efficient use of network resources.
• In short-answer questions, turn a feature into a clear benefit.

Common Mistakes

• Giving only a feature, such as "circuit switching uses a dedicated path," without stating why that is useful.
• Giving a disadvantage instead of a benefit.
• Mixing the two methods up, for example saying circuit switching shares bandwidth.
• Writing about unrelated topics such as encryption or protocols instead of the switching method.

Things to Be Careful About

• The question asks for one benefit of each, so one clear point per method is enough.
• Make sure the benefit is attached to the correct switching type.
• If you say packet switching is "faster," that is unsafe because it is not always true; efficiency is the safer marking-point.
• If you say packets "take different routes," remember that this is a feature and needs linking to a benefit such as resilience or flexible routing.

Background Concept

The key difference between circuit switching and packet switching is how the network handles the path used by the data.

In circuit switching:

• a complete path is established first
• the path is reserved for the whole session
• data travels along that same path

In packet switching:

• data is broken into packets
• no single path is permanently reserved
• packets may be routed independently through the network

A question asking for differences wants a comparison, so each point should mention both methods or clearly contrast them.

Understanding the Question

This part asks for two differences. That means two separate comparisons between circuit switching and packet switching.

Strong answers usually compare:

• whether a dedicated path is set up
• whether all data follows one route or packets can take different routes

Other valid comparisons could include reserved bandwidth versus shared bandwidth, or setup required versus no setup.

Approach

Choose two standard textbook contrasts and state each one in a paired way:

1. what happens before transmission begins
2. how the route is used during transmission

This makes each difference complete and easy for the examiner to credit.

Step-by-Step Reasoning

First difference:

• In circuit switching, the network creates a connection before any real data is transferred.
• This connection is dedicated to that communication.
• In packet switching, the network does not reserve one dedicated end-to-end connection in advance.
• So the first valid difference is:
  • circuit switching sets up a dedicated connection first, packet switching does not.

Second difference:

• Once a circuit-switched connection exists, the data uses that same route throughout the session.
• In packet switching, packets are handled separately by the network.
• Different packets from the same message may travel by different routes.
• So the second valid difference is:
  • circuit switching uses one fixed route, packet switching can use different routes for different packets.

These are strong answers because they are precise, clearly contrasted, and directly about switching methods.

Key Takeaways

• Differences questions should be answered as direct comparisons.
• Circuit switching: dedicated path, fixed route during communication.
• Packet switching: no dedicated path, packets may be routed independently.
• Good comparison points are setup, path usage, bandwidth use, and routing behaviour.

Common Mistakes

• Writing two facts about one method without comparing it to the other.
• Repeating the same idea twice in different wording, such as "dedicated path" and "reserved line," which may only count once.
• Saying packet switching always uses different routes; packets can take different routes, not necessarily always.
• Giving benefits instead of differences when the question specifically asks for differences.

Things to Be Careful About

• Make sure the two differences are genuinely distinct.
• Use comparison language such as "whereas", "in contrast", or give both methods in the same sentence.
• Avoid vague statements like "packet switching is better" because that is not a difference in method.
• Be precise: a circuit-switched path is established before transmission, which is a key exam point.

Background Concept

Low-level scheduling is the operating system activity that decides which ready process gets the CPU next. In a multitasking system, one process does not usually keep the processor forever. Instead, the OS uses time slicing: each running process is allowed to run for a short quantum of time.

An interrupt is a signal that makes the processor stop its current sequence temporarily and deal with something else. For scheduling, the important interrupt is commonly the timer interrupt. When the timer says the current time slice has expired, the processor must switch attention from the running process to the operating system.

To make process switching possible, the current process context must be saved. The context is the information needed to resume the process later, such as register contents, program counter and other state information stored in its process control block.

Understanding the Question

This question is not asking for a general definition of an interrupt. It is asking specifically how interrupt handling is used in low-level scheduling. So the answer needs to connect interrupts to CPU scheduling.

The key chain is:

1. an interrupt occurs,
2. the current process state is saved,
3. the scheduler gets control,
4. another process is chosen and resumed.

Those are the ideas that earn the marks.

Approach

A good approach is to describe the scheduling cycle in the correct order. Start with the trigger, which is normally a timer interrupt when the time slice ends. Then state what the processor/OS does with the currently running process. Finally, explain that the scheduler picks another ready process and restores its state.

For a 2-mark answer, concise linked points are better than a long explanation.

Step-by-Step Reasoning

A process is running on the CPU.

After a short period, the timer generates an interrupt. This is important because it gives the operating system a controlled way to take the CPU away from the running process.

When the interrupt is handled, the current process cannot just be abandoned. Its state must be saved so that it can continue later from the correct instruction with the correct register values. That saved information is its context.

Once the context has been saved, control passes to the operating system's scheduler or dispatcher. The scheduler looks at the ready processes and decides which one should run next.

The chosen process then has its previously saved context restored. That means the processor registers and program counter are put back to the values for that process, and execution continues.

So interrupt handling is what allows the operating system to interrupt a running process safely and switch the CPU to another process.

Key Takeaways

• Low-level scheduling decides which ready process gets the CPU.
• Timer interrupts are commonly used to end a time slice.
• Context saving and restoring are essential for process switching.
• Interrupt handling gives the OS control so it can perform scheduling.

Common Mistakes

• Saying only that an interrupt "stops the process" without mentioning scheduling. The question is about how interrupts are used in scheduling.
• Forgetting to mention saving the current process state/context. Without this, the process could not resume correctly later.
• Describing I/O interrupts instead of the timer interrupt used for time slicing. I/O interrupts exist, but the scheduling link here is usually the timer.
• Giving a vague answer like "the OS handles the interrupt and chooses something else" with no indication of context switching.

Things to Be Careful About

• Keep the sequence correct: interrupt, save context, run scheduler, restore next process.
• Use process-management language such as time slice, ready process, context and scheduler.
• Do not confuse low-level scheduling with high-level scheduling; here the focus is immediate CPU allocation among ready processes.
• If you mention the dispatcher as well as the scheduler, make sure the role is still clear: the scheduler chooses, and the selected process is then restored and run.

Background Concept

In process management, the operating system keeps track of the state of every process. The three basic states named here are:

• running: the process is currently executing on the CPU
• ready: the process could run, but the CPU is not currently assigned to it
• blocked: the process cannot continue yet because it is waiting for something

These states help the operating system manage multitasking efficiently. A process can move between them as events happen. For example, a running process may become blocked if it requests input from a device, or it may return to ready if its time slice expires.

Understanding the Question

The table already gives the three process states. Your job is to give one valid reason why a process could be in each state.

That means you do not need a full explanation of all state transitions. You just need one correct cause or description per row:

• why it would be running
• why it would be ready
• why it would be blocked

The safest answers are the standard textbook meanings of each state.

Approach

Treat each state separately.

For running, think: what must be true? The process has the CPU.

For ready, think: can it run right now? Yes, but it is waiting its turn because the CPU is busy with another process.

For blocked, think: what is stopping it? It is waiting for some external event, commonly I/O completion, data arrival or resource availability.

Then write one precise reason for each row.

Step-by-Step Reasoning

Running

A process is in the running state when the processor is actually executing its instructions. So a correct reason is that it has been selected by the scheduler and currently has control of the CPU.

Ready

A process is in the ready state when it is not blocked and has everything it needs except processor time. So a correct reason is that it is waiting in the ready queue until the CPU becomes available.

Blocked

A process is in the blocked state when it cannot continue until some event happens. The most common example is waiting for an input/output operation to finish. Other acceptable examples might include waiting for data, a message, or a resource.

So the completed table uses one valid reason for each state:

• running -> currently being executed
• ready -> waiting for CPU time
• blocked -> waiting for I/O completion or another event

Key Takeaways

• Running means the process has the CPU now.
• Ready means the process can run but is waiting for CPU allocation.
• Blocked means the process cannot proceed until an event/resource is available.
• Knowing the difference between ready and blocked is essential in process-state questions.

Common Mistakes

• Confusing ready with blocked. A ready process is able to run; a blocked process is not.
• Saying a blocked process is "waiting for the CPU". That describes ready, not blocked.
• Giving a vague reason like "it is waiting" without saying what it is waiting for.
• Saying a running process is "about to run". That would fit ready more than running.

Things to Be Careful About

• For running, refer to actual execution, not just selection.
• For ready, make it clear that the only missing resource is CPU time.
• For blocked, give a real event such as I/O completion, not just "not chosen yet".
• The question asks for one reason only for each state, so one clear valid statement per row is enough.

Background Concept

A truth table shows the output of a logic circuit for every possible combination of its inputs. To complete one, work through the circuit in the order the signals flow. For each gate, apply its rule:

• NOT reverses the input: 0 becomes 1, 1 becomes 0.
• OR outputs 1 if at least one input is 1.
• AND outputs 1 only if all inputs are 1.
• XOR outputs 1 only when its two inputs are different.

When a circuit has labelled intermediate points such as P, Q, R and S, these are usually included in the table so you can show your working clearly.

Understanding the Question

You are given a logic circuit with inputs A, B and C, and intermediate signals P, Q, R and S. The question asks you to complete the truth table and show working.

From the circuit:

• P is the output of a NOT gate on B, so $P = \overline{B}$.
• Q is the output of an XOR gate using A and P, so $Q = A \oplus P$.
• R is the output of an OR gate using B and C, so $R = B + C$.
• S is the output of an AND gate using Q and P, so $S = Q \cdot P$.
• Z is the output of a 3-input OR gate using S, P and R, so $Z = S + P + R$.

So the task is really to calculate these five derived values for each of the eight possible input rows.

Approach

The safest method is:

1. Copy the input rows in the given order.
2. Fill column P first because it depends only on B.
3. Use P to find Q.
4. Find R from B and C.
5. Find S from Q and P.
6. Find Z from S, P and R.

This left-to-right method prevents mistakes because each later signal uses earlier ones.

Step-by-Step Reasoning

Start with the definitions:

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

Now go row by row.

Row 1: A=0, B=0, C=0

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

Row 2: A=0, B=0, C=1

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

Row 3: A=0, B=1, C=0

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

Row 4: A=0, B=1, C=1

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

Row 5: A=1, B=0, C=0

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

Row 6: A=1, B=0, C=1

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

Row 7: A=1, B=1, C=0

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

Row 8: A=1, B=1, C=1

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

A useful observation is that Z is always 1 here. If B=0, then P=1, so the final OR gate must output 1. If B=1, then R=1 because $R=B+C$, so the final OR gate again must output 1.

Key Takeaways

• Work through a logic circuit in signal order, not input-row order alone.
• Use intermediate columns to avoid losing track of internal signals.
• XOR means “different”, not simply “OR”.
• A final OR gate can make a pattern obvious, such as Z always being 1.

Common Mistakes

• Treating XOR as ordinary OR. XOR only gives 1 when the two inputs differ.
• Forgetting that P is the inverse of B, so when B=0, P=1.
• Filling S from the wrong inputs. S comes from Q AND P, not from Q and R.
• Missing that Z is a 3-input OR, so any one of S, P or R being 1 makes Z=1.

Things to Be Careful About

• Keep the row order exactly as given in the table.
• Calculate columns in dependency order: P, then Q and R, then S, then Z.
• Do not skip intermediate columns even if you notice a shortcut.
• Make sure every cell is filled; a single wrong intermediate value can affect later columns.

Background Concept

Cryptography is the use of mathematical methods to protect data so that unauthorised people cannot read or alter it. At this level, the main named types you are expected to know are symmetric encryption and asymmetric encryption.

• Symmetric encryption uses the same key for encryption and decryption.
• Asymmetric encryption uses a pair of keys: a public key and a private key.

Questions that say "identify" or "state" usually want only the correct technical term, not an explanation.

Understanding the Question

The question tells you that asymmetric encryption is one type of cryptography and asks for one other type. So you only need to name another valid type.

The most standard answer in this syllabus is symmetric encryption.

Approach

Use recall from the encryption topic:

1. Think of the named types of encryption/cryptography you know.
2. Exclude the one already given in the question.
3. State one valid alternative.

Step-by-Step Reasoning

The question already gives asymmetric encryption.

Another standard type is symmetric encryption, where the same key is used to both encrypt and decrypt the data.

Because the command word is Identify, no further detail is needed for full credit.

Key Takeaways

• Know the two core named encryption types: symmetric and asymmetric.
• For a one-mark identification question, a correct term is enough.

Common Mistakes

• Giving an example of software or a protocol instead of a cryptography type.
• Describing encryption without naming a type.
• Repeating asymmetric encryption, which the question already gave.

Things to Be Careful About

• Read the wording carefully: it asks for one other type.
• Keep the answer short and precise.
• Use the exact technical term symmetric encryption.

Background Concept

In asymmetric encryption, each user or organisation has a key pair:

• a public key, which can be shared openly
• a private key, which must be kept secret

The keys are mathematically related, but they do different jobs. For confidentiality when sending data to someone:

• the sender encrypts using the recipient's public key
• the recipient decrypts using their private key

This works because data encrypted with the public key can only be decrypted by the matching private key. That is what makes it suitable for receiving secure transmissions.

Understanding the Question

The organisation wants to receive secure transmissions. That means the focus is on privacy/confidentiality of incoming messages, not proving who sent them.

So the question is really asking:

• which key does the organisation share?
• which key does the sender use?
• which key does the organisation keep secret?
• how does this arrangement keep the transmission secure?

The key clue is the word receive. When someone wants others to send them confidential data, they publish the public key and keep the private key secret.

Approach

Use the standard asymmetric-encryption pattern for confidentiality:

1. The organisation shares its public key.
2. A sender uses that public key to encrypt the message.
3. The sender transmits the encrypted data.
4. The organisation decrypts it with its private key.
5. Security comes from the fact that only the private key can decrypt the message.

This gives a clear sequence and covers all likely marking points.

Step-by-Step Reasoning

The organisation has two keys.

1. Decide which key can be shared

The public key is the one that may be given to anyone who needs to send a secure message to the organisation. It is designed to be distributed openly.

2. Decide which key must stay secret

The private key belongs only to the organisation. It must not be shared, because it is the key needed to recover the original message.

3. What the sender does

When someone wants to send a confidential transmission to the organisation, they take the organisation's public key and use it to encrypt the plaintext message.

After encryption, the message becomes ciphertext, which is unreadable without the correct corresponding key.

4. What happens during transmission

The encrypted message is then sent across the network. Even if it is intercepted, it should not be readable by an attacker because the attacker does not have the organisation's private key.

5. What the organisation does on receipt

When the organisation receives the ciphertext, it uses its private key to decrypt it and recover the original message.

6. Why this is secure

The important idea is that the two keys have different roles:

• public key for encryption by the sender
• private key for decryption by the recipient

So anyone may send a secure message using the public key, but only the organisation can read it because only the organisation has the private key.

Key Takeaways

• In asymmetric encryption, the two keys are not interchangeable.
• For confidentiality, encrypt with the recipient's public key and decrypt with the recipient's private key.
• The private key must remain secret.
• The public key can be distributed openly without breaking the system.

Common Mistakes

• Reversing the keys and saying the sender encrypts with the private key for confidentiality. That is not the normal method for private transmission.
• Saying both keys are secret. In asymmetric encryption, the public key is intended to be shared.
• Saying the organisation decrypts with the public key. For a confidential received message, decryption is done with the private key.
• Talking about passwords instead of encryption keys.
• Explaining digital signatures instead of secure message receipt. Signatures are about verification/authentication, whereas this question is about receiving a secure transmission.

Things to Be Careful About

• The question is specifically about receiving a secure transmission, so describe the process from the sender to the organisation.
• Use the correct key names exactly: public key and private key.
• Make clear that the public key is shared and the private key is kept secret.
• Do not confuse encryption with decryption.
• If you mention security, tie it to the fact that only the private key can decrypt the message.

Background Concept

A compiler translates source code into object code in several stages. Typical stages include lexical analysis, syntax analysis, code generation and optimisation. The optimisation stage does not change what the program does; instead, it tries to improve how efficiently the generated code will run.

Optimisation may remove unnecessary instructions, simplify repeated calculations, reduce memory usage or rearrange code so execution is faster. The key idea is that the output should behave the same as before, but be more efficient.

Understanding the Question

This question asks for the purpose of the optimisation stage during compilation. It is not asking for a description of all compilation stages, and it is not asking how optimisation is done in detail. For 1 mark, the answer needs one clear idea: optimisation improves the generated code so it executes more efficiently.

Approach

For a one-mark theory question like this, give the core purpose directly. The safest wording is to mention efficiency of the object code, such as faster execution or lower memory use.

Step-by-Step Reasoning

The optimisation stage happens after the compiler has already understood the source program and is generating machine-level or object code.

Its purpose is:

• not to change the program's result
• but to improve the generated code
• so the code executes more efficiently

"More efficiently" usually means one or both of:

• faster execution time
• less memory usage

So a full-credit answer is a short statement such as: the compiler optimises the object code to make it run faster or use less memory.

Key Takeaways

• Optimisation is a compilation stage.
• Its job is to improve efficiency, not change the program's meaning.
• Good short-answer wording is "faster execution" and/or "less memory".

Common Mistakes

• Saying it "finds errors": that is not the purpose of optimisation.
• Saying it "translates the code": that describes compilation in general, not optimisation specifically.
• Giving vague wording like "makes it better" without saying in what way.

Things to Be Careful About

• Mention efficiency of the generated code, not just the source code.
• Do not imply the program's output changes.
• For a 1-mark answer, keep it brief and precise.

Background Concept

Reverse Polish Notation (RPN), also called postfix notation, writes operators after their operands. For example, instead of writing a + b, RPN writes a b +.

RPN is useful because it removes the need for precedence rules and most brackets during evaluation. A stack is the standard tool for both evaluating an RPN expression and converting it back into infix form.

To convert RPN back to infix:

• read the expression from left to right
• when you see an operand, push it onto the stack
• when you see an operator, pop the top two items
• combine them as (left operator right)
• push the new sub-expression back onto the stack

The order matters very carefully:

• first popped item = right operand
• second popped item = left operand

Understanding the Question

The question gives the RPN expression:

a b - c + c a - * d /

and asks for the original infix form. That means we must rebuild the bracketed algebraic expression in the correct order.

Because the operators include subtraction and division, operand order is important. For example, a b - means (a - b), not (b - a).

Approach

Use a stack of partial expressions.

Each variable such as a, b, c, d is pushed as an operand. Every time an operator appears, take the most recent two items, combine them with brackets, and push the result back. Continue until one full expression remains.

Brackets are important here because the question asks for the original infix form, and the grouping must be unambiguous.

Step-by-Step Reasoning

Start reading left to right.

1. Read a

   • push a

2. Read b

   • push b

3. Read -

   • pop b then a
   • combine as (a - b)
   • push (a - b)

4. Read c

   • push c

5. Read +

   • pop c then (a - b)
   • combine as ((a - b) + c)
   • push that result

6. Read c

   • push c

7. Read a

   • push a

8. Read -

   • pop a then c
   • combine as (c - a)
   • push that result

9. Read *

   • pop (c - a) then ((a - b) + c)
   • combine as (((a - b) + c) * (c - a))
   • push it back

10. Read d

    • push d

11. Read /

    • pop d then (((a - b) + c) * (c - a))
    • combine as ((((a - b) + c) * (c - a)) / d)

Only one expression is left, so that is the infix form.

Key Takeaways

• RPN is converted back to infix using a stack.
• For every operator, pop two items and combine them.
• The first item popped becomes the right operand.
• Brackets help preserve the exact original grouping.

Common Mistakes

• Reversing operand order for - or /, for example writing (b - a) instead of (a - b).
• Missing brackets and producing an expression whose order of operations is ambiguous.
• Combining the wrong pair of sub-expressions when an operator appears.

Things to Be Careful About

• Always read left to right.
• For subtraction and division, the order of the two popped items is critical.
• Even if a simplified infix expression might still be mathematically acceptable, exam answers are safest when fully bracketed.
• Keep each sub-expression intact when it is pushed back onto the stack.

Background Concept

To evaluate an RPN expression, we use a stack. A stack follows LIFO order: last in, first out. That means the most recently pushed value is the first one removed.

The basic RPN evaluation rule is:

• if the next symbol is an operand, push it onto the stack
• if the next symbol is an operator, pop the top two values, apply the operator, then push the result back

For binary operators such as +, -, * and /, the order of the two popped values matters:

• first popped = right operand
• second popped = left operand

So if the stack top contains 6 above 16 and the operator is -, the calculation is 16 - 6, not 6 - 16.

Understanding the Question

The expression is:

c a / b d - * b +

with values:

• a = 3
• b = 16
• c = 9
• d = 6

The question does not just want the final answer. It specifically asks to show the changing contents of the stack as the RPN expression is evaluated. So we must track the stack after each symbol is processed.

Approach

First replace each variable by its value:

9 3 / 16 6 - * 16 +

Then process the expression one symbol at a time:

1. push numbers onto the stack
2. when an operator appears, pop two values
3. perform the calculation in the correct order
4. push the result
5. record the stack after every step

Because the question is about stack contents, it is best to show the state after each symbol.

Step-by-Step Reasoning

We will write the stack from bottom to top.

Start with an empty stack.

1. Symbol c

   • c = 9
   • push 9
   • stack: 9

2. Symbol a

   • a = 3
   • push 3
   • stack: 9, 3

3. Symbol /

   • pop 3 then 9
   • calculate 9 / 3 = 3
   • push 3
   • stack: 3

4. Symbol b

   • b = 16
   • push 16
   • stack: 3, 16

5. Symbol d

   • d = 6
   • push 6
   • stack: 3, 16, 6

6. Symbol -

   • pop 6 then 16
   • calculate 16 - 6 = 10
   • push 10
   • stack: 3, 10

7. Symbol *

   • pop 10 then 3
   • calculate 3 * 10 = 30
   • push 30
   • stack: 30

8. Symbol b

   • b = 16
   • push 16
   • stack: 30, 16

9. Symbol +

   • pop 16 then 30
   • calculate 30 + 16 = 46
   • push 46
   • stack: 46

The final value left on the stack is 46, so the whole expression evaluates to 46.

Key Takeaways

• RPN evaluation is done with a stack.
• Operands are pushed; operators pop two values and push one result.
• For - and /, operand order is crucial.
• The final result is the single value left on the stack.

Common Mistakes

• Doing division as 3 / 9 instead of 9 / 3.
• Doing subtraction as 6 - 16 instead of 16 - 6.
• Forgetting to push the result back after an operation.
• Giving only the final answer 46 and not showing the changing stack contents.

Things to Be Careful About

• Record the stack after every symbol, not just after each operator.
• Be consistent about whether you write the stack bottom-to-top or top-to-bottom.
• When an operator appears, the top of the stack is the right operand.
• Check that one final value remains on the stack at the end; if more than one remains, a step has gone wrong.

Background Concept

Back propagation of errors is a training method used with artificial neural networks. A neural network contains layers of nodes connected by weighted links. When input data is fed into the network, values pass forward through the layers and an output is produced.

If the network is being trained using supervised learning, the correct output is already known for each training example. Back propagation is then used to measure how wrong the network's answer is and to adjust the connection weights so that future answers are better.

The key idea is simple:

1. send data forward through the network,
2. measure the error,
3. send information about that error backwards,
4. change the weights to reduce the error.

Understanding the Question

This question asks you to describe the back propagation of errors method in machine learning. It is not asking for code or a mathematical derivation. It wants the main stages of the method in a clear sequence.

Because it is 4 marks, you should include several linked points rather than a one-line definition. The important ideas are output, comparison with expected result, backward passing of error, and weight adjustment.

Approach

The best approach is to describe the training cycle in order:

• produce an output,
• compare it with the correct output,
• calculate the error,
• move that error backwards through the network,
• alter weights,
• repeat until performance improves.

This gives a complete description that matches what examiners usually reward.

Step-by-Step Reasoning

First, the network is given a training example as input. The values move forward through the layers and the network produces an output.

Next, that output is compared with the expected or target output. If they are different, the system calculates an error value. This error shows how far the network's answer is from the correct answer.

Then the network works backwards from the output layer through the hidden layers. This is the "back propagation" stage. The error information is passed back through the network so the system can work out which weights contributed to the wrong result.

After that, the weights of the connections are adjusted. The aim is to reduce the error next time the same or similar input is processed. Larger errors usually lead to larger changes, while smaller errors lead to smaller adjustments.

This process is repeated over many training examples, often many times. Repeated adjustment gradually improves the network so that the total error becomes smaller and the outputs become more accurate.

A good 4-mark description therefore includes:

• output produced from training data,
• comparison with expected output,
• error calculated and sent backwards,
• weights changed and process repeated.

Key Takeaways

• Back propagation is a supervised learning training method for neural networks.
• The network learns by reducing the difference between actual and expected output.
• Errors are used to update the weights of connections.
• Training is iterative: the process is repeated many times.

Common Mistakes

• Describing only the forward pass and not mentioning the backward pass.
• Saying the network "stores the answer" instead of explaining that it adjusts weights.
• Forgetting that the output must be compared with a known correct output.
• Treating back propagation as a search algorithm rather than a training method.

Things to Be Careful About

• Use the correct sequence: forward output first, then error calculation, then backward adjustment.
• Mention weights specifically, because changing the weights is how learning occurs.
• The word "back" in back propagation matters: the error is sent from output layer towards earlier layers.
• Since this is a description question, clear ordered points score better than vague general statements.

Background Concept

An exception is a run-time error condition that occurs while a program is executing. Unlike a syntax error, which is found before the program runs, an exception happens during execution. Common examples are dividing by zero, trying to open a file that does not exist, or using an invalid array index.

If a program does not deal with the exception, the default behaviour is often that the program stops abruptly. Exception handling is the mechanism used to prevent that. A section of code is placed inside a construct such as TRY ... CATCH, TRY ... EXCEPT, or similar. If an exception occurs, control is transferred to the handling code instead of the whole program simply terminating.

Understanding the Question

The question is not asking for examples of exceptions yet; it is asking how termination can be avoided when an exception happens. So the key idea is not "remove all errors" but "catch the error and deal with it safely".

For 2 marks, the answer normally needs two linked ideas:

• the program must trap or catch the exception
• the program must then handle it in some way so that execution can continue or end in a controlled way

Approach

The best approach is to state the general method first: use exception-handling code. Then state what that code does: it intercepts the error and runs alternative instructions such as showing an error message, ignoring the faulty action, using a default value, or asking the user to re-enter data.

That directly answers both parts of the idea the examiner is looking for.

Step-by-Step Reasoning

1. The program reaches a statement that may cause a run-time problem.
2. That statement is placed inside an exception-handling structure such as TRY.
3. If no error occurs, execution continues normally.
4. If an exception occurs, the program does not immediately crash.
5. Instead, control jumps to the matching handler such as CATCH or EXCEPT.
6. The handler contains code to deal with the problem, for example:
   • output an error message
   • request valid input again
   • skip the invalid operation
   • use a safe default action
   • close files or clean up resources
7. Because the exception was handled, the program can continue running or end gracefully rather than halting unexpectedly.

So the essential description is: trap the exception, then provide handling code.

Key Takeaways

• Exceptions are run-time errors, not syntax errors.
• Unhandled exceptions can cause abrupt program termination.
• Exception handling works by trapping the error and running alternative code.
• A good answer must mention both catching the exception and handling it.

Common Mistakes

• Saying only "debug the program". That is not what the question asks; it asks how termination due to an exception is avoided during execution.
• Saying only "use validation". Validation can reduce some exceptions, but it is not the direct mechanism for handling an exception once it occurs.
• Mentioning TRY without saying what happens next. To score fully, you should also say the exception is handled so the program does not halt.
• Confusing syntax errors with exceptions. Syntax errors are usually found before execution, whereas exceptions occur at run time.

Things to Be Careful About

• Use the term exception handling accurately.
• Make clear that the error is trapped before termination.
• Make clear that there is handling code, not just detection.
• Do not drift into giving causes of exceptions here; that belongs to part (b).

Background Concept

An exception is caused by a run-time condition that the program cannot complete normally. These are situations where the instruction is valid in general, but the specific data or environment makes it fail.

Typical causes include:

• division by zero
• file not found
• invalid data type entered by a user
• array index out of bounds
• numeric overflow
• attempting an invalid operation on a null or uninitialised object

The exact examples accepted can vary, but they must be genuine run-time causes of exceptions.

Understanding the Question

This part asks for two possible causes, so the task is simply to name two valid situations that would raise an exception. No long explanation is needed. The safest approach is to choose very common, unambiguous examples.

Approach

Pick two standard run-time errors that are widely recognised:

• division by zero
• trying to access a file that is missing

These are strong choices because they are clearly exceptions and are unlikely to be disputed.

Step-by-Step Reasoning

For the first example:

• If a program evaluates an expression where the divisor is zero, the arithmetic operation cannot be completed.
• This raises an exception at run time.

For the second example:

• If a program attempts to open or read a file that is not present at the specified location, the operating system cannot complete the file access request.
• This raises a file-handling exception.

Since the question asks for two causes, listing these two is enough.

Key Takeaways

• Causes of exceptions are run-time problems.
• Good examples are specific situations, not vague statements like "there is an error".
• Division by zero and missing files are standard examples to remember.

Common Mistakes

• Giving syntax errors, such as a missing bracket. That is usually detected before the program runs, so it is not a run-time exception.
• Writing a vague answer such as "bad input" without making clear what the run-time problem is.
• Repeating the same idea twice in different words.
• Naming logic errors. A logic error may produce the wrong output without necessarily causing an exception.

Things to Be Careful About

• The question says identify two, so give exactly two clear examples.
• Make sure each example is definitely a cause of a run-time exception.
• Choose examples that are easy for an examiner to credit without extra explanation.
• Avoid over-explaining; this is a short identification question.

Background Concept

Recursion happens when a procedure or function calls itself. Every time that happens, the program must keep track of the current call so that it can return to it later.

The data saved for a call typically includes:

• the return address, so the program knows where to continue afterwards
• the parameter values for that call
• any local variables created during that call

This stored block of information is often called a stack frame or activation record. These frames are kept on a stack.

A stack is ideal because it is last-in, first-out (LIFO). The newest recursive call is always the next one that must complete, so the newest frame should be removed first.

Understanding the Question

The question asks why a stack is used when a recursive algorithm is executed. It is not asking how to write recursion. It wants the reason the computer uses a stack behind the scenes.

To answer well, you need to connect:

• what recursion does: many nested calls to the same routine
• what must be remembered for each call: address, parameters, local variables
• why the stack structure fits: the most recent call returns first

Approach

Give three linked points:

1. each recursive call needs its own stored context
2. that context is stored on a stack
3. the stack's LIFO behaviour matches the order in which recursive calls return and unwind

This directly addresses both the storage need and the reason the stack data structure is appropriate.

Step-by-Step Reasoning

Suppose a function calls itself several times. The first call cannot finish immediately because it pauses while the second call runs. Then the second may pause while a third call runs, and so on.

That creates a chain of unfinished calls. For the program to work correctly, each unfinished call must have its state saved somewhere. That state includes:

• where execution should resume after the inner call ends
• what argument values belong to that level of recursion
• what local variables belong to that level of recursion

A stack is used to store these separate call records.

Why a stack specifically?
Because the most recent recursive call is the first one that can complete. For example:

• Call 1 creates a frame and waits
• Call 2 creates a frame and waits
• Call 3 creates a frame and reaches the base case

Now Call 3 finishes first. Its frame is removed first. Control returns to Call 2. Then Call 2 finishes and its frame is removed. Then Call 1 finishes.

That order is exactly LIFO:

• last call made = first call removed
• earliest call made = last call removed

This is why recursion is naturally handled using a stack.

Key Takeaways

• Recursive calls create multiple unfinished instances of the same routine.
• Each call needs its own stored context, including return address and local data.
• A stack is used because recursive calls unwind in last-in, first-out order.
• Understanding recursion includes understanding what happens at runtime, not just the code itself.

Common Mistakes

• Saying only that "a stack stores data" without explaining what data or why that helps recursion.
• Describing a normal programmer-defined stack ADT instead of the call stack used by the system.
• Forgetting to mention return addresses or local variables/parameters.
• Saying recursion works in first-in, first-out order. That would describe a queue, not recursion.

Things to Be Careful About

• The question is about execution of recursion, so focus on runtime storage of calls.
• Use the idea of LIFO explicitly, because that is the key reason a stack is suitable.
• Distinguish between the recursive algorithm itself and the system mechanism used to manage it.
• The process of returning from deeper calls is often called unwinding; this is a useful term to know.