Background Concept

A truth table shows every possible combination of input values and the corresponding output. For three inputs A, B and C, there are 8 possible rows.

To match a logic statement to a truth table, you need to understand what each operator does:

• XOR gives 1 only when its two inputs are different.
• OR gives 1 if at least one input is 1.
• NOR means NOT OR, so it gives 1 only when the OR result is 0.
• AND gives 1 only when all inputs are 1.
• NOT reverses a value.

A very useful exam method is to focus first on the rows where the output is 1, because these rows are usually the quickest way to eliminate wrong options.

Understanding the Question

You are given a completed truth table for inputs A, B and C and output X. You must choose which one of the four given logic statements produces exactly that pattern.

From the table, X is 1 only for these two rows:

• A=0, B=0, C=0
• A=1, B=1, C=0

Every other row gives 0.

So the correct expression must produce 1 in exactly those two cases and nowhere else.

Approach

The best approach is not to calculate every option fully for all 8 rows unless you need to. Instead:

1. Notice the rows where X = 1.
2. Check each option against those rows.
3. Eliminate expressions that would create extra 1s.
4. Confirm the remaining choice against a few 0 rows.

This is faster and less error-prone than building four full truth tables.

Step-by-Step Reasoning

The truth table gives X = 1 only at 000 and 110.

Now test the options.

1. NOT (A AND B AND C)

   • A AND B AND C is 1 only for 111.
   • So NOT (A AND B AND C) would be 1 for all rows except 111.
   • That does not match the table, so this is wrong.

2. (A XOR B) NOR C

   • NOR means NOT of an OR result.
   • So this is NOT ((A XOR B) OR C).
   • If C = 1, then (... OR C) becomes 1, so the output must be 0. This matches all rows with C=1 in the table.
   • If C = 0, then the expression becomes NOT (A XOR B).
   • A XOR B is 0 when A and B are equal.
   • So NOT (A XOR B) is 1 when A and B are equal.
   • With C=0, that gives 1 for A=B=0 and A=B=1, which are exactly 000 and 110.
   • This matches perfectly.

3. (A OR B OR C) NOR C

   • This simplifies to NOT ((A OR B OR C) OR C), which is just NOT (A OR B OR C).
   • That gives 1 only for 000.
   • But the table also has 1 for 110, so this is wrong.

4. NOT A AND NOT B AND NOT C

   • This is 1 only when all three inputs are 0.
   • So it gives 1 only for 000.
   • It misses 110, so it is wrong.

Therefore the only matching statement is (A XOR B) NOR C.

Key Takeaways

• Use the rows where the output is 1 to identify the correct expression quickly.
• XOR checks whether two inputs are different.
• NOR means you perform OR first, then invert the result.
• A correct logic expression must match every row, not just some of them.

Common Mistakes

• Confusing XOR with OR. OR is 1 when either or both inputs are 1, but XOR is 1 only when they are different.
• Forgetting that NOR means OR followed by NOT.
• Checking only one row and assuming the answer is correct.
• Choosing NOT A AND NOT B AND NOT C because it matches 000, without noticing that the table also has 110 as 1.

Things to Be Careful About

• Read compound operators in the correct order: A XOR B happens before the NOR with C.
• Do not stop after finding one matching row; the expression must fit all 8 rows.
• In multiple-choice-style logic matching, eliminate answers that produce too many 1s or too few 1s before doing full checking.

Background Concept

To draw a logic circuit from a Boolean expression, you translate each part of the expression into gates.

Useful gate meanings here are:

• NOT A means input A passes through a NOT gate.
• NOT B means input B passes through a NOT gate.
• NOT B XOR C means the output from the NOT gate on B and the input C feed into an XOR gate.
• NOT A AND (NOT B XOR C) means those two intermediate results feed into an AND gate.
• NOT (...) around the whole expression means invert the final result, so put a NOT gate after the AND gate.

A good rule is to work from the inside out, just as you would evaluate brackets in arithmetic.

Understanding the Question

You must draw the circuit for:

X = NOT (NOT A AND (NOT B XOR C))

The blank figure already provides three inputs on the left, labelled A, B and C, and one output on the right, labelled X. Your job is to insert the correct gates and connect them in the correct order.

The important clue is the structure of the brackets:

• first make NOT A
• first make NOT B
• then combine NOT B with C using XOR
• then combine that result with NOT A using AND
• then invert the final result

Approach

Break the expression into smaller pieces:

1. NOT A
2. NOT B
3. (NOT B XOR C)
4. NOT A AND (NOT B XOR C)
5. NOT (...)

This tells you exactly which gates are needed and in what order. If you draw it in this sequence, the circuit is much easier to build correctly.

Step-by-Step Reasoning

Start with the expression:

X = NOT (NOT A AND (NOT B XOR C))

Now convert each part.

1. NOT A

   • Send input A through a NOT gate.
   • This produces the signal NOT A.

2. NOT B

   • Send input B through a NOT gate.
   • This produces the signal NOT B.

3. (NOT B XOR C)

   • Take the output from the NOT gate on B.
   • Feed that and input C into an XOR gate.
   • The XOR output now represents (NOT B XOR C).

