Data Types, Data Structures and Boolean Algebra - Worksheets, Questions and Revision

14 original exam-style questions - 8 pages of questions with a full mark scheme - free printable PDF.

Download PDF Jump to mark scheme (page 9)Read the revision guide

Next in this strand

Revision Library

revisionlibrary.co.uk

A-Level · Computer Systems (Component 1)

A1.4 Data Types, Data Structures and Boolean Algebra

OCR H446 · Calculators not allowed · about 185 minutes

Total Marks

Name: _______________________________ Date: ____ / ____ / ______

Answer ALL questions. Show all your working.

This question is about primitive data types and number base conversions.

(a)State the most appropriate primitive data type for each of the following items of data: (i) a customer's age in whole years (ii) the price of an item in pounds and pence (iii) whether a user is currently logged in (iv) the initial letter of a person's surname.(4)

(b)Convert the denary integer 214 into an 8-bit unsigned binary number. Show your working.(2)

(c)Convert your answer to part (b) into hexadecimal.(2)

(d)Convert the hexadecimal value 2F into an 8-bit binary number, and state its denary value.(2)

(Total for Question 1 is 10 marks)

This question is about two's complement representation and binary addition.

(a)Represent the denary number -45 as an 8-bit two's complement binary number. Show your working.(2)

(b)Represent the denary number 77 as an 8-bit two's complement binary number.(1)

(c)Add your answers to parts (a) and (b) together in binary, showing your working, and state the resulting bit pattern.(3)

(d)A programmer adds the 8-bit two's complement numbers 01111111 and 00000001. State the resulting bit pattern, and explain why this result demonstrates arithmetic overflow.(2)

(Total for Question 2 is 8 marks)

This question is about floating point representation.

(a)A computer represents floating point numbers using an 8-bit mantissa and a 4-bit exponent, both stored in two's complement, with the mantissa normalised so that its first two bits differ. Represent the denary integer 22 in this floating point form, showing your working for both the mantissa and the exponent.(3)

(b)State what is meant by a normalised mantissa, and explain why floating point numbers are stored in normalised form.(2)

(c)Many decimal fractions, such as 0.1, cannot be represented exactly in binary floating point. Explain why this happens, and the effect it can have on a program that repeatedly adds 0.1 to a running total.(2)

(d)State the effect on the floating point number system of allocating (i) more bits to the exponent and (ii) more bits to the mantissa, keeping the total number of bits used unchanged.(2)

(Total for Question 3 is 9 marks)

This question is about character encoding.

(a)State the name of the character encoding standard that can represent characters and symbols from all the world's writing systems, in contrast to standard ASCII, which only covers a limited character set.(1)

(b)Given that the ASCII code for the character 'A' is 65, state the ASCII code for the character 'H'.(1)

(c)A company's customer database must store names containing accented and non-Latin characters (for example, an umlaut in Muller, or a Chinese name). Explain one advantage of storing this data using Unicode rather than ASCII.(2)

(d)A new messaging app must support 200 different characters using a fixed-length binary code. Calculate the minimum number of bits required per character, showing your working.(2)

(Total for Question 4 is 6 marks)

A program uses the following pseudocode to process a set of 5 test scores stored in an array:

DECLARE scores : ARRAY[0:4] OF INTEGER
scores[0] <- 12
scores[1] <- 45
scores[2] <- 8
scores[3] <- 45
scores[4] <- 19
total <- 0
FOR i <- 0 TO 4
    total <- total + scores[i]
NEXT i
average <- total / 5
OUTPUT average

Use this pseudocode to answer parts (a) to (d).

(a)State the name of the data structure declared by the line 'DECLARE scores : ARRAY[0:4] OF INTEGER', and state the data type of each element it stores.(1)

(b)Complete a trace table for the FOR loop, showing the values of i, scores[i] and total for each of the 5 iterations.(5)

(c)State the value that will be output by the program.(1)

