Computer Science 9618/31 — May/June 2025

Background Concept

An enumerated data type is a user-defined type whose values are limited to a fixed list of named items. It is a non-composite user-defined type because it stores one value chosen from a set, rather than several fields grouped together.

This is useful when only certain values are valid. Instead of storing any random string, the program can restrict the variable to one of the allowed taxi codes. That improves validation and makes the program design clearer.

Understanding the Question

The question gives six taxi identity codes:

• M100
• M230
• T101
• T102
• T120
• T150

It asks for a pseudocode statement to declare an enumerated type called Vehicle that can hold only those codes.

So the task is not to declare a variable. It is to declare the type itself.

Approach

For an enumeration, the normal approach is:

1. write the type name
2. write the complete list of permitted values
3. separate the values clearly inside brackets

The important idea is that every valid taxi code must appear in the declaration, and no extra values should be invented.

Step-by-Step Reasoning

We need a type called Vehicle.

Because the taxi can only be one of a small fixed set of codes, an enumerated type is appropriate.

The declaration therefore names the type and lists the allowed values:

TYPE Vehicle = (M100, M230, T101, T102, T120, T150)

This means any data item of type Vehicle can only take one of those six values.

Key Takeaways

• Use an enumerated type when the allowed values come from a fixed known list.
• An enumeration is a non-composite user-defined type.
• The declaration must include all allowed values exactly as given.

Common Mistakes

• Declaring a variable instead of a type: for example, writing something like DECLARE Taxi : Vehicle does not answer the question.
• Missing one of the taxi codes: an incomplete list means the type does not match the given data.
• Changing the codes: for example, writing m100 instead of M100 may lose marks because the values should match exactly.
• Using STRING instead of an enumeration: that does not create the required user-defined enumerated type.

Things to Be Careful About

• The type name must be Vehicle.
• The values should be written exactly as supplied in the question.
• This is a type declaration, not an assignment.
• Keep to pseudocode style rather than using syntax from a specific programming language.

Background Concept

A composite user-defined type groups several related data items into one structure. Instead of storing each booking detail separately, the program can store them together as one Booking record.

This is useful because all the information about one booking belongs together. A composite type makes data easier to organise, pass around, and process.

When designing a composite type, each field should use the most appropriate data type:

• STRING for text or mixed letters and numbers
• DATE for calendar dates
• an enumerated type when only a fixed set of values is allowed

Understanding the Question

The question asks for pseudocode statements to declare a composite data type called Booking.

The booking must contain:

• booking number
• destination
• client name
• client telephone number
• date of departure
• address for pick-up
• taxi identity code

The question also specifically says to use the enumerated type from part (a), so the field storing the taxi code should be of type Vehicle.

Approach

The best way to answer is to define a type called Booking and then declare one field for each piece of required data.

For each field, choose the most suitable type:

• booking number: STRING, because it may contain letters and numbers
• destination: STRING
• client name: STRING
• client telephone number: STRING, because telephone numbers are not used in arithmetic and may contain leading zeroes
• date of departure: DATE
• pick-up address: STRING
• taxi used: Vehicle

Then place all of these inside the composite type declaration.

Step-by-Step Reasoning

We start by naming the composite type Booking:

TYPE Booking

Now add each field.

BookingNumber must allow a combination of letters and numbers, so it should be a STRING:

DECLARE BookingNumber : STRING

Destination is text, so STRING is suitable:

DECLARE Destination : STRING

ClientName is also text:

DECLARE ClientName : STRING

ClientTelephoneNumber should be STRING, not INTEGER, because telephone numbers can begin with zero and are identifiers rather than numbers for calculation:

DECLARE ClientTelephoneNumber : STRING

DateOfDeparture is best stored as a DATE:

DECLARE DateOfDeparture : DATE

PickupAddress is text, so use STRING:

DECLARE PickupAddress : STRING

Finally, the taxi identity code must use the enumerated type from part (a), so the field type is Vehicle:

DECLARE TaxiUsed : Vehicle

Then close the type:

ENDTYPE

Putting it all together gives:

TYPE Booking
   DECLARE BookingNumber : STRING
   DECLARE Destination : STRING
   DECLARE ClientName : STRING
   DECLARE ClientTelephoneNumber : STRING
   DECLARE DateOfDeparture : DATE
   DECLARE PickupAddress : STRING
   DECLARE TaxiUsed : Vehicle
ENDTYPE

Key Takeaways

• A composite type groups several related fields into one structured item.
• Choose each field type based on the kind of data it stores.
• Use STRING for values like phone numbers and booking references when arithmetic is not needed.
• Reusing an enumerated type inside a composite type is good design because it restricts values to valid options.

Common Mistakes

• Using INTEGER for telephone number: this is poor design because leading zeroes could be lost.
• Using STRING for the taxi code instead of Vehicle: the question specifically asks to use the enumerated type from part (a).
• Missing one of the required fields: every listed item must appear in the composite type.
• Confusing the type name with a variable name: Booking is the type being declared, not one booking record instance.
• Putting the taxi codes directly into this type instead of referencing Vehicle: that repeats data already defined in part (a).

Things to Be Careful About

• Match the required type name exactly: Booking.
• Ensure there are seven fields, one for each data item listed.
• Keep field types sensible: especially STRING for booking number and telephone number.
• Use the previously declared enumerated type exactly as Vehicle.
• Stay in pseudocode format and do not switch to syntax from Python, Java, or SQL.

Background Concept

In binary floating-point representation, a number is stored as a mantissa and an exponent.

• The mantissa stores the significant bits of the number.
• The exponent tells you how far the binary point has been moved.
• In this question, both fields use two's complement.

For Cambridge 9618 floating-point questions of this type, the binary point is assumed to be immediately after the sign bit of the mantissa. A normalised mantissa must begin:

• 01 for a positive number
• 10 for a negative number

That means the first two bits must be different. This makes the mantissa as large as possible in magnitude without changing the value of the number.

Understanding the Question

You are given a positive binary fraction:

0.00000011010111

You must write it in the computer's floating-point format using:

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

Because the number is already in binary, the main job is to:

1. normalise it
2. find the exponent
3. write both fields using the exact number of bits required

Approach

For a positive number, normalise by moving the binary point until the mantissa starts 01....

Then:

• count how many places the point moved
• if the point moved to the right, the exponent is negative
• if the point moved to the left, the exponent is positive
• write the exponent in 6-bit two's complement
• pad the mantissa with trailing zeros if needed so it fills all 10 bits

Step-by-Step Reasoning

Start with:

0.00000011010111

To normalise a positive number, we want the mantissa to begin 01.

Move the binary point 6 places to the right:

0.11010111 × 2^-6

Why is the exponent -6? Because moving the point right makes the mantissa bigger, so the exponent must be negative to keep the overall value unchanged.

Now write the mantissa.