4. NOT A AND (NOT B XOR C)

   • Feed the output from the NOT gate on A into one input of an AND gate.
   • Feed the output from the XOR gate into the other input of the AND gate.
   • The AND output now represents NOT A AND (NOT B XOR C).

5. NOT (...)

   • Because the whole expression is negated, pass the AND output through a final NOT gate.
   • Label the final output X.

So the completed circuit is:

This matches the intended logic exactly.

Key Takeaways

• Translate Boolean expressions into circuits by working from the innermost brackets outward.
• Each NOT on a single variable needs its own inverter on that input.
• Intermediate sub-expressions such as (NOT B XOR C) become separate gate outputs that feed later gates.
• A NOT around the entire expression means invert only at the very end.

Common Mistakes

• Putting the final NOT on A or B instead of on the whole expression.
• Feeding B directly into the XOR gate instead of NOT B.
• Using OR instead of XOR.
• Connecting NOT A directly to the final NOT gate and skipping the AND stage.
• Ignoring the bracket structure and drawing gates in the wrong order.

Things to Be Careful About

• NOT A and NOT B are separate operations, so they need separate NOT gates.
• The XOR gate must take NOT B and C, not A and B.
• The AND gate must combine exactly two intermediate results: NOT A and (NOT B XOR C).
• The final output X is the inversion of the AND result, so the last gate must be a NOT gate.
• Some mark schemes also accept the last two gates drawn as a single NAND gate, because NOT (P AND Q) is equivalent to P NAND Q.

Background Concept

An embedded system is a computer system built into a larger device to carry out a specific purpose. Unlike a general-purpose computer, it is not designed to run many unrelated applications. It usually has a processor, memory and input/output components, but these are all dedicated to one job. Embedded systems often operate automatically, respond to sensors, and have limited user interfaces.

Understanding the Question

The question describes a video doorbell that detects motion, records video, sends messages to a smartphone and plays a doorbell sound when the button is pressed. You are being asked for two features that make this device look like an embedded system.

The key clue is that the doorbell is not acting like a full general-purpose computer. It is a specialist device designed for a narrow set of tasks.

Approach

Think of the standard characteristics of embedded systems and match them to the doorbell. Good answers are features such as:

• it has a specific purpose
• it is built into another device
• it operates automatically
• it has limited user interaction

Any two valid characteristics that clearly fit the scenario would gain the marks.

Step-by-Step Reasoning

The doorbell does not let the user install many different programs or use it for unrelated tasks like word processing or gaming. That tells us it is not general-purpose. Instead, it is dedicated to a small set of functions: detecting motion, recording, storing and transmitting alerts.

Also, the computer components are inside the doorbell unit itself. That means the computer system is embedded within the device rather than existing as a separate standalone computer.

A further sign is that it works automatically. When motion is detected, recording starts without the user having to control each step manually. Automatic reaction to inputs is typical of embedded devices.

So two strong characteristics are:

• dedicated to a specific task
• built into another device and operating automatically

Key Takeaways

• An embedded system is designed for a specific job.
• It is usually built into a larger product.
• Automatic operation in response to inputs is a common sign of an embedded system.

Common Mistakes

• Saying only that it is "electronic" or "uses a sensor". That alone does not prove it is embedded.
• Describing what the device does without linking it to an embedded-system characteristic.
• Giving features of a general-purpose computer instead.

Things to Be Careful About

Use characteristics, not just examples. For instance, "it records video" is weaker on its own than "it performs a specific dedicated function". Make sure each point clearly explains why the doorbell fits the idea of an embedded system.

Background Concept

A monitoring system uses sensors to collect data about conditions and then reports, displays or stores that data. A control system also uses sensors, but it goes further by automatically changing something in the physical environment through an actuator. Control systems often use feedback to keep a condition within limits.

Examples:

• Monitoring: burglar alarm, weather station, heart-rate monitor
• Control: central heating, traffic lights, automatic greenhouse watering

Understanding the Question

You must decide whether the video doorbell is a monitoring system or a control system, then justify that decision. The device detects motion, records video and sends messages to a smartphone.

The important detail is what happens after the sensor is triggered. Does the system merely report/store information, or does it physically change the environment by driving an actuator?

Approach

Check for the three key parts of a control system:

• sensor input
• processing
• actuator output that changes something physical

The doorbell clearly has sensor input and processing. The deciding issue is whether it has an actuator carrying out automatic control. In this scenario it records and sends alerts, which is monitoring behaviour.

Step-by-Step Reasoning

The motion sensor detects that someone is near the door. That is the sensing stage.

The doorbell then starts recording and sends a message to a smartphone. These actions collect and communicate information. They do not change the outside world in the way a control system would.

A true control system would do something like unlock a door, switch on lights or move a mechanism through an actuator. None of that is described here.

Therefore the correct classification is a monitoring system. The justification is that the system senses and reports/stores data but does not use an actuator to control physical conditions.

Key Takeaways

• Monitoring systems gather and report data.
• Control systems gather data and then act on the environment.
• The presence or absence of an actuator is often the clearest difference.

Common Mistakes