(d)Rewrite the line 'average <- total / 5' so that integer (whole-number) division is used instead of real division, and state the new value that would be output.(2)

(Total for Question 5 is 9 marks)

A program uses the following pseudocode:

TYPE StudentRecord

    DECLARE studentID : INTEGER
    DECLARE name : STRING
    DECLARE grade : CHAR

ENDTYPE

DECLARE student1 : StudentRecord
student1.studentID <- 10234
student1.name <- "Amara Okafor"
student1.grade <- 'B'

(a)State the term used to describe a data structure, such as StudentRecord above, that groups together related data items, which may be of different data types, under a single identifier.(1)

(b)State the value stored in student1.name after the code above has executed.(1)

(c)Write pseudocode to (i) declare an array called cohort of 30 StudentRecord elements, and (ii) set the grade field of the 5th student in the array to 'A'.(3)

(d)Explain one advantage of using a single array of StudentRecord elements, rather than three separate arrays (one for IDs, one for names and one for grades), to store the same cohort data.(2)

(Total for Question 6 is 7 marks)

A program implements a stack using the following pseudocode:

DECLARE stack : ARRAY[0:9] OF INTEGER
DECLARE top : INTEGER
top <- -1

PROCEDURE Push(value : INTEGER)
    top <- top + 1
    stack[top] <- value
ENDPROCEDURE

FUNCTION Pop() RETURNS INTEGER
    DECLARE value : INTEGER
    value <- stack[top]
    top <- top - 1
    RETURN value
ENDFUNCTION

(a)State the name of the abstract data type shown above, and state its access principle (the order in which items are added and removed).(2)

(b)The following sequence of calls is made on an initially empty stack: Push(6), Push(2), Push(9), Pop(), Push(4), Pop(), Pop(). Complete a trace table showing the value of top and the contents of the stack array after each call, and the value returned by each Pop().(6)

(c)State the value returned by the final Pop() call in the sequence.(1)

(d)A text editor uses a stack to implement its 'undo' feature, where the most recently made change is the first to be undone. Explain why a stack, rather than a queue, is the appropriate data structure for this purpose.(2)

(Total for Question 7 is 11 marks)

A circular queue is implemented as an array of 5 elements (indices 0 to 4), using two pointers: rear points to the next free slot for insertion, and front points to the next item to be removed. Both pointers start at index 0.

Enqueue(value): queue[rear] <- value, then rear <- (rear+1) MOD 5
Dequeue(): value <- queue[front], then front <- (front+1) MOD 5, RETURN value

(a)Explain why a linear queue implemented using a fixed-size array can appear to be 'full', and reject further enqueue operations, even when it currently holds far fewer items than the array's capacity.(2)

(b)Explain how implementing the queue as a circular queue overcomes this problem.(2)

(c)The following operations are carried out in order on the circular queue described above: Enqueue(15), Enqueue(23), Enqueue(8), Dequeue(), Enqueue(41), Enqueue(6), Dequeue(). Complete a trace showing the value of front and rear after each operation, and the value returned by each Dequeue().(5)

(d)State the final values of front and rear, and list the values currently stored in the queue in order from front to rear.(2)

(Total for Question 8 is 11 marks)

The values 50, 30, 70, 20, 40, 60, 80, 35 are inserted, in that order, into an initially empty binary search tree (BST), where for each node, values less than the node are inserted into its left subtree and values greater than or equal to the node are inserted into its right subtree.

(a)State the value stored at the root of the tree once all eight values have been inserted.(1)

(b)State the left child and the right child of the node containing 30.(2)

(c)State the left child and the right child of the node containing 70.(2)

(d)A pre-order traversal visits nodes in the order: root, then left subtree, then right subtree. State the sequence of values produced by a pre-order traversal of the completed tree.(3)

(e)An in-order traversal visits nodes in the order: left subtree, root, right subtree. State the sequence of values produced by an in-order traversal of the tree, and explain why an in-order traversal of any binary search tree always produces the stored values in ascending order.(4)