The normalised mantissa is 0.11010111.
Since the mantissa field has 10 bits in total, and the sign bit is included, we need 10 stored bits:

0110101110

That is:

• sign bit 0
• fractional part 110101110

Now write the exponent.

Exponent = -6

First write +6 in 6 bits:

000110

Convert to two's complement:

• invert: 111001
• add 1: 111010

So the exponent field is:

111010

Therefore the final floating-point representation is:

• Mantissa: 0110101110
• Exponent: 111010

Key Takeaways

• In this format, a normalised positive mantissa starts 01.
• The exponent records how many places the binary point moved.
• Moving the binary point right gives a negative exponent.
• Always pad the mantissa to the full required bit length.
• Two's complement must be used for the exponent because the question states that both fields use it.

Common Mistakes

• Using the wrong normalised form: for a positive number, the mantissa should not begin 00 or 11; it should begin 01.
• Getting the exponent sign wrong: moving the point right means a negative exponent, not positive.
• Forgetting the fixed field size: the mantissa must be exactly 10 bits and the exponent exactly 6 bits.
• Using sign-magnitude for the exponent: the exponent must be in two's complement.

Things to Be Careful About

• Count the point shifts carefully; one extra or one missing shift changes the exponent.
• Do not include an explicit binary point in the stored bit pattern unless the question asks for it; the point position is implied.
• When padding the mantissa, add zeros on the right, not the left.
• Check that the exponent uses 6 bits exactly: -6 must be 111010, not a shorter form.

Background Concept

A binary floating-point number stores a value as:

mantissa × 2^exponent

In this question:

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

The mantissa is normalised when the first two bits are different:

• 01 for positive values
• 10 for negative values

This rule matters because the mantissa itself is stored in two's complement, not as a separate sign bit with magnitude.

You also need to convert the denary fraction correctly. Binary fractions use place values:

• 1/2 = 0.1
• 1/4 = 0.01
• 1/8 = 0.001
• 1/16 = 0.0001

and so on.

Understanding the Question

You must convert -25.3125 into this floating-point system and show the working.

That means:

1. convert the denary number to binary
2. normalise it
3. fit the mantissa into 10 bits
4. fit the exponent into 6 bits
5. make sure the negative mantissa is stored in two's complement

The question is testing several linked skills at once, not just one binary conversion.

Approach

A reliable method is:

1. Convert the whole number part and fractional part separately.
2. Combine them into one binary number.
3. Write the normalised floating-point form.
4. Write the positive normalised mantissa first.
5. Since the number is negative, convert that mantissa into two's complement.
6. Write the exponent in 6-bit two's complement.

Because the exponent here is positive, its two's complement form is just the ordinary 6-bit binary value.

Step-by-Step Reasoning

First convert 25.3125 to binary.

1. Convert the integer part

25 in binary is:

11001

because:

16 + 8 + 1 = 25

2. Convert the fractional part

0.3125 equals:

0.25 + 0.0625

which is:

1/4 + 1/16

So in binary:

0.3125 = 0.0101

3. Combine them

Therefore:

25.3125 = 11001.0101

So:

-25.3125 = -11001.0101

4. Normalise the value

To normalise, move the binary point left 5 places so the positive magnitude becomes:

0.110010101 × 2^5

So the negative number is:

-0.110010101 × 2^5

The exponent is +5 because we moved the binary point left 5 places.

5. Write the mantissa

The positive normalised mantissa is:

0110010101

This is already 10 bits long:

• sign bit 0
• fractional bits 110010101

But the original number is negative, so the mantissa must be stored as a negative two's complement value.

Take two's complement of 0110010101:

• invert -> 1001101010
• add 1 -> 1001101011

So the stored mantissa is:

1001101011

Notice that it begins 10, which is exactly what we expect for a normalised negative mantissa.

6. Write the exponent

Exponent = +5

In 6-bit binary:

000101

Since it is positive, this is also its 6-bit two's complement form.

So the final representation is:

• Mantissa: 1001101011
• Exponent: 000101

Key Takeaways

• Convert the integer and fraction separately when changing denary to binary.
• A normalised floating-point value is written as mantissa × 2^exponent.
• In two's complement floating-point, a normalised negative mantissa begins 10.
• A positive exponent is written as ordinary binary, provided it fits in the field size.
• For a negative number, do not just put a 1 at the front of the mantissa; you must use full two's complement.

Common Mistakes

• Converting 0.3125 incorrectly: it is 0.0101, not 0.101.
• Using the wrong exponent: 11001.0101 becomes 0.110010101 × 2^5, so the exponent is 5, not 4 or -5.
• Using sign-magnitude for the mantissa: writing something like 1110010101 would be wrong because the mantissa must be in two's complement.
• Forgetting to normalise: 11001.0101 is not in the required stored mantissa form.
• Not checking field widths: the mantissa must be 10 bits and the exponent 6 bits.

Things to Be Careful About

• Keep the mantissa and exponent roles separate: the mantissa stores the significant bits, the exponent stores the shift.
• When finding the negative mantissa, start from the positive 10-bit version and then take two's complement carefully.
• Do not lose bits when normalising; every significant binary digit matters.
• Check that the final negative mantissa still satisfies the normalisation rule for two's complement floating-point, starting 10.
• For positive exponents in two's complement, do not unnecessarily invert or add 1; +5 is simply 000101 in 6 bits.

Background Concept

The TCP/IP protocol suite is organised into layers. Each layer has a particular job and offers services to the layer above it. This layered approach makes communication easier to design, because each layer can focus on one part of the process.

The Application Layer is the layer closest to the user. It contains the protocols that applications use to communicate over a network, such as HTTP for web pages, SMTP for email and FTP for file transfer. Its purpose is to make network communication available to application software.

The Transport Layer sits below the Application Layer. Its job is to provide communication from one end device to another end device. It takes data from the Application Layer and manages how that data is transported. Important transport functions include splitting data into smaller units, numbering them, checking for errors, controlling the rate of transfer and making sure the data reaches the correct application through port numbers.

Understanding the Question

This question asks for the purpose of two TCP/IP layers, not just their names or examples of protocols. So the answer must explain what each layer is for.

For the Application Layer, you need to say that it supports application software using network services.

For the Transport Layer, you need to say that it handles end-to-end delivery of data, including how it is split up and managed during transfer.

A good answer separates the two clearly and avoids mixing their jobs together.

Approach

The best approach is:

1. Name what the layer is responsible for.
2. Add one or two key functions that show that purpose.
3. Keep the Application Layer and Transport Layer distinct.

For Application Layer, think: user applications, network services, communication rules.

For Transport Layer, think: end-to-end delivery, segmentation, ports, sequencing, reliability.

Step-by-Step Reasoning

For the Application Layer:

• This is the layer used by software such as browsers, email clients and file transfer programs.
• It does not physically move the data itself; instead, it provides the protocols and rules that let applications communicate.
• So the purpose is to allow application programs to use network services.
• A strong description mentions that it defines the rules for services such as web access, email and file transfer.

For the Transport Layer:

• Once the application produces data, that data must be delivered from one device to another.
• The Transport Layer manages this end-to-end delivery.
• It may break large data into smaller segments or packets so that it can be transmitted efficiently.
• It uses port numbers so that, when data arrives, it can be passed to the correct application on the destination device.
• It may also provide reliability features such as sequencing the segments, checking for errors, acknowledging receipt and retransmitting missing data.

So the complete description should show that the Transport Layer is not just about moving data, but about managing the communication between applications running on different computers.

Key Takeaways

• The Application Layer provides network services to application software.
• The Transport Layer provides end-to-end delivery between devices and applications.
• Transport functions commonly include segmentation, port addressing, sequencing and reliability.
• In layered protocols, each layer has a specific role and passes work to adjacent layers.

Common Mistakes

• Saying the Application Layer is where the user types data. That is too vague; the key point is that it provides network services and protocols for applications.
• Confusing the Transport Layer with the Internet Layer. The Transport Layer handles end-to-end delivery, while the Internet Layer deals with addressing and routing between networks.
• Listing protocol names only, such as HTTP or TCP, without describing the purpose of the layer.
• Saying the Transport Layer sends signals across cables. That is the job of lower layers, not the Transport Layer.

Things to Be Careful About

• The question asks for the purpose of each layer, so focus on function, not just examples.
• Keep the two layers separate; do not describe routing under the Transport Layer.
• If you mention reliability, make clear it is part of transport management, not the only purpose of the layer.
• Use accurate terminology such as end-to-end communication, segments/packets, and port numbers where appropriate.

Background Concept

In packet switching, a complete message is not sent as one continuous block. Instead, it is broken into smaller pieces called packets. This is the main method used on the internet.

Each packet usually contains:

• the actual data
• a destination address
• often a source address
• a sequence number so packets can be put back in order
• error-checking information

Routers read the packet headers and decide where to send each packet next. Because the internet is a packet-switched network, there is no need to reserve one fixed path for the whole message.

Understanding the Question

The question asks you to describe packet switching as a method of transmitting messages across the internet. That means you should explain the process from start to finish:

• how the message begins
• what happens to it during transmission
• how routers are involved
• what happens when the packets arrive

This is not asking for a comparison with circuit switching, so the focus should stay on how packet switching works.

Approach

A clear way to answer is to describe the stages in order:

1. Split the message into packets.
2. Add addressing and control information to each packet.
3. Send packets across the network.
4. Explain that routers can send packets by different routes.
5. Reassemble the packets at the destination.

That sequence matches how packet switching actually works and usually covers all marking points.

Step-by-Step Reasoning

• First, the original message is too large or inconvenient to send as one unit, so it is divided into smaller packets.
• Each packet needs more than just data. It also needs header information so the network knows where it is going and how it fits into the original message.
• The destination address tells routers where the packet should eventually go.
• A sequence number allows the receiving device to rebuild the message in the correct order.
• As the packets travel through the internet, routers examine the header of each one.
• A router chooses the next hop for that packet based on routing information and current network conditions.
• Because packets are handled separately, packet 1 and packet 2 do not have to follow the same path.
• This means some packets may arrive earlier than others, and they may arrive out of order.
• At the destination, the receiving device collects the packets, checks their sequence numbers and reassembles the original message.
• If a packet is lost or damaged, protocols can arrange for it to be retransmitted.

That is the essential description of packet switching on the internet.

Key Takeaways

• Packet switching sends data in small units called packets.
• Each packet carries both data and control information.
• Routers forward packets independently across the network.
• Different packets can take different routes.
• The destination reorders and reassembles the packets into the original message.

Common Mistakes

• Saying that all packets always follow the same route. In packet switching, they may take different routes.
• Forgetting to mention the header information such as destination address or sequence number.
• Confusing packet switching with circuit switching by saying a dedicated path is reserved first.
• Not explaining what happens at the destination after the packets arrive.

Things to Be Careful About

• Mention that packets are transmitted independently.
• Include the role of routers, since they are central to packet switching.
• Make clear that packets may arrive out of order.
• If you mention retransmission, treat it as something that happens when packets are lost or corrupted, not as the main definition of packet switching.

Background Concept

A binary tree stores each item in a node. In this question, each node has three fields:

• a left pointer
• the data value
• a right pointer

Because the list is described as ordered, the tree is being used as a binary search tree. That means:

• values smaller than a node go into its left subtree
• values larger than a node go into its right subtree

To insert a new value, start at the root and compare:

• if the new value is smaller, move left
• if the new value is larger, move right
• keep doing this until you reach a null pointer
• place the new node there

A null pointer means there is no child in that position. In this question, null is shown by -1.

Understanding the Question

You are given part of an existing tree:

• root node 36
• 36 has left child 12 and right child 40
• 12 has left child 3
• the left pointer of 3 is already shown as -1

You must add the integers 6, 15, 41, and 66 in that order, then complete the whole binary tree, including the missing -1 null pointers.

So this is not just about placing the four values. You must also show every empty left or right child pointer as -1.

Approach

Use the standard binary-search-tree insertion method for each new value:

1. Start at the root.
2. Compare the new value with the current node.
3. Move left if smaller, right if larger.
4. Stop when the required child pointer is null.
5. Insert the new node there.
6. After all insertions, fill every missing child pointer with -1.

The key idea is that the insertion order matters. Each new value is inserted into the tree produced by the previous insertions.

Step-by-Step Reasoning

Start with the given tree.

• Root is 36.
• Left child of 36 is 12.
• Right child of 36 is 40.
• Left child of 12 is 3.

Now insert 6.

• Compare 6 with 36: 6 < 36, so go left to 12.
• Compare 6 with 12: 6 < 12, so go left to 3.
• Compare 6 with 3: 6 > 3, so go right.
• The right pointer of 3 is empty, so insert 6 as the right child of 3.

Now insert 15.

• Compare 15 with 36: 15 < 36, so go left to 12.
• Compare 15 with 12: 15 > 12, so go right.
• The right pointer of 12 is empty, so insert 15 as the right child of 12.

Now insert 41.

• Compare 41 with 36: 41 > 36, so go right to 40.
• Compare 41 with 40: 41 > 40, so go right.
• The right pointer of 40 is empty, so insert 41 as the right child of 40.

Now insert 66.

• Compare 66 with 36: 66 > 36, so go right to 40.
• Compare 66 with 40: 66 > 40, so go right to 41.
• Compare 66 with 41: 66 > 41, so go right.
• The right pointer of 41 is empty, so insert 66 as the right child of 41.

Now complete all null pointers:

