How Computers Work

Question 1 (10 marks)

(a) $217$ to binary — repeated division by 2: $217/2=108$ r$1$; $108/2=54$ r$0$; $54/2=27$ r$0$; $27/2=13$ r$1$; $13/2=6$ r$1$; $6/2=3$ r$0$; $3/2=1$ r$1$; $1/2=0$ r$1$. Reading remainders bottom-up: $\mathbf{11011001_2}$. (2) To hex: group binary in nibbles $1101\ 1001 = \text{D}\,9 = \mathbf{0xD9}$. (Check: $13\cdot16+9=208+9=217$.) (2) Why: remainders give binary digits least-significant first; nibble grouping gives hex directly.

(b) $\text{0x2F} = 2\cdot16 + 15 = 32+15 = \mathbf{47}$. (2) To octal: $47 = 32+15 = 057_8$ (since $47/8=5$ r$7$) → $\mathbf{57_8}$. (1)

(c) Hex is used because one hex digit maps exactly to 4 binary bits ($16=2^4$), so a byte is just two hex digits. It is far more compact and less error-prone to read than long binary strings, while still directly reflecting bit patterns (unlike decimal). (3: mapping 1, compactness 1, bit-faithfulness 1)

Question 2 (10 marks)

(a) Truth table for $F=(A\oplus B)\cdot\overline C$: (4: 1 per correct half of table)

$F=1$ only for rows $(0,1,0)$ and $(1,0,0)$.

(b) NAND completeness: (2 each)

• NOT: $\overline{A} = A \text{ NAND } A$.
• AND: $A\cdot B = \overline{(A\text{ NAND }B)} = (A\text{ NAND }B)\text{ NAND }(A\text{ NAND }B)$.
• OR: $A+B = \overline{A}\text{ NAND }\overline{B} = (A\text{ NAND }A)\text{ NAND }(B\text{ NAND }B)$ (by De Morgan).

Verification: NOT via $\overline{A}=\overline{A\cdot A}$; OR since $\overline{\bar A\cdot\bar B}=A+B$.

Question 3 (12 marks)

(a) Full adder equations: (2) $\text{Sum} = A\oplus B\oplus C_{in}, \qquad C_{out} = A\cdot B + C_{in}\cdot(A\oplus B)\ (=AB+BC_{in}+AC_{in}).$ Truth table: (4)

(b) First half adder adds $A$ and $B$ giving partial sum $S_1=A\oplus B$ and carry $C_1=A\cdot B$. Second half adder adds $S_1$ and $C_{in}$ giving final Sum $=S_1\oplus C_{in}$ and carry $C_2=S_1\cdot C_{in}$. The OR gate combines the two carries: $C_{out}=C_1+C_2$. (3)

(c) $Y = \overline{S}\cdot I_0 + S\cdot I_1$. A multiplexer selects one of several data inputs to pass to the output based on the select line(s). (3)

Question 4 (10 marks)

(a) SR latch = two cross-coupled NOR gates; $Q$ and $\overline Q$ feed back. (1)

• $(0,0)$: Hold — retains previous state. (1)
• $(1,0)$: Set — $Q=1$. (1)
• $(0,1)$: Reset — $Q=0$. (1)
• $(1,1)$: Forbidden/invalid — both outputs forced to $0$, violating $Q=\overline{\overline Q}$; unstable on release. (1)

(b) A D flip-flop stores whatever is on its D input at the clock edge (no forbidden state). A JK flip-flop behaves like SR but $(J,K)=(1,1)$ toggles instead of being forbidden. A register holds $N$ independent bits, and each single-bit storage element (flip-flop) holds exactly one bit, so $N$ bits require $N$ flip-flops. (3)

(c) $2^8 = \mathbf{256}$ distinct values; largest unsigned $= 2^8-1 = \mathbf{255}$. (2)

Question 5 (10 marks)

(a) (6: 1 per correct step+component)

1. Fetch: control unit uses the PC to address memory, loads instruction into the instruction register; PC incremented.
2. Decode: the control unit interprets the opcode/operands.
3. Execute: the ALU performs arithmetic/logic (or a memory/register transfer occurs); operands come from registers.
4. Results written back to registers/memory; cycle repeats with next PC value.

(b) Machine code is the raw binary opcodes the CPU executes directly. Assembly is a human-readable mnemonic representation (e.g. MOV, ADD) that maps essentially one-to-one to machine instructions and is translated by an assembler. Both exist because the hardware only understands binary, but humans need readable symbols to write/debug low-level code. (4)

Question 6 (8 marks)

(a) Fastest→slowest: registers → L1 cache → RAM → SSD → HDD. (3 for order) As you move down: latency increases and capacity/size increases while cost-per-bit falls — small+fast at the top, large+slow at the bottom. (2)

(b) Any two of: Resource manager (schedules CPU time, allocates memory, manages I/O among processes); Abstraction layer (hides hardware details behind system calls / file & process abstractions); also process/memory protection and security. (3)

[
  {"claim":"217 decimal = 0xD9 and binary 11011001","code":"result = (bin(217)=='0b11011001') and (hex(217)=='0xd9')"},
  {"claim":"0x2F = 47 decimal = 57 octal","code":"result = (0x2F==47) and (oct(47)=='0o57')"},
  {"claim":"8-bit register: 256 values, max 255","code":"result = (2**8==256) and (2**8-1==255)"},
  {"claim":"Full adder Cout majority function matches truth table","code":"from sympy.logic.boolalg import Xor\nA,B,C=symbols('A B C')\nCout=(A&B)|(C&Xor(A,B))\nrows={(a,b,c):int(bool(Cout.subs({A:a,B:b,C:c}))) for a in (0,1) for b in (0,1) for c in (0,1)}\nexpected={(0,0,0):0,(0,0,1):0,(0,1,0):0,(0,1,1):1,(1,0,0):0,(1,0,1):1,(1,1,0):1,(1,1,1):1}\nresult = rows==expected"}
]