(f)State one advantage of storing this data in a binary search tree, rather than in a sorted (ordered) one-dimensional array, in terms of the efficiency of inserting new data values.(2)

(Total for Question 9 is 14 marks)

A programmer is implementing a hash table.

(a)Explain what is meant by a hash table, and describe the role played by a hash function when storing and retrieving data in one.(3)

(b)A hash table has 7 slots, indexed 0 to 6, and uses the hash function h(key) = key MOD 7. State the index that each of the following keys initially hashes to: 15, 22, 9, 30, 16. Identify which of these keys collide with an earlier key (hash to a slot already used by a key inserted before it), assuming they are inserted in the order given.(3)

(c)Collisions are resolved using linear probing: if a key's home slot is already occupied, the next slot is checked (wrapping from slot 6 back to slot 0), and so on, until an empty slot is found. Using this method, insert the five keys from part (b), in the order given, into the hash table. State the final contents of all 7 slots.(4)

(d)Explain one disadvantage of using linear probing to resolve collisions when a hash table becomes heavily loaded (close to full).(2)

(Total for Question 10 is 12 marks)

Q = (A AND B) OR (NOT C) is a Boolean expression with three inputs, A, B and C.

(a)Complete a truth table for Q, showing the output for all 8 possible combinations of A, B and C (using the standard ordering 000 to 111).(4)

(b)State the number of rows required in a truth table for a Boolean expression with n input variables, and explain why this formula applies.(2)

(c)Describe a logic circuit that implements Q = (A AND B) OR (NOT C), stating the logic gates required and how they are connected.(2)

(d)A different logic gate has the property that its single output is 1 only when its two inputs, A and B, have different values. Identify this logic gate.(1)

(Total for Question 11 is 9 marks)

This question is about the laws of Boolean algebra.

(a)State De Morgan's first law, expressing NOT(A AND B) in terms of NOT A, NOT B and OR.(1)

(b)State De Morgan's second law, expressing NOT(A OR B) in terms of NOT A, NOT B and AND.(1)

(c)Simplify the Boolean expression Q = NOT(NOT A OR NOT B) OR (A AND B), showing each step of your working and naming the law used at each step.(4)

(d)Simplify the Boolean expression Q = (A AND B) OR (A AND NOT B), showing each step of your working and naming the law used at each step.(3)

(e)A student claims that (A OR B) AND (A OR C) is equivalent to A OR (B AND C). State whether the student is correct, and name the Boolean law that justifies your answer.(2)

(Total for Question 12 is 11 marks)

A security system triggers an alarm (ALARM) if the front door sensor (D) is open AND the system is armed (S), OR if the motion sensor (M) is triggered while the system is armed (S), regardless of the door.

(a)Write a Boolean expression for ALARM in terms of D, S and M.(2)

(b)Using the distributive law, simplify your expression from part (a) so that it uses only one AND gate involving S.(2)

(c)Describe the simplified logic circuit needed to implement ALARM = S AND (D OR M), stating the gates required and their inputs.(2)

(d)Complete a truth table for ALARM = S AND (D OR M), showing the output for all 8 combinations of S, D and M (using the standard ordering 000 to 111).(4)

(e)State the number of rows in the truth table where ALARM = 1, and explain what this means for the behaviour of the security system.(2)

(Total for Question 13 is 12 marks)

Priya, a software engineer, is designing two separate programs: (1) a program to manage a print queue for a school's network printer, where print jobs must be handled in the order they are submitted, and (2) a program to store and quickly search a large, frequently-changing dictionary of 50000 words for a spell-checker.

Discuss which data structure(s) would be most appropriate for (1) the print queue and (2) the spell-checker's word list, justifying your choice by comparing at least two suitable data structures for each scenario in terms of how their operations are performed and how efficient they are.

(Total for Question 14 is 9 marks)