• 3 already has left pointer -1.
• 3 has right child 6, so only 6 needs both pointers as -1.
• 15 has no children, so left -1, right -1.
• 40 has no left child, so left pointer -1.
• 41 has no left child, so left pointer -1.
• 66 has no children, so left -1, right -1.

So the finished structure is exactly the tree shown here:

Key Takeaways

• A binary search tree places smaller values to the left and larger values to the right.
• Values are inserted one at a time by following comparisons from the root.
• The order of insertion affects the final shape of the tree.
• In pointer diagrams, every missing child must still be shown using the null value, here -1.

Common Mistakes

• Putting 6 as the left child of 3. This is wrong because 6 is greater than 3, so it must go to the right.
• Putting 15 under 40. This ignores the first comparison with 36; since 15 < 36, it must stay in the left subtree.
• Putting 66 directly under 40. You must continue comparing until the first null pointer is reached; 66 must go right of 41.
• Forgetting the null pointers. The question explicitly says to include them, so missing -1 values loses marks.

Things to Be Careful About

• Use the tree already formed after each insertion before placing the next value.
• Follow the comparison path all the way from the root each time.
• Make sure each node has both a left pointer and a right pointer accounted for, even when one or both are null.
• Do not confuse a general binary tree with a binary search tree here; the word ordered tells you the data must follow search-tree ordering.

Background Concept

Recursion is a programming technique where a procedure or function solves a problem by calling itself. Each call usually works on a smaller or simpler version of the same problem.

A recursive algorithm must have:

• a recursive call, where it calls itself
• a base case, where it stops calling itself

Without a base case, the calls would continue indefinitely and eventually cause a runtime failure such as stack overflow.

Recursion is often useful for problems that are naturally defined in terms of smaller versions of themselves, such as:

• traversing trees
• processing linked lists
• mathematical definitions like factorial

Understanding the Question

The question asks you to describe what recursion means. This is a theory definition question, so you do not need code or an example unless it helps your wording.

For full marks, the answer needs the two essential ideas:

• a routine calls itself
• there is some condition that ends the repeated calls

Approach

Give a short description with the two marking points:

1. mention self-calling
2. mention the stopping condition or base case

That is enough for a concise full-mark answer.

Step-by-Step Reasoning

The phrase procedure or function calls itself is the core definition.

However, that alone is not a complete description, because recursion only works correctly if there is a point where the self-calling stops. That point is called the base case.

So the full idea is:

• a routine calls itself
• each call moves toward a simpler case
• once the base case is reached, the recursion stops

In an exam answer worth 2 marks, the first and last of those points are usually the ones being rewarded.

Key Takeaways

• Recursion means self-calling.
• A recursive algorithm must have a base case.
• Recursive solutions are common for self-similar structures such as trees.

Common Mistakes

• Saying recursion is just repetition. Repetition could also describe iteration with loops, so that is too vague.
• Describing a loop instead of a self-calling routine. Recursion uses function or procedure calls, not just FOR or WHILE.
• Forgetting to mention the stopping condition. That usually loses one of the marks.

Things to Be Careful About

• Use the word itself clearly, so the examiner can see you mean self-calling.
• Mention base case, stopping condition, or termination condition explicitly.
• Do not confuse recursion with iteration; they can solve similar problems, but they are different techniques.

Background Concept

An Abstract Data Type (ADT) is a logical model of a data structure, defined by the operations it supports rather than by one specific implementation. Examples include stacks, queues, lists, trees, and graphs.

Some ADTs are especially suitable for recursive algorithms because their structure is naturally recursive. For example, a linked list can be viewed as:

• one node
• followed by the rest of the linked list

That self-similar structure makes recursive processing possible.

Understanding the Question

The question already gives binary tree as one ADT that can be implemented using recursive algorithms. You must name one different ADT.

You do not need to explain it here, just identify one valid example.

Approach

Think of ADTs whose structure can be broken into a smaller version of the same structure. A linked list is a strong choice because each node points to the remainder of the list, so recursive traversal is straightforward.

Step-by-Step Reasoning

A linked list is a valid answer because recursive algorithms can process it node by node:

• process the current node
• then call the same algorithm on the next node
• stop when the pointer is null

That makes it an appropriate ADT to name here.

Other ADTs may also be accepted in some contexts, but linked list is a clear and standard answer.

Key Takeaways

• An ADT describes what operations are supported, not just how data is stored.
• Recursive algorithms work well on self-similar structures.
• Linked lists are a common example of an ADT that can be processed recursively.

Common Mistakes

• Giving binary tree again. The question asks for one other ADT.
• Naming something that is not really an ADT, such as a programming language feature.
• Choosing an example with no clear recursive structure when a clearer answer was available.

Things to Be Careful About

• Read one other carefully; it must be different from binary tree.
• Give the name of the ADT, not an operation such as insert or search.
• Keep the answer brief for a 1-mark identify question.

Background Concept

A sum-of-products (SOP) expression is a Boolean expression made by OR-ing together several product terms. Each product term is an AND combination of all input variables, with a variable written complemented if its value is 0 in that row and uncomplemented if its value is 1.

For a truth table:

• look only at the rows where the output is 1
• write one product term for each such row
• OR all those terms together

This gives the canonical sum-of-products form, sometimes called the sum of minterms.

Using prime notation:

• A' means NOT A
• B' means NOT B
• and so on

Understanding the Question

You are given a complete truth table for inputs A, B, C and D, and output Z. Part (a) asks for the Boolean expression that exactly matches the table in sum-of-products form.

So the task is not to simplify yet. It is simply to find every row where Z = 1 and convert each of those rows into a product term.

From the table, Z = 1 for these input combinations:

• 0000
• 0101
• 0111
• 1000
• 1101
• 1111

Each of those becomes one term.

Approach

Use the standard minterm method:

1. Scan the truth table.
2. Keep only rows where Z = 1.
3. For each such row:
   • write the variable unchanged if its bit is 1
   • write the variable with a prime if its bit is 0
4. Join all terms with +, which means OR.

Because the question specifically says sum-of-products, this direct method is the safest and most exam-appropriate approach.

Step-by-Step Reasoning

Take each row with output 1.

1. Row A=0, B=0, C=0, D=0

   • A becomes A'
   • B becomes B'
   • C becomes C'
   • D becomes D'
   • term: A'B'C'D'

2. Row A=0, B=1, C=0, D=1

   • A becomes A'
   • B stays B
   • C becomes C'
   • D stays D
   • term: A'BC'D

3. Row A=0, B=1, C=1, D=1

   • A becomes A'
   • B stays B
   • C stays C
   • D stays D
   • term: A'BCD

4. Row A=1, B=0, C=0, D=0

   • A stays A
   • B becomes B'
   • C becomes C'
   • D becomes D'
   • term: AB'C'D'

5. Row A=1, B=1, C=0, D=1

   • A stays A
   • B stays B
   • C becomes C'
   • D stays D
   • term: ABC'D