• Calling it a control system just because it reacts to an input. Reacting is not enough; there must be physical control of something.
• Forgetting the justification and giving only the label.
• Confusing sending an alert with controlling the environment.

Things to Be Careful About

Mention both sides of the distinction if possible: it uses a sensor and reports information, but it does not use an actuator to change conditions. That makes the justification complete and precise.

Background Concept

Sampling is the process of measuring an analogue sound wave at regular time intervals so it can be stored digitally. The sampling rate is the number of samples taken per second, measured in hertz. A higher sampling rate means the system captures more detail from the original sound wave.

In general:

• higher sampling rate -> better sound quality
• higher sampling rate -> larger file size
• larger file size -> more storage, bandwidth and processing demands

Understanding the Question

The microphone's sampling rate changes from 44.1 kHz to 88.2 kHz. You need to describe how that affects the performance of the video doorbell.

The wording is important: it is not asking only about sound quality. It asks about performance, so you should consider both benefits and costs.

Approach

First compare the two values. 88.2 kHz is double 44.1 kHz. Then apply the standard effects of increasing sampling rate:

• more samples per second
• more accurate sound capture
• more data to store, process and transmit

Step-by-Step Reasoning

At 44.1 kHz, the microphone records 44 100 samples every second. At 88.2 kHz, it records 88 200 samples every second. So the number of samples per second doubles.

Because the system measures the sound wave more often, the digital version is a closer representation of the original sound. That improves audio quality.

However, every extra sample is extra data. Doubling the sampling rate means the audio part of the recording becomes larger if the sample resolution and number of channels stay the same.

For the doorbell, that means:

• more primary memory or buffer use while recording
• more secondary storage used by each video
• the storage fills sooner
• more data must be transmitted to the smartphone
• the processor may have more work handling the extra audio data

So the performance effect is a trade-off: better sound quality but greater use of resources.

Key Takeaways

• Increasing sampling rate improves the accuracy of digital sound.
• Higher quality comes at the cost of larger files.
• Bigger files affect storage, transmission speed and processing demand.

Common Mistakes

• Saying only that the sound gets louder. Sampling rate affects detail, not loudness.
• Mentioning file size but not quality, or quality but not file size.
• Forgetting that the rate doubled, so the amount of audio data also increases significantly.

Things to Be Careful About

Do not confuse sampling rate with bit depth. Sampling rate is how often samples are taken; bit depth is how many bits are used per sample. This question is only about the effect of changing sampling rate.

Background Concept

A translator converts source code written by a programmer into a form the computer can run. Two common translators are a compiler and an interpreter.

An interpreter translates and executes the program one statement at a time. This means translation and execution happen together as the program runs. If an error is reached, execution stops at that point.

A compiler translates the whole source program before execution. The output is usually object code or an executable file. If there are errors, they are reported after compilation, and the program usually cannot run until the errors are fixed and the program is compiled again.

For debugging, the key idea is how quickly the programmer can locate an error and test a correction.

Understanding the Question

The question says the developer is still writing the program and chooses an interpreter because it is easier for debugging. You are asked for one reason why debugging is easier with an interpreter than with a compiler.

So this is not asking for a list of general differences. It wants a debugging-focused explanation. The most direct point is that the interpreter works line by line and stops as soon as it finds an error, making the location of the problem easier to identify.

Approach

Use a direct comparison:

1. State how an interpreter works.
2. Link that behaviour to debugging.
3. Make the advantage explicit by mentioning immediate error location or avoiding recompiling the whole program.

That gives a full explanation rather than just a definition.

Step-by-Step Reasoning

A good answer begins with the interpreter's behaviour:

• It translates one line or statement at a time.
• It executes each line immediately after translating it.

Now connect that to debugging:

• If an error occurs, the interpreter stops at the line containing the error, or at least very close to where the error is detected.
• Because the programmer gets feedback immediately during the run, it is easier to identify which part of the code caused the problem.

Then complete the explanation by contrasting with compilation:

• With a compiler, the programmer typically compiles the whole program first.
• After changes, the whole program must be compiled again before testing.
• That makes the edit-test cycle slower during development.

The question asks for one reason, so the cleanest answer is the immediate line-by-line error identification point.

Key Takeaways

• An interpreter is useful during development because it gives immediate feedback.
• Debugging is easier when errors can be traced to a specific line as the program runs.
• A compiler is less convenient during debugging because the whole program usually needs recompiling after changes.

Common Mistakes

• Saying only that an interpreter is "faster" for debugging. That is too vague and may be inaccurate unless you explain the faster edit-test cycle.
• Giving a general definition of interpreter and compiler without linking it to debugging.
• Saying a compiler executes line by line. It does not; it translates the whole program first.
• Mixing up translation and execution, for example claiming the interpreter creates an executable file.

Things to Be Careful About

• The question asks for one reason, so one explained point is enough if it is complete.
• Make sure the answer includes why debugging is easier, not just how an interpreter works.
• Use the correct contrast: interpreter = line by line and immediate feedback; compiler = whole program translation first.
• Do not drift into advantages for finished software, because that belongs to part (b), not part (a).

Background Concept