Mark scheme · A1.4 Data Types, Data Structures and Boolean Algebra

Question 1

(a) B1 INTEGER for age
(a) B1 REAL (oe fixed-point/currency type) for price
(a) B1 BOOLEAN for logged-in status
(a) B1 CHAR for the initial letter
(a) Answer: INTEGER, REAL, BOOLEAN, CHAR
(b) M1 correct place values identified, e.g. 128+64+16+4+2=214, or equivalent method shown
(b) A1 11010110 cao
(b) Answer: 11010110
(c) M1 binary split into two 4-bit nibbles: 1101 and 0110
(c) A1 D6 cao
(c) Answer: D6
(d) M1 2=0010 and F=1111 correctly identified
(d) A1 00101111 and denary value 47, both correct (oe)
(d) Answer: 00101111 = 47

Question 2

(a) M1 45 correctly represented in binary (00101101) and correctly inverted (11010010)
(a) A1 11010011 cao (invert then add 1)
(a) Answer: 11010011
(b) B1 01001101 cao
(b) Answer: 01001101
(c) M1 correct bit-by-bit binary addition attempted with carries shown
(c) M1 final carry out of the 8th bit correctly discarded
(c) A1 00000000 cao
(c) Answer: 00000000
(d) B1 10000000 stated
(d) B1 explanation that both operands are positive (sign bit 0) but the result has sign bit 1 (negative), which is impossible when adding two positive numbers, so overflow has occurred
(d) Answer: 10000000 (overflow, since 127+1=128 cannot be represented as a positive 8-bit two's complement number)

Question 3

(a) M1 22 written in binary (10110) and expressed as a normalised fraction, e.g. 0.10110 x 2⁵
(a) M1 exponent 5 correctly converted to 4-bit two's complement (0101)
(a) A1 mantissa 01011000 and exponent 0101 both correct (oe equivalent padding)
(a) Answer: mantissa = 01011000, exponent = 0101
(b) B1 normalised means the mantissa's first two bits differ (no redundant leading 0s or 1s before the significant digits)
(b) B1 normalisation gives each number a single, unique representation and maximises the number of significant bits available, maximising precision
(b) Answer: Normalised means the first two mantissa bits differ; this is used to maximise precision and give a unique representation for each value.
(c) B1 0.1 is a recurring (non-terminating) binary fraction, so it must be truncated/rounded to fit the fixed number of mantissa bits
(c) B1 the small rounding error accumulates over repeated additions, causing the running total to drift from the mathematically expected value
(c) Answer: 0.1 cannot be represented exactly in binary so it is rounded; repeated addition accumulates this rounding error, causing the total to drift from the true value.
(d) B1 (i) more exponent bits increases the range of values that can be represented
(d) B1 (ii) more mantissa bits increases the precision (accuracy) of the values represented
(d) Answer: (i) increases range; (ii) increases precision.

Question 4

(a) B1 Unicode
(a) Answer: Unicode
(b) B1 72 cao
(b) Answer: 72
(c) B1 Unicode includes code points for accented characters and non-Latin scripts, whereas standard 7-bit ASCII only encodes basic Latin letters, digits and symbols
(c) B1 so names can be stored and displayed accurately rather than being corrupted or losing information
(c) Answer: Unicode covers accented and non-Latin characters that ASCII cannot represent, so names are stored and displayed correctly.
(d) M1 2⁷=128 (insufficient, since 128<200) and 2⁸=256 (sufficient, since 256≥200) tested
(d) A1 8 bits cao
(d) Answer: 8 bits

Question 5

(a) B1 a one-dimensional array (of 5 elements), storing INTEGER data (both parts needed for the mark)
(a) Answer: A one-dimensional array of INTEGER values.
(b) B1 i=0, scores[i]=12, total=12
(b) B1 i=1, scores[i]=45, total=57
(b) B1 i=2, scores[i]=8, total=65
(b) B1 i=3, scores[i]=45, total=110
(b) B1 i=4, scores[i]=19, total=129
(b) Answer: total after each iteration: 12, 57, 65, 110, 129
(c) B1 25.8 cao
(c) Answer: 25.8
(d) M1 average <- total DIV 5 (or equivalent correct use of DIV)
(d) A1 25 cao
(d) Answer: average <- total DIV 5, output 25

Question 6

(a) B1 a record
(a) Answer: A record.
(b) B1 "Amara Okafor" cao
(b) Answer: Amara Okafor
(c) M1 array declared with correct bounds for 30 elements of type StudentRecord, e.g. DECLARE cohort : ARRAY[0:29] OF StudentRecord
(c) M1 correct index used for the 5th element (index 4, since arrays are zero-indexed)
(c) A1 correct dot notation used to access and assign the field, e.g. cohort[4].grade <- 'A' (any correct logic, ignore minor syntax)

DECLARE cohort : ARRAY[0:29] OF StudentRecord
cohort[4].grade <- 'A'

(d) B1 all the data relating to one student is kept together under one index, so there is no risk of the arrays becoming out of step (e.g. after sorting or deleting an entry)
(d) B1 makes the code easier to read and maintain, since related fields are accessed via one structure (e.g. cohort[i].grade) rather than needing to keep several array indices synchronised
(d) Answer: Keeps each student's data together under one index, avoiding the arrays becoming mismatched, and makes the code clearer to maintain.

Question 7

(a) B1 Stack
(a) B1 LIFO (Last In, First Out)
(a) Answer: Stack; LIFO (Last In, First Out).
(b) B1 Push(6): top=0, stack[0]=6
(b) B1 Push(2): top=1, stack[1]=2
(b) B1 Push(9): top=2, stack[2]=9
(b) B1 Pop() returns 9, top becomes 1
(b) B1 Push(4): top=2, stack[2]=4
(b) B1 Pop() returns 4 (top becomes 1), then Pop() returns 2 (top becomes 0)
(b) Answer: Returned values in order: 9, 4, 2. Final top = 0.
(c) B1 2 cao
(c) Answer: 2
(d) B1 a stack is LIFO, so the last (most recent) action pushed onto the stack is the first one popped off / undone, matching the required behaviour
(d) B1 a queue is FIFO and would instead undo the oldest recorded action first, which would not match how 'undo' is expected to behave
(d) Answer: A stack's LIFO order means the most recent action is undone first, matching the required behaviour; a FIFO queue would undo the oldest action first instead.

Question 8

(a) B1 as items are dequeued from the front, the front pointer moves forward but the freed slots at the start of the array are not reused
(a) B1 so once the rear pointer reaches the end of the array, no more items can be enqueued even though slots earlier in the array are empty
(a) Answer: Freed slots at the front of the array cannot be reused once the rear pointer reaches the end, so the queue appears full despite having empty slots.
(b) B1 the rear (and front) pointer wraps around to index 0 once it passes the last index, e.g. using MOD arithmetic
(b) B1 so slots freed near the start of the array can be reused, meaning the queue is only full when all slots are genuinely occupied
(b) Answer: The pointers wrap around to the start of the array using MOD arithmetic, so freed slots are reused and the queue is only full when genuinely at capacity.
(c) B1 Enqueue(15): queue[0]=15, rear=1
(c) B1 Enqueue(23) and Enqueue(8): queue[1]=23, queue[2]=8, rear=3
(c) B1 Dequeue() returns 15, front becomes 1
(c) B1 Enqueue(41) and Enqueue(6): queue[3]=41, queue[4]=6, rear wraps to 0 (since (4+1) MOD 5=0)
(c) B1 Dequeue() returns 23, front becomes 2
(c) Answer: Dequeue() calls return 15, then 23. After all operations: front=2, rear=0.
(d) B1 front=2, rear=0
(d) B1 values in order: 8, 41, 6
(d) Answer: front=2, rear=0; queue contents (front to rear): 8, 41, 6.

Question 9

(a) B1 50
(a) Answer: 50
(b) B1 left child = 20
(b) B1 right child = 40
(b) Answer: Left child = 20, right child = 40.
(c) B1 left child = 60
(c) B1 right child = 80
(c) Answer: Left child = 60, right child = 80.
(d) M1 root 50 visited first, correctly followed by the complete left subtree
(d) M1 left subtree correctly given as 30, 20, 40, 35
(d) A1 full sequence 50, 30, 20, 40, 35, 70, 60, 80 cao
(d) Answer: 50, 30, 20, 40, 35, 70, 60, 80
(e) M1 sequence 20, 30, 35, 40, 50, 60, 70, 80 attempted with correct method
(e) A1 sequence fully correct (cao)
(e) B1 explanation that at every node, all values in its left subtree are smaller and all values in its right subtree are larger (the BST property)
(e) B1 so visiting left subtree, then the node, then right subtree at every level guarantees values are output smallest-first
(e) Answer: 20, 30, 35, 40, 50, 60, 70, 80; because at every node all values in its left subtree are smaller and all values in its right subtree are larger, processing left-node-right at each level always yields ascending order.
(f) B1 inserting into a BST only requires traversing a single path from the root (typically O(log n) comparisons for a balanced tree) and attaching a new node
(f) B1 whereas inserting into a sorted array requires shifting all subsequent elements along by one position to keep the array in order, which is O(n)
(f) Answer: Inserting into a BST only needs a single root-to-leaf path traversal (no shifting), far more efficient than a sorted array, where all following elements must be shifted along.

Question 10

(a) B1 a hash table is a data structure that stores key-value data in an array-like structure, using a function to determine where a given key's data should be stored
(a) B1 the hash function takes a key as input and returns an index (address) within the table, so the same key always maps to the same index
(a) B1 this allows data to be stored and retrieved directly, typically in constant / O(1) average time, without searching through the whole structure
(a) Answer: A hash table stores data using a hash function that maps each key to an index in the table, allowing fast (average O(1)) storage and retrieval.
(b) M1 correct MOD 7 calculation shown or implied for at least 3 of the 5 keys
(b) A1 all 5 indices correct: 15->1, 22->1, 9->2, 30->2, 16->2
(b) A1 collisions correctly identified: 22 collides with 15 (both index 1); 30 and 16 each collide, since index 2 is already used by 9 (and then 30)
(b) Answer: 15->1, 22->1, 9->2, 30->2, 16->2. Collisions: 22 (with 15); 30 (with 9); 16 (with 9 and 30).
(c) M1 15 placed at slot 1 (home slot, no collision)
(c) M1 22 probes from slot 1 (occupied) to slot 2 (empty), placed at slot 2; 9 then probes from slot 2 (occupied) to slot 3 (empty), placed at slot 3
(c) M1 30 probes slots 2 and 3 (occupied) to slot 4 (empty), placed at slot 4; 16 probes slots 2, 3 and 4 (occupied) to slot 5 (empty), placed at slot 5
(c) A1 final table fully correct: slot0=empty, 1=15, 2=22, 3=9, 4=30, 5=16, 6=empty
(c) Answer: Slot0: empty, Slot1: 15, Slot2: 22, Slot3: 9, Slot4: 30, Slot5: 16, Slot6: empty.
(d) B1 keys that collide tend to cluster together in consecutive slots (primary clustering)
(d) B1 this means later insertions and searches may need to probe through many occupied slots before finding an empty slot or the target key, increasing average access time towards O(n)
(d) Answer: Linear probing causes clustering of colliding keys in consecutive slots, so as the table fills, insertions and searches must probe through more slots, increasing average access time.

Question 11

(a) B1 A=0,B=0 rows (C=0 then C=1) correctly give Q=1, Q=0
(a) B1 A=0,B=1 rows (C=0 then C=1) correctly give Q=1, Q=0
(a) B1 A=1,B=0 rows (C=0 then C=1) correctly give Q=1, Q=0
(a) B1 A=1,B=1 rows (C=0 then C=1) correctly give Q=1, Q=1
(a) Answer: Q values (A,B,C from 000 to 111): 1, 0, 1, 0, 1, 0, 1, 1
(b) B1 2ⁿ rows
(b) B1 because each of the n variables can independently take one of 2 values (0 or 1), giving 2 x 2 x ... (n times) = 2ⁿ possible combinations
(b) Answer: 2ⁿ rows, since each of the n inputs can independently be 0 or 1.
(c) B1 an AND gate with inputs A and B, and a NOT gate with input C
(c) B1 the outputs of the AND gate and the NOT gate are connected as the two inputs to an OR gate, whose output is Q
(c) Answer: AND gate (inputs A, B) and NOT gate (input C) feed into an OR gate, whose output is Q.
(d) B1 XOR (exclusive OR)
(d) Answer: XOR

Question 12

(a) B1 NOT(A AND B) = (NOT A) OR (NOT B)
(a) Answer: NOT(A AND B) = (NOT A) OR (NOT B)
(b) B1 NOT(A OR B) = (NOT A) AND (NOT B)
(b) Answer: NOT(A OR B) = (NOT A) AND (NOT B)
(c) M1 De Morgan's second law applied to NOT(NOT A OR NOT B), giving NOT(NOT A) AND NOT(NOT B)
(c) dM1 double negation (involution) law applied: NOT(NOT A) AND NOT(NOT B) = A AND B
(c) dM1 expression now reads Q = (A AND B) OR (A AND B); idempotent law applied (X OR X = X)
(c) A1 Q = A AND B cao
(c) Answer: Q = A AND B
(d) M1 A factorised out using the distributive law: A AND (B OR NOT B)
(d) dM1 complement law applied: B OR NOT B = 1, giving A AND 1
(d) A1 identity law applied: A AND 1 = A, so Q = A cao
(d) Answer: Q = A
(e) B1 the student is correct
(e) B1 this is the distributive law (OR distributes over AND, just as AND distributes over OR): A OR (B AND C) = (A OR B) AND (A OR C)
(e) Answer: Correct; this is an application of the distributive law.

Question 13

(a) M1 correctly identifies that ALARM is true when (D AND S) is true, or when (M AND S) is true
(a) A1 ALARM = (D AND S) OR (M AND S) (oe, any equivalent correct expression)
(a) Answer: ALARM = (D AND S) OR (M AND S)
(b) M1 S correctly factorised out of both terms
(b) A1 ALARM = S AND (D OR M) cao
(b) Answer: ALARM = S AND (D OR M)
(c) B1 an OR gate with inputs D and M
(c) B1 the output of the OR gate, together with input S, are connected to an AND gate, whose output is ALARM
(c) Answer: OR gate (inputs D, M) feeding into an AND gate together with S; the AND gate output is ALARM.
(d) B1 S=0 rows (all 4 combinations of D,M): ALARM=0 in every case, since S=0
(d) B1 S=1,D=0: M=0 gives ALARM=0; M=1 gives ALARM=1
(d) B1 S=1,D=1: M=0 gives ALARM=1; M=1 gives ALARM=1
(d) B1 full table correct and consistent with S AND (D OR M) (cao)
(d) Answer: ALARM values (S,D,M from 000 to 111): 0, 0, 0, 0, 0, 1, 1, 1
(e) B1 3 rows
(e) B1 the alarm only ever sounds when the system is armed (S=1) and at least one of the sensors (D or M) is triggered; when the system is disarmed (S=0) the alarm never sounds, regardless of the sensors
(e) Answer: 3 rows; the alarm only sounds when the system is armed and at least one sensor is triggered - it never sounds while disarmed.