6. Row A=1, B=1, C=1, D=1

   • A stays A
   • B stays B
   • C stays C
   • D stays D
   • term: ABCD

Now OR all six terms together:

Z = A'B'C'D' + A'BC'D + A'BCD + AB'C'D' + ABC'D + ABCD

That is the full canonical SOP expression.

Key Takeaways

• In canonical SOP, use only rows where output = 1.
• A 0 in the row gives a complemented variable.
• A 1 in the row gives an uncomplemented variable.
• Join all product terms with OR.

Common Mistakes

• Using rows where Z = 0 instead of Z = 1. That would give a product-of-sums style approach, not SOP.
• Missing one of the 1-rows. That makes the expression incomplete.
• Forgetting to complement variables that have value 0.
• Trying to simplify in part (a). The question asks for sum-of-products from the table, so the unsimplified canonical form is required.

Things to Be Careful About

• Check every row carefully; one missed 1 changes the whole answer.
• Keep the variables in a consistent order: A, then B, then C, then D.
• Do not mix prime notation incorrectly, for example writing B instead of B' when the row value is 0.
• Save simplification for the K-map parts, not this part.

Background Concept

A syntax diagram shows the valid structure of strings in a grammar. You follow the arrows from left to right. If there are branches, you choose one valid route. If there is a loop, that part may be repeated according to how the arrows reconnect.

In this question:

• uppercase can be one of A, C, E, G, J
• lowercase can be one of b, d, f, h, k
• symbol can be one of $, @, #, &, %
• digit can be one of 0 to 9

For passcode, the diagram shows:

1. the first character must be uppercase
2. after that, the next character must be one of lowercase, symbol or digit
3. that choice can then repeat, so more characters of those three types may follow
4. no more uppercase characters are allowed after the first one

Understanding the Question

You are given two example passcodes and asked why each one is invalid. That means you do not need to rewrite the whole rule; you only need to identify the exact point where each string breaks the syntax diagram.

The key thing to inherit from the parent diagram is the structure of passcode: one starting uppercase character, followed by one or more characters that are lowercase letters, symbols or digits.

Approach

Take each passcode from left to right and compare it with the diagram:

• first, check whether the first character is a valid uppercase
• then check whether every later character is from the allowed sets: lowercase, symbol or digit
• as soon as one character breaks the rule, that gives the reason it is invalid

Step-by-Step Reasoning

For #Jd7:

• The first character is #.
• The syntax diagram says a passcode must begin with uppercase.
• # is not one of A, C, E, G, J.
• In fact, # belongs to the symbol set.
• So the string is invalid immediately at the first character.

For C%6A:

• The first character is C.
• C is in the uppercase set, so the start is valid.
• The next characters % and 6 are also valid because they are a symbol and a digit.
• The last character is A.
• After the first character, the diagram only allows lowercase, symbol or digit.
• A is an uppercase character, so it is not allowed in that position.
• Therefore the string is invalid because it contains an uppercase character after the first character.

Key Takeaways

• Read syntax diagrams from left to right.
• The first part of a diagram often fixes the first character or token very precisely.
• A loop means repetition of the section it returns to.
• To test validity, compare each character position with the part of the grammar that applies there.

Common Mistakes

• Saying #Jd7 is invalid because of J. The string is already invalid at #, so that is the clearest reason.
• Missing that C%6A starts correctly. The problem is not the C; it is the final A.
• Assuming any uppercase or lowercase letter is allowed. Only the letters shown in the individual syntax diagrams are valid.
• Forgetting that the loop in passcode repeats only lowercase, symbol or digit, not uppercase.

Things to Be Careful About

• Use the named sets exactly as defined by the diagrams.
• Do not treat J and A the same: J is in the given uppercase set, but A is only allowed as the first character of a passcode.
• The question asks why each passcode is invalid, so give one precise grammar-based reason for each string.

Background Concept

Backus-Naur Form (BNF) is a way of writing grammar rules textually. It describes how valid strings can be formed.

Important ideas:

• A non-terminal is written in angle brackets, for example <passcode>.
• A terminal is an actual symbol or character that can appear in the final string, for example A or #.
• ::= means “is defined as”.
• | means “or”.
• Repetition in a syntax diagram is usually represented in BNF by recursion.

A syntax diagram and BNF are two different notations for the same grammar. So the task is to translate the picture into the formal text version.

Understanding the Question

You are asked to complete the BNF for two non-terminals:

• <uppercase>
• <passcode>

From the diagrams:

• <uppercase> is simply one choice from five uppercase letters.
• <passcode> must begin with <uppercase>, then have at least one further character chosen from <lowercase>, <symbol> or <digit>, and that second stage can repeat.

The key challenge is the loop in the passcode diagram. In BNF, a loop is not shown with arrows, so you must recreate it using recursive rules.

Approach

Translate each diagram systematically.

For <uppercase>:

• it is just an OR-list of the five terminals shown

For <passcode>:

• first identify the base cases: an uppercase followed by exactly one allowed following character
• then add recursive cases to show that more allowed following characters can be appended
• make sure recursion only adds lowercase, symbol or digit, so no extra uppercase can appear after the first character

Step-by-Step Reasoning

Start with <uppercase>.

The diagram has five parallel choices:

• A
• C
• E
• G
• J

So the BNF is:

<uppercase> ::= A | C | E | G | J

Now consider <passcode>.

The diagram says:

1. start with <uppercase>
2. then choose one of <lowercase>, <symbol> or <digit>
3. then you may loop and choose one of those again

So first write the shortest valid passcodes. These are the base forms:

<uppercase><lowercase>
<uppercase><symbol>
<uppercase><digit>

These represent passcodes of length 2.

Next, represent the repetition. The loop means that after forming a valid <passcode>, you may add another:

• <lowercase>
• or <symbol>
• or <digit>

So the recursive forms are:

<passcode><lowercase>
<passcode><symbol>
<passcode><digit>

Putting base cases and recursive cases together gives:

<passcode> ::= <uppercase><lowercase>
             | <uppercase><symbol>
             | <uppercase><digit>
             | <passcode><lowercase>
             | <passcode><symbol>
             | <passcode><digit>

Why this works:

• it guarantees the first character came from <uppercase>
• it guarantees every later character is from <lowercase>, <symbol> or <digit>
• it allows any number of later characters, because recursion can keep extending the passcode

For example, to form C%6:

• start with <passcode> ::= <uppercase><symbol> to get C%
• then use <passcode> ::= <passcode><digit> to append 6

So the grammar matches the diagram correctly.

Key Takeaways

• Parallel branches in a syntax diagram become | alternatives in BNF.
• A loop in a syntax diagram usually becomes recursion in BNF.
• Base cases are needed so the recursion can stop.
• Good BNF preserves the exact restrictions of the original diagram, not just the general idea.