A compiler translates an entire source program into machine code, or into code that can be linked to form an executable file. An executable file is a file the computer can run directly.

An interpreter does not usually create a separate executable file. Instead, it reads the source code and translates it as the program runs. That means the source program, and usually the interpreter itself, are needed each time the program is executed.

When software is complete and ready for customers, the priorities change. Debugging convenience matters less, and distribution, ease of use, performance, and protection of the original source code become more important.

Understanding the Question

The question says the program is finished and ready to be sold. The developer now uses a compiler because it creates an executable file. You must explain why the need for an executable makes the compiler the correct choice.

This wording is important: it is not just asking for any advantage of a compiler. The answer should focus on why a finished program that will be given to customers benefits from being compiled into an executable.

Approach

Build the answer around the executable file:

1. State that the compiler creates the executable.
2. Explain the customer benefit: they can run the program directly.
3. Add why this matters for completed software: no repeated translation each run, and no need to distribute the source code.

These points directly connect the executable file to real-world software distribution.

Step-by-Step Reasoning

First, identify what the compiler provides:

• A compiler translates the whole completed program.
• The output is an executable file.

Now explain why that matters when selling software:

• The customer receives a ready-to-run program.
• They do not need the original source code in order to use it.
• They also do not need an interpreter to translate the code every time they want to run it.

Next, explain the practical advantage of that:

• Since translation has already been done, the executable can be run directly.
• This is more convenient for customers because installation and use are simpler.
• It is also more efficient for repeated use because the program does not need to be retranslated on each execution.

A further linked reason is protection:

• If only the executable is distributed, the developer does not have to give customers the source code.
• This helps protect the program from being easily copied or altered.

For a 3-mark answer, the strongest three linked points are:

• compiler creates executable,
• customer runs it directly without interpreter/source,
• no need for translation each time, so it suits finished software.

Key Takeaways

• A compiler is preferred for finished software because it creates an executable file.
• Executables are easier to distribute to end users than source code.
• Compiled programs can be run repeatedly without retranslation.
• Releasing an executable also helps keep the source code private.

Common Mistakes

• Saying only "a compiler is faster" without explaining that the executable runs without being translated each time.
• Repeating the debugging advantage of an interpreter from part (a). That does not answer this part.
• Saying customers need the compiler to run the executable. They do not; the whole point is that the executable runs directly.
• Confusing source code with executable code.
• Writing that an interpreter creates an executable file. It normally does not.

Things to Be Careful About

• Link every point to the phrase "create an executable file" because that is the focus of the question.
• Keep the context in mind: the program is complete and being sold, so think about customer use rather than development.
• Do not overstate the point as "completely impossible" to distribute interpreted code; the exam wants the normal textbook comparison that compiled executables are more appropriate.
• A strong answer explains both what the compiler does and why that matters for end users.

Background Concept

This question is about tracing simple assembly-language instructions and, especially, understanding addressing modes.

The accumulator (ACC) is the main working register. Most load, add and subtract instructions change the value in ACC.

The index register (IX) is used with indexed addressing. Instead of using the address written in the instruction directly, the processor adds that address to the current value in IX to form the real memory address.

The important addressing modes here are:

• Immediate addressing: the operand is the actual value. Example: LDM #5 puts 5 into ACC.
• Direct addressing: the operand is a memory address. Example: LDD 20 loads the contents of address 20.
• Indirect addressing: the operand is an address containing another address. Example: LDI 25 means look in address 25 first, then use that second address.
• Indexed addressing: add the operand address to IX, then use the result as the memory address.

When tracing assembly, always ask: "Is this number a value, or is it an address?" That is what usually decides the mark.

Understanding the Question

You are given:

• a small instruction set
• the current contents of some memory addresses
• the starting values of ACC and IX
• four short programs

You must work out the final content of ACC after each program runs.

The key skill is reading each instruction correctly:

• LDD means direct load from memory
• LDI means indirect load through a pointer address
• LDX means indexed load using IX
• LDM means load a literal value straight into ACC
• ADD and SUB change ACC
• INC ACC adds 1 to ACC

The wording "complete the table by writing the content of the ACC after each program has run" means only the final accumulator value is needed for each row.

Approach

For each program:

1. Start from the given register values.
2. Read the first instruction and update ACC or IX if needed.
3. Continue instruction by instruction in order.
4. For any memory access, check the table carefully.
5. For indirect or indexed addressing, calculate the effective address before loading.
6. Record the final value left in ACC.

A good tracing habit is to write one short line per instruction, showing what ACC becomes after that instruction.

Step-by-Step Reasoning

Program 1: LDD 20 then ADD #2

• LDD 20 uses direct addressing.
• Address 20 contains 2.
• So ACC becomes 2.
• ADD #2 uses immediate addressing, so add the literal value 2.
• 2 + 2 = 4.

Final ACC = 4.

Program 2: LDX 22

• LDX uses indexed addressing.
• The instruction gives base address 22.
• IX = 1.
• Effective address = 22 + 1 = 23.
• Address 23 contains 5.
• So ACC becomes 5.

Final ACC = 5.