Common Mistakes

• Writing only <passcode> ::= <uppercase><lowercase> | <symbol> | <digit>. This is wrong because it does not keep the full sequence structure.
• Allowing <uppercase> to repeat later in the passcode. The diagram does not allow that.
• Forgetting the base cases and writing only recursive rules. Then the grammar has no way to generate a complete string.
• Using a form like <uppercase><lowercase><passcode> without thinking carefully. That would insert another uppercase later when <passcode> expands, which breaks the diagram.

Things to Be Careful About

• Keep non-terminals in angle brackets exactly, such as <uppercase> and <passcode>.
• Use | for alternatives and ::= for definition.
• Make sure the recursive rule extends an already valid <passcode> with one extra allowed character.
• The diagram implies at least one character after the initial uppercase, so your BNF must not allow a one-character passcode.

Background Concept

Multi-tasking is an operating system feature that allows several processes to make progress during the same overall period of time. On a single processor, this does not usually mean they all execute at the exact same instant. Instead, the OS rapidly switches the CPU from one process to another. This is called context switching, and it gives the user the impression that tasks are running simultaneously.

This matters for process management because the OS must decide which process is ready to run, which is waiting for input/output, and when to suspend one process and resume another. Good process management keeps the CPU busy and prevents the whole system from appearing to freeze while one process is waiting.

Understanding the Question

This part asks for two things:

1. what multi-tasking means
2. how it helps process management

So a full answer needs both the definition and the benefit. A definition alone would not be enough. The phrase "how it benefits process management" is asking you to connect the idea of multiple tasks with the OS's job of scheduling and controlling processes.

Approach

A good approach is:

• define multi-tasking as several processes sharing processor time
• mention that the switching is controlled by the operating system
• explain the benefit: if one process is waiting, another can use the CPU

That gives a clear link between the concept and the management advantage.

Step-by-Step Reasoning

First, identify the key idea behind multi-tasking: more than one process can be active during the same period.

Second, make the definition accurate. In exam wording, it is best to say that the processor time is shared between processes, or that the OS switches between processes quickly. This is better than just saying "many things happen at once", because on one CPU they are usually interleaved rather than truly simultaneous.

Third, explain the benefit to process management. Many processes spend time waiting for input/output, disk access, network data, or user input. If the OS can run another ready process during that wait, the CPU does not sit idle.

So the benefit is not just "it is faster" in a vague sense. The real process-management benefit is:

• better CPU utilisation
• smoother running of several processes
• improved responsiveness because ready tasks do not have to wait for one blocked task to finish completely

That is why the answer links multi-tasking with switching to another ready process when one cannot continue.

Key Takeaways

• Multi-tasking means multiple processes share CPU time.
• On a single processor, this is achieved by rapid switching, not true simultaneous execution.
• Its main benefit is better management of ready and waiting processes, leading to better CPU use and responsiveness.

Common Mistakes

• Saying multi-tasking means multiple users on one system. That is multi-user operation, not the definition of multi-tasking.
• Saying processes run "at the same time" without explaining time-sharing. That is incomplete on a single-CPU system.
• Giving a general benefit such as "it is efficient" without linking it to process management, scheduling, or CPU usage.

Things to Be Careful About

• Use the word process or task consistently; in this syllabus context, the OS is managing processes.
• Make sure you describe the OS sharing or switching CPU time.
• The benefit should be specifically about management of processes, such as improved utilisation or responsiveness, not an unrelated benefit like increased storage space.

Background Concept

A scheduling routine is the rule an operating system uses to decide which ready process gets the CPU next. Shortest remaining time (SRT), also called shortest remaining time first, is a pre-emptive scheduling algorithm.

"Pre-emptive" means the OS is allowed to stop a running process before it finishes and give the CPU to another process. In SRT, the decision is based on how much CPU time each ready process still needs. The process with the shortest remaining execution time is chosen.

This is different from a non-pre-emptive method such as shortest job first, where the chosen process keeps the CPU until it finishes or blocks.

Understanding the Question

This question asks for two separate parts:

1. the function of the shortest remaining time scheduling routine
2. one benefit of using it

The word "function" means you must explain what the algorithm actually does, not just name it. So you should mention:

• it compares remaining times
• it chooses the process with the smallest remaining time
• it can interrupt the current process if a shorter one becomes ready

Then you need one clear benefit. A common accepted benefit is reduced average waiting time or turnaround time, especially for short tasks.

Approach

To answer this well:

• begin by stating the selection rule: shortest remaining time left
• add the important feature that it is pre-emptive
• then give one practical advantage such as faster completion of short jobs or lower average waiting time

This structure matches the wording of the question exactly.

Step-by-Step Reasoning

Start with the function.

Suppose several processes are in the ready queue. The scheduler examines how much processing time each still requires. It chooses the one with the least remaining time.

Now include the key SRT feature: pre-emption. Imagine one process is currently running, but a new process arrives that needs even less time than the current process still has left. Under shortest remaining time scheduling, the OS interrupts the current process, saves its state, and switches the CPU to the new shorter process.

That is why the phrase "remaining time" matters. The decision is not based on original job length alone. It is based on how much time is still needed from this point onward.

Then state the benefit. Because short processes are favoured, they usually finish quickly instead of sitting behind long jobs. This tends to reduce average waiting time and average turnaround time across the set of jobs. It can also improve responsiveness, because short interactive tasks get service sooner.

A strong exam answer therefore includes both the selection rule and the pre-emption rule, then one explicit benefit.

Key Takeaways

• Shortest remaining time is a pre-emptive scheduling algorithm.
• The ready process with the least CPU time left is chosen.
• If a shorter process arrives, the current process can be interrupted.
• A major benefit is lower average waiting or turnaround time, especially for short jobs.

Common Mistakes

• Describing shortest job first instead of shortest remaining time. SJF may be non-pre-emptive; SRT must include interruption of the running process when appropriate.
• Saying it chooses the process that arrived first. That describes FCFS, not SRT.
• Giving only a benefit without explaining the function, or only the function without a benefit.
• Saying simply "it is faster" without saying what is improved, such as waiting time, turnaround time, or response time.

Things to Be Careful About

• Use the word remaining, not just shortest, because the current amount of time left is what matters.
• Mention that it is pre-emptive if you are explaining the function fully.
• A valid benefit should be specific and scheduling-related, such as reduced average waiting time.
• Do not confuse waiting time with execution time: the scheduler affects when a process gets CPU access, not the actual amount of work the process itself must perform.

Background Concept

SSL (Secure Sockets Layer) and TLS (Transport Layer Security) are protocols used to secure communication over a network, especially between a client and a server. TLS is the newer, more secure development of SSL, but exam questions often mention them together as SSL/TLS.

The main idea is that when data travels across the internet, it may pass through many devices and networks. Without protection, that data could be read, altered or sent to the wrong party. SSL/TLS helps prevent this by providing security services for the connection.

The key functions usually credited in exam answers are:

• Encryption: data is converted into a form that cannot be understood by someone who intercepts it.
• Authentication: confirms that the server, and sometimes the client, is genuine.
• Integrity: helps detect whether data has been changed in transit.

For a two-mark "state two functions" question, any two valid functions are usually enough.

Understanding the Question

This part asks for two functions of SSL/TLS, not examples of where it is used. So the answer should describe what the protocols do, not where they are found.

The safest response is to name two well-known security roles of SSL/TLS, such as:

• encrypting transmitted data
• authenticating the communicating parties

These are the clearest, most standard marking points.

Approach

A good strategy is to think of the main security goals for communication:

1. Keep the message secret.
2. Make sure it is the real server or user.
3. Make sure the message was not altered.

Then choose any two of these that SSL/TLS provides. Since the question only needs two, keep each point short and exact.

Step-by-Step Reasoning

The first valid function is encryption.

• SSL/TLS encrypts the data sent over the connection.
• That means if someone captures the packets, they should not be able to read the contents.
• This protects confidential information such as passwords, account details and personal data.

The second valid function is authentication.

• SSL/TLS uses certificates and keys so that a client can check it is communicating with the genuine server.
• In some cases it can also authenticate the client.
• This reduces the risk of connecting to an impostor system.

A third valid idea, though not needed if two marks are available, is integrity.

• SSL/TLS can detect whether the data has been tampered with during transmission.

Because the question asks for two functions, the clean full-mark answer is to state encryption and authentication.

Key Takeaways

• SSL/TLS is used to secure data in transit.
• Its main roles are encryption, authentication and integrity checking.
• For short theory questions, give direct functions, not long descriptions.

Common Mistakes

• Giving examples of use instead of functions, such as "online banking". That answers part (b), not part (a).
• Saying only "it makes the internet safe". This is too vague.
• Naming just one function and then repeating it in different words.
• Confusing SSL/TLS with antivirus or firewall software. SSL/TLS secures communications, not the whole computer.

Things to Be Careful About

• The question says state two, so two separate points are needed.
• Use precise wording such as encrypts data and authenticates the server/client.
• Do not drift into setup details like handshakes unless they directly support the function you are stating.
• Keep the answer at protocol level: what it does for the connection.

Background Concept

SSL/TLS is appropriate whenever data sent between two systems needs protection while it is travelling across a network. The classic case is client-server communication over the internet.

If the data is sensitive, valuable or private, then using SSL/TLS is important because it can:

• hide the data from eavesdroppers through encryption
• verify the identity of the server
• help detect tampering with the transmitted data

In practice, this is often seen in secure web connections such as HTTPS, but the idea is broader than just websites.

Understanding the Question

This part asks for two examples of situations where SSL/TLS would be appropriate. So unlike part (a), this is asking for real-life contexts or applications, not technical functions.

The examiner wants places where confidential or important information is exchanged over a network. Strong examples are online banking and online shopping/payment systems.

Approach

Think of situations where someone sends data that should not be exposed or altered, for example:

• passwords
• bank details
• card details
• personal information

Then name two common activities where this happens. The best answers are familiar, clearly network-based, and obviously security-sensitive.

Step-by-Step Reasoning

A first strong example is online banking.

• A user logs in to a bank website or app.
• Account information and login credentials are sent across the network.
• This must be protected from interception and impersonation.
• Therefore SSL/TLS is appropriate.

A second strong example is e-commerce or online shopping.

• A user signs in, enters personal details, and submits card or payment information.
• This data is confidential and financially important.
• SSL/TLS helps secure the connection while it is transmitted.

Other valid examples could include secure email access, logging in to websites, submitting confidential forms, or any HTTPS-based service involving sensitive data. But for a two-mark question, two clear examples are enough.

Key Takeaways

• Use SSL/TLS wherever sensitive data is transmitted over a network.
• Good examples usually involve login details, personal data or payment information.
• In application questions, give concrete situations rather than technical definitions.

Common Mistakes

• Repeating the functions from part (a), such as "encryption" or "authentication", instead of giving situations.
• Giving something too vague like "the internet" or "websites" without saying what kind of use.
• Naming situations that do not obviously involve network communication.
• Giving two answers that are really the same example written differently.

Things to Be Careful About

• The question asks for examples of situations, so make them specific enough, such as online banking rather than just banking.
• Choose scenarios where the need for secure transmission is obvious.
• Avoid examples that focus on stored data security rather than data in transit.
• Two distinct examples are needed for full marks.

Background Concept

In AI, a graph is a data structure used to represent relationships between items. A graph is made up of:

• nodes (vertices), which represent things such as states, locations, situations or possible solutions
• edges, which represent the connections or allowed moves between those nodes

Sometimes edges also have weights, which represent a cost, distance or time. AI systems often use graphs when they need to search through many possibilities to reach a goal.

This is common in problems such as route finding, game playing, puzzle solving and planning. The AI can move from node to node along edges and evaluate which route gives the best outcome.

Understanding the Question

The question asks for the purpose of a graph in an AI system. So it is not asking for a long definition of graph theory. It wants the role the graph plays:

1. how it represents a problem
2. why that representation is useful to the AI

For 2 marks, the expected answer is usually one point about representation and one point about search/solution finding.

Approach

A good approach is:

• first say what the graph stands for in an AI problem
• then say what the AI does with that graph

That gives a complete answer: the graph is both a model of the problem and a search space the AI can work through.

Step-by-Step Reasoning

The first important idea is that a graph turns a real problem into a structure the computer can process.

• A node can stand for a location, a state in a puzzle, or a possible situation.
• An edge can stand for a path, transition, or legal move from one state to another.

So the graph is useful because it gives the AI a clear map of what choices exist.

The second important idea is what the AI does next.

• Once the problem is in graph form, the AI can search it.
• It can look for a route from a start node to a goal node.
• If edges have weights, it can look for the best route, such as the shortest distance or lowest cost.

That is why graphs are important in AI: they allow structured searching and problem solving.

Key Takeaways

• A graph represents a problem using nodes and edges.
• In AI, nodes often represent states or locations.
• Edges represent possible moves or relationships.
• The AI searches the graph to find a valid or optimal solution.

Common Mistakes

• Only defining a graph: saying a graph has nodes and edges is not enough on its own; the answer should also mention its purpose in AI.
• Talking about charts/graphs: this is not a bar chart or line graph; it is the computer science graph data structure.
• Missing the search idea: the key AI use is that the graph can be searched to solve problems.

Things to Be Careful About

• Use AI language such as states, moves, paths, costs or solutions.
• If you mention weights, link them to finding the best path, not just any path.
• Keep the answer focused on purpose rather than giving unrelated examples or algorithms in too much detail.