Program 3: LDI 25, INC ACC, SUB 22

• LDI 25 uses indirect addressing.
• First look at address 25.
• Address 25 contains 22.
• Now use address 22.
• Address 22 contains 3.
• So ACC becomes 3.
• INC ACC adds 1, so ACC = 4.
• SUB 22 uses direct addressing, so subtract contents of address 22.
• Address 22 contains 3.
• 4 - 3 = 1.

Final ACC = 1.

Program 4: LDD 19, LDM #5, LDM #25

• LDD 19 loads contents of address 19.
• Address 19 contains 24, so ACC = 24.
• LDM #5 loads the literal value 5, replacing the old value. Now ACC = 5.
• LDM #25 again loads a literal value, replacing the old value. Now ACC = 25.

Final ACC = 25.

So the completed results are:

• Program 1: 4
• Program 2: 5
• Program 3: 1
• Program 4: 25

Key Takeaways

• Immediate addressing uses the value itself.
• Direct addressing uses the contents of the stated address.
• Indirect addressing means one extra memory lookup.
• Indexed addressing means add IX to the address first.
• Load instructions replace the current value in ACC; they do not add to it.

Common Mistakes

• Treating LDM #25 as "load contents of address 25". It does not; it loads the literal value 25.
• Doing indirect addressing in one step only. For LDI 25, you must look up address 25, then use that result as another address.
• Forgetting to add IX for indexed addressing.
• Subtracting the address number instead of the contents of the address. SUB 22 means subtract the value stored in address 22, not subtract 22.
• Thinking earlier LDM or LDD values still matter after a later load. Each new load overwrites ACC.

Things to Be Careful About

• Read the symbol in the operand carefully: # means immediate denary value.
• Keep direct and indirect addressing separate in your mind.
• In indexed addressing, add the address and IX first, then read memory.
• The question asks for the final ACC value only, not every intermediate value.
• Even when a program starts with an existing ACC, a later load instruction may completely replace it, so do not carry forward old values unnecessarily.

Background Concept

This question is about bitwise operations on binary values stored in the accumulator.

A bitwise operation compares corresponding bits in two binary numbers:

• AND gives 1 only if both bits are 1.
• OR gives 1 if at least one bit is 1.
• XOR gives 1 if the bits are different.

Useful reminders:

• x AND 1 = x
• x AND 0 = 0
• x OR 0 = x
• x OR 1 = 1
• x XOR 0 = x
• x XOR 1 flips the bit

These operations are often used for masking, setting bits, clearing bits, and toggling bits.

Understanding the Question

You are given:

• the bit manipulation instructions AND, XOR and OR
• memory contents at addresses 30 to 34
• the starting accumulator value 10011010

The important sentence is: "The binary number 10011010 is reloaded into the ACC before each program is run."

That means each of the three programs starts from exactly the same accumulator value. You must not carry the answer from one row into the next row.

You then find the result of each bitwise operation and write the final binary content of ACC.

Approach

For each row:

1. Start with ACC = 10011010.
2. Work out the second operand.
   • If it is an address, look up the contents at that address.
   • If it is denary, convert it to binary first.
   • If it is already binary, use it directly.
3. Perform the bitwise operation column by column from left to right.
4. Write the resulting 8-bit binary value.

Step-by-Step Reasoning

Program 1: AND 31

• This uses the contents of address 31.
• Address 31 contains 11111111.
• So calculate:

10011010 AND 11111111

Because AND with 1 leaves each bit unchanged, every bit stays the same.

Bit by bit:

• 1 AND 1 = 1
• 0 AND 1 = 0
• 0 AND 1 = 0
• 1 AND 1 = 1
• 1 AND 1 = 1
• 0 AND 1 = 0
• 1 AND 1 = 1
• 0 AND 1 = 0

Result: 10011010

Program 2: XOR B01001111

• The second operand is already given in binary: 01001111.
• So calculate:

10011010 XOR 01001111

Bit by bit, XOR gives 1 when the bits are different:

• 1 XOR 0 = 1
• 0 XOR 1 = 1
• 0 XOR 0 = 0
• 1 XOR 0 = 1
• 1 XOR 1 = 0
• 0 XOR 1 = 1
• 1 XOR 1 = 0
• 0 XOR 1 = 1

Result: 11010101

Program 3: OR #30

• #30 is denary 30, so convert it to 8-bit binary.
• 30 in binary is 11110.
• As an 8-bit value this is 00011110.

Now calculate:

10011010 OR 00011110

Bit by bit, OR gives 1 if either bit is 1:

• 1 OR 0 = 1
• 0 OR 0 = 0
• 0 OR 0 = 0
• 1 OR 1 = 1
• 1 OR 1 = 1
• 0 OR 1 = 1
• 1 OR 1 = 1
• 0 OR 0 = 0

Result: 10011110

So the completed table entries are:

• Program 1: 10011010
• Program 2: 11010101
• Program 3: 10011110

Key Takeaways

• Bitwise operations compare matching bit positions.
• AND with all 1s leaves a binary value unchanged.
• XOR highlights differences and can flip bits.
• OR can force bits to 1.
• When an operand is given in denary, convert it to binary before doing the bitwise operation.

Common Mistakes

• Forgetting that ACC is reloaded before each program. That would make rows 2 and 3 wrong.
• Using the address number itself instead of the contents at that address. AND 31 means use the bits stored in address 31.
• Converting 30 incorrectly to binary, or not padding it to 8 bits.
• Confusing OR and XOR: OR gives 1 when either bit is 1, while XOR gives 1 only when the bits differ.
• Dropping leading zeros. The question expects full 8-bit results.

Things to Be Careful About

• Keep all values aligned as 8-bit binary numbers.
• Read the operand format carefully: B... is binary, #... is denary, and a plain address means read from memory.
• Write results bit by bit rather than trying to do the whole byte mentally if you are unsure.
• Preserve the bit order exactly from leftmost bit to rightmost bit.
• Do not mix arithmetic addition with bitwise OR or XOR; these are logical bit operations, not ordinary number addition.

Background Concept

A client-server model is a network model in which different computers have different roles.

• A client is the device used by the end user. It requests services or data.
• A server is a computer that provides those services or data.

The key idea is that the data and processing are usually centralised on the server, while the client gives the user a way to interact with that service. In banking, this is very important because the bank wants one central, controlled place for customer records rather than copies of the data stored on many customer devices.

Understanding the Question

The question gives a banking app downloaded onto a smartphone and tells you this is a client-server model. It asks for the roles of the different devices.

So you need to identify:

• what the customer device does
• what the bank’s server does
• how they interact

This is not asking for general network features such as speed or topology. It is specifically about the job of each side in the model.

Approach

A good way to answer is to separate the system into two devices:

1. Client device: what the user has and what it does.
2. Server: what the bank has and what it does.

Then link them with the flow of data:

• client sends request
• server processes request
• server returns result

For full marks, include both storage/processing on the server and the user interface/request role on the client.

Step-by-Step Reasoning

The smartphone or similar device is the client because it is the device the customer uses directly. It runs the banking app, displays screens, accepts input such as login details or transfer requests, and sends those requests across the network.

The bank’s central computer system is the server. It is responsible for holding the account database and the software or services that deal with banking operations. When a request arrives, the server checks what the customer is allowed to do, processes the request, reads or updates the stored data, and sends back the response.

For example:

• a customer opens the app and requests their balance
• the client sends that request to the server
• the server finds the correct account details in the database
• the server sends the balance back
• the client displays it on screen

A strong answer usually mentions that the server can also deal with many different clients at once, because many customers may access the service simultaneously.

Key Takeaways

• In a client-server system, the client requests and the server provides.
• The client usually handles the interface for the user.
• The server usually handles central storage, processing and control.
• Banking systems use client-server because the bank needs centralised, secure data management.

Common Mistakes

• Saying the client stores the main customer database. In this model, the bank’s central server stores the authoritative data.
• Describing only one side, for example only the smartphone. The question asks for the roles of the different devices.
• Confusing client-server with peer-to-peer. In peer-to-peer, devices act more equally; here the bank server has the central service role.
• Giving vague points such as “they communicate” without explaining what each device actually does.

Things to Be Careful About

• Use the terms client and server correctly.
• Make sure you mention both requesting and responding.
• Include at least one clear server role such as stores data, processes requests, or authenticates users.
• Keep the answer focused on device roles, not unrelated security features unless they support the server’s role.

Background Concept

Parity checking is a verification method used when data is transmitted. Its purpose is to help detect whether a bit may have changed during transfer.

There are two common parity choices:

• even parity: the total number of 1s, including the parity bit, should be even
• odd parity: the total number of 1s, including the parity bit, should be odd

A parity bit is an extra bit added to a group of data bits. The receiver counts the 1s again. If the total does not match the agreed parity, an error is detected.

A stronger form is parity block check, where several units are arranged like rows in a grid and an extra set of parity bits is added for the columns as well. This can detect more errors than checking each unit separately.

Understanding the Question

This question gives you a partly written description and asks you to complete the missing technical terms.

The clues are:

• “agree on whether to use ... parity” points to odd or even
• “if ... has an even number of 1s, a parity bit of 1 is appended” means the chosen parity must be odd
• “bytes are grouped together, for example in a grid” points to parity block check
• “transmitted with the data as a parity ...” refers to the extra row of parity bits, a parity byte

Approach

Treat each blank separately and use the wording around it as a clue.

1. First identify the possible parity choices.
2. Then decide which parity type fits the rule given about appending a 1 when there is already an even number of 1s.
3. Recognise that grouping bytes into a grid is block parity.
4. Name the extra transmitted group of parity bits.

Step-by-Step Reasoning

The first blank is the general choice of parity. Before transmission, the two computers must agree whether they are using odd parity or even parity, so the phrase is odd or even.

The second blank asks what the data is divided into. In standard exam wording for parity at this level, the data is divided into bytes for checking.

The third blank is decided from the rule:

• if the group has an even number of 1s
• and a parity bit of 1 is added

then the total number of 1s becomes odd. So the agreed parity must be odd.

The fourth blank refers to a “parity ... check” where the bytes are placed in a grid and each column is checked. That is a parity block check.