Background Concept

An artificial neural network (ANN) is a computing model inspired by the way biological neurons connect in the brain. It is built from many simple processing units called neurons or nodes.

These nodes are usually arranged in layers:

• an input layer to receive data
• one or more hidden layers to process the data
• an output layer to produce the final result

Each connection between nodes has a weight. The weight controls how strongly one node influences the next. During training, these weights are adjusted so that the network gives better answers.

Deep Learning is a form of machine learning that uses neural networks with many hidden layers. The word "deep" refers to this greater number of layers. Having many layers allows the system to learn more complex patterns by building up features step by step.

Understanding the Question

The question asks you to explain the use of artificial neural networks in Deep Learning. This means you should go beyond simply defining an ANN.

You need to explain:

• that Deep Learning is based on ANNs
• that these networks have multiple layers, especially many hidden layers
• that they are trained using data
• that weight adjustment allows the network to learn patterns and make decisions such as classifications or predictions

For 4 marks, the answer should contain several linked points, not just one sentence.

Approach

A strong structure is:

1. state that Deep Learning uses ANNs
2. describe the ANN structure in terms of layers and connected nodes
3. explain that Deep Learning uses many hidden layers
4. explain training by changing weights to reduce errors
5. finish with what this achieves: learning features and producing outputs

This gives both the mechanism and the purpose.

Step-by-Step Reasoning

First, identify the basic tool used in Deep Learning:

• Deep Learning uses artificial neural networks.
• An ANN is a set of interconnected processing nodes.

Next, describe the structure:

• Data enters through the input layer.
• It is processed through one or more hidden layers.
• The final answer is produced at the output layer.

Why does Deep Learning specifically matter here?

• In Deep Learning, there are many hidden layers, not just one.
• Each layer processes the results from the previous layer.
• This means early layers can learn simple features, while later layers combine them into more complex patterns.

Now explain training:

• The network is trained using large amounts of example data.
• It produces an output.
• That output is compared with the correct answer.
• The error is used to adjust the connection weights.
• A standard method for this is back propagation.
• Over many training cycles, the weights improve so the network becomes more accurate.

Finally, explain the result of using the ANN:

• The network learns patterns in the training data.
• It does not need every rule to be programmed manually.
• After training, it can classify inputs, recognise objects, detect speech patterns, or make predictions.

So the ANN is the core structure that allows Deep Learning systems to learn increasingly complex representations from data.

Key Takeaways

• Deep Learning is built on artificial neural networks.
• ANNs consist of input, hidden and output layers.
• Deep Learning uses many hidden layers.
• Training adjusts weights to reduce error.
• The network learns patterns/features and can then classify or predict outputs.

Common Mistakes

• Only defining an ANN: saying it is based on the brain or made of neurons is not enough; you must connect it to Deep Learning.
• Forgetting the meaning of "deep": the important point is the presence of many hidden layers.
• Missing the training process: the network must learn by changing weights using data.
• Saying it is explicitly programmed with rules: neural networks learn from examples rather than being given every rule directly.
• Confusing neurons with layers: neurons are individual nodes; layers are groups of nodes.

Things to Be Careful About

• Make sure you mention many hidden layers, not just "layers" in general, because that is what makes it Deep Learning.
• If you mention back propagation, link it correctly to adjusting weights to reduce error.
• Use the term learn patterns/features from data rather than vague phrases like "thinks like a human brain".
• Keep the explanation practical: structure, training, and outcome are the three main marking areas.

Background Concept

In object-oriented programming, a class is a template for creating objects. A class diagram shows the structure of that class: its attributes and its methods.

• Attributes are the data items stored in each object.
• Methods are the operations the object can perform.
• A common pattern is to use setter methods such as SetDateSeen(...) to assign values to attributes.
• Another common pattern is to use getter methods such as GetDateSeen() to return values stored in the object.

In questions like this, you choose attribute names and data types that match the scenario, then add methods that fit the stated purpose.

Understanding the Question

The class Appointment already contains three attributes:

• DateSeen : DATE
• Treatments : STRING
• Medications : STRING

The question says an appointment must also identify:

• the patient, using a unique 8-digit number, so this should be an INTEGER
• the doctor, identified by name, so this should be a STRING

It also asks for methods to:

• assign date seen
• assign treatments given
• assign medications prescribed
• return the date seen
• return the patient identifier
• return the doctor identifier

Two setter methods are already given in the diagram:

• SetPatientID(PatientNumber : INTEGER)
• SetDoctor(DoctorID : STRING)

So the blank method lines need to be filled with the remaining setters and getters.

Approach

A good way to tackle this is:

1. Add the two missing attributes first.
2. Match each required "assign" operation with a setter method.
3. Match each required "return" operation with a getter method.
4. Keep the style consistent with the class diagram already shown.

Because the question already gives method names beginning with Set... and getter names like GetTreatments(), we should continue using that pattern.

Step-by-Step Reasoning

First, the patient identifier:

• The patient is identified by an 8-digit number.
• A number of this kind is best stored as INTEGER in this context.
• So a suitable attribute is PatientID : INTEGER.

Second, the doctor identifier:

• The doctor is identified by name.
• A name is text, so the data type should be STRING.
• So a suitable attribute is DoctorID : STRING.

Now the methods.

The diagram already includes:

• SetPatientID(PatientNumber : INTEGER)
• SetDoctor(DoctorID : STRING)
• GetTreatments()
• GetMedications()

The question also requires methods to assign:

• date seen
• treatments given
• medications prescribed

So we add three setter methods:

• SetDateSeen(DateSeen : DATE)
• SetTreatments(Treatments : STRING)
• SetMedications(Medications : STRING)

Then it requires methods to return:

• date seen
• patient attribute
• doctor attribute

So we add three getter methods:

• GetDateSeen()
• GetPatientID()
• GetDoctor()

That fills all the blank method lines exactly.

Key Takeaways

• A class diagram lists both attributes and methods.
• Choose data types from the meaning of the data: numeric identifiers often use INTEGER, names use STRING, dates use DATE.
• Setter methods assign values to attributes.
• Getter methods return values from attributes.
• Keep naming style consistent with the given class design.

Common Mistakes

• Using the wrong data type for the doctor, for example INTEGER instead of STRING.
• Forgetting that the question asks for both assign methods and return methods.
• Adding methods for Treatments and Medications returns even though GetTreatments() and GetMedications() are already provided.
• Writing method bodies instead of just completing the class diagram entries.
• Omitting one of the required getter methods, especially GetPatientID() or GetDoctor().

Things to Be Careful About

• Follow the style already used in the diagram.
• Do not change the given methods; only fill the blanks.
• Make sure each attribute has a matching sensible data type.
• Keep method names consistent with the given Set... and Get... naming pattern.
• In a diagram question, the examiner is usually crediting the class structure, not full program code.