The last blank asks what the set of column parity bits is called. Because those bits form an extra byte sent with the data, it is a parity byte.

So the completed terms are:

• odd or even
• bytes
• odd
• block
• byte

Key Takeaways

• Odd parity means the total number of 1s should be odd.
• Even parity means the total number of 1s should be even.
• A single parity bit helps detect some transmission errors.
• Parity block check adds another layer by checking columns as well as individual units.

Common Mistakes

• Writing even for the third blank. If a group already has an even number of 1s and you add 1, the total becomes odd, not even.
• Confusing validation with verification. Parity check verifies that transferred data has not changed; it does not check whether the data is sensible.
• Saying parity check corrects all errors. It mainly helps detect errors and is limited.
• Mixing up parity bit and parity byte. A parity bit is added to one group; a parity byte is the extra set of column parity bits in block parity.

Things to Be Careful About

• Read the condition carefully: “even number of 1s” plus “append 1” is the key clue for odd parity.
• Use the exact technical phrase parity block check.
• Remember that parity is about counting 1s, not counting all bits.
• In exam questions like this, one wrong blank does not automatically make the others wrong, so solve each clue independently.

Background Concept

A database is in Third Normal Form (3NF) when data is organised so that:

• each table stores data about one entity or relationship
• each record can be uniquely identified by a primary key
• there are no repeating groups
• non-key attributes depend on the key, the whole key, and nothing but the key

In practice, this means you split the data into sensible tables and avoid duplication. If two entities have a many-to-many relationship, you normally create a linking table between them. In this question, a user can complete many quizzes, and each quiz can be completed by many users, so that relationship needs a separate table.

A good database design also chooses suitable fields:

• Username can identify a user because it must be unique.
• DateOfBirth is better than storing age, because age changes over time.
• quiz information should be stored once per quiz.
• the score belongs to the relationship between a particular user and a particular quiz.

Understanding the Question

The question describes a website where:

• users create accounts
• each user has a unique username
• each user enters an email address
• users must be over 16
• a new quiz is available each day
• each quiz has a file name and a playable date
• each user gets a score for each quiz completed
• users are given a rating such as Gold

You are asked to create exactly three tables, normalised to 3NF, and write them in the format TableName(PrimaryKey, Field1, Field2, ...).

The important clue is that there are really three different kinds of data here:

• data about users
• data about quizzes
• data about a user's result on a quiz

That naturally leads to three tables.

Approach

Start by identifying the entities:

1. USER for account details.
2. QUIZ for quiz details.
3. a linking table for which user completed which quiz and what score they got.

Then choose keys:

• Username is suitable as the primary key for users because it must be unique.
• QuizID is a simple primary key for quizzes.
• the linking table needs both the user and the quiz to identify one result, so a composite key of (Username, QuizID) is appropriate.

Finally, place each attribute where it belongs:

• user details in USER
• quiz details in QUIZ
• Score in the linking table because it depends on both the user and the quiz

Step-by-Step Reasoning

USER(Username, EmailAddress, DateOfBirth, Rating)

• Username is the primary key because usernames must be unique.
• EmailAddress belongs here because it is a property of the user.
• DateOfBirth should be stored instead of age. The requirement is that all users must be over 16, but age is calculated from date of birth and changes with time.
• Rating is a property of the user.

QUIZ(QuizID, FileName, PlayDate)

• each quiz needs its own record
• QuizID is used as the primary key
• FileName is stored because each quiz is in its own text file
• PlayDate is stored because the database stores the date the quiz can be played

USERQUIZ(Username, QuizID, Score)

• this table links users to quizzes
• one user can appear many times, once for different quizzes
• one quiz can appear many times, once for different users
• Score belongs here because it is the score for one specific user on one specific quiz
• the natural primary key is the combination of Username and QuizID

Why this is 3NF:

• user details are not repeated in every score record
• quiz details are not repeated in every score record
• score depends on the whole composite key in USERQUIZ
• there are no partial dependencies such as storing EmailAddress or FileName in the linking table

Foreign keys are needed so that the relationship works correctly:

• USERQUIZ.Username refers to USER.Username
• USERQUIZ.QuizID refers to QUIZ.QuizID

Key Takeaways

• Use separate tables for separate entities.
• Resolve a many-to-many relationship with a linking table.
• Store DateOfBirth rather than age.
• Put attributes in the table where they depend on that table's key.
• In 3NF, avoid repeating data and avoid attributes depending on only part of a composite key.

Common Mistakes

• Storing everything in one large table. This causes duplication and is not properly normalised.
• Storing Age instead of DateOfBirth. Age changes and should normally be calculated.
• Putting Score in USER or QUIZ. A score is not just about the user or just about the quiz; it is about both together.
• Missing the linking table. Since users and quizzes have a many-to-many relationship, a separate table is needed.
• Forgetting primary keys or foreign keys. The relationships must be identifiable and enforceable.

Things to Be Careful About

• If you use Username as the primary key, it must be unique.
• If you use a composite key in the linking table, make sure Score depends on both parts of that key.
• Keep the table design in the requested format.
• Validation rules such as "valid email" and "over 16" are important, but they do not necessarily mean extra tables are required.
• A different valid 3NF design could use surrogate keys such as UserID; what matters is that the design is correctly normalised and the relationships are clear.

Background Concept

A Database Management System (DBMS) provides tools to create, maintain and manage a database. As part of this, it keeps information not only about the data itself, but also about how the database is structured.

Two important terms are:

• data dictionary: metadata about the database
• logical schema: the logical design of the database

Metadata means "data about data". For example, the DBMS needs to know a field's name, data type, size, whether it is a primary key, and what validation rules apply.

The logical schema is the planned structure of the database. It describes what tables exist and how they relate, without talking about where the files are physically stored on disk.

Understanding the Question

You are asked to describe what two DBMS features mean:

• data dictionary
• logical schema

This is not asking for examples from the quiz database in part (a), although you can think of that database while answering. It wants short, accurate descriptions of the terms themselves.

Approach

For each term:

1. state what it is
2. say what kind of information it contains or shows
3. make the distinction clear

The key difference is:

• the data dictionary stores detailed metadata entries
• the logical schema shows the overall logical organisation of the database

Step-by-Step Reasoning

For data dictionary:

• the phrase means a collection of metadata
• metadata describes the structure of the database rather than the actual user records
• good points to include are field names, data types, sizes, keys, validation and relationships

So a strong description is that it is a store of metadata about the database structure.

For logical schema:

• this is the blueprint of the database at the logical level
• it shows the tables and the relationships between them
• it includes items such as fields, primary keys and foreign keys
• it does not describe the physical storage details

So a strong description is that it is the logical structure of the database, independent of physical implementation.

Key Takeaways

• A data dictionary stores metadata.
• Metadata includes technical details about fields and tables.
• A logical schema shows how the database is organised logically.
• Logical design is different from physical storage.

Common Mistakes

• Saying the data dictionary stores the actual records. It stores metadata, not the user data itself.
• Describing the logical schema as the physical file layout. That would be physical design, not logical schema.
• Giving vague answers such as "it helps the database work" without saying what information it contains.

Things to Be Careful About

• Use the term metadata correctly.
• Mention enough detail to show understanding, for example keys, data types or relationships.
• Make sure your logical schema answer refers to logical structure, not storage devices or file locations.
• In exam questions that say "describe", give a little more than a one-word definition.

Background Concept

A network topology is the physical or logical arrangement of devices and connections in a network.

The three topologies in this question have standard features:

• Bus topology: all devices share one main cable (the backbone). Because they share the same transmission medium, collisions are more likely.
• Star topology: each device connects to one central device, usually a switch or hub.
• Mesh topology: devices are connected by multiple links, so there can be several possible routes between devices. This gives high fault tolerance.

The key exam skill is to recognise the defining feature of each topology from a short description.

Understanding the Question

You are given five statements, and for each one you must decide which topology or topologies it describes.

The wording gives clues:

• central device points to star
• central cable points to bus
• multiple paths points to mesh
• line fails but network still works fully points to mesh
• collisions strongly points to bus

Because the question says "one or more boxes", you should consider whether a statement could apply to more than one topology. In this set, each statement matches one topology clearly.

Approach

For each row:

1. Identify the key phrase.
2. Recall which topology is known for that feature.
3. Tick only the topology that matches that description.

A good way to think about it is to compare the defining structure:

• one shared cable -> bus
• one central connecting device -> star
• many interconnections / alternative routes -> mesh

Step-by-Step Reasoning

1. all devices connect to one central device

   • In a star network, every device has its own connection to a central switch or hub.
   • So this is Star.

2. all devices connect to a central cable

   • In a bus network, every device is attached to one main backbone cable.
   • So this is Bus.

3. multiple paths for the packets to travel along

   • Mesh networks have redundant connections.
   • This means packets can often take different routes.
   • So this is Mesh.

4. robust against damage because if any line fails, the rest of the network retains full functionality

   • This describes fault tolerance caused by redundancy.
   • In a mesh network, one failed link does not stop communication because other paths exist.
   • So this is Mesh.

5. most likely to lose data through collisions

   • Collisions happen when devices try to send on the same shared medium at the same time.
   • A bus topology uses one shared cable, so it is the most associated with collisions.
   • So this is Bus.

Key Takeaways

• Bus = one backbone cable, shared medium, collisions more likely.
• Star = one central device.
• Mesh = many links, multiple routes, strong fault tolerance.
• In topology questions, the wording usually points to one defining feature.

Common Mistakes

• Confusing central device with central cable. A device means star; a cable means bus.
• Ticking star for the fault-tolerance statement. Star is easier to manage, but if the central device fails, the whole network can fail.
• Forgetting that collisions are mainly a problem where devices share the same transmission path, which is typical of bus networks.

Things to Be Careful About

• Read each phrase exactly: "device" and "cable" are not interchangeable.
• "Retains full functionality" is stronger than simply "still partly works"; that points to mesh because of alternative paths.
• Since the instruction says "one or more boxes", always consider multiple answers, but only tick extra boxes when the statement genuinely applies.