Cambridge International A Level Computer Science 9618
A complete revision companion for Cambridge A Level Computer Science (9618) — data representation, Boolean logic, algorithms, ADTs, networking, databases, the SDLC, and security in one printable sheet.
Our reference sheets are free to download — save this one as PDF for offline revision.
Aligned with the latest 2026 syllabus and board specifications. This sheet is prepared to match your exam board’s official specifications for the 2026 exam series.
Cambridge A Level Computer Science (9618) blends precise theory with applied problem-solving. This reference sheet pulls together the formulas, conventions, and frameworks examiners reward across Papers 1–4 — from binary arithmetic and Big-O analysis to OSI layers, normalisation, and pseudocode style.
Number bases, two's complement, and floating-point representation
Boolean algebra laws, logic gates, and Karnaugh maps
Sorting, searching, and Big-O complexity reference
OSI / TCP/IP networking and SQL / normalisation essentials
Number systems and binary arithmetic underpin almost every theory paper question.
Binary, denary, and hexadecimal conversions are routinely examined.
Binary → Denary
Sum of (bit × 2^position) starting from position 0 on the right Denary → Binary
Repeated division by 2; read remainders bottom-up Hex → Binary
Replace each hex digit with its 4-bit binary equivalent (0=0000, F=1111) Binary → Hex
Group bits into nibbles of 4 from the right; convert each nibble to a hex digit Standard method for representing negative integers in 9618.
Negate a binary number
Invert all bits, then add 1 n-bit range
−2^(n−1) to +2^(n−1) − 1 (e.g. 8-bit: −128 to +127) MSB rule
Most-significant bit = 1 indicates a negative number Overflow occurs when the sign of the result is inconsistent with the operands' signs.
Normalisation maximises precision; ASCII / Unicode encode characters.
Normalised form
Mantissa starts with 0.1 (positive) or 1.0 (negative) — first two bits differ Real value
value = mantissa × 2^exponent (both in two's complement) Character codes
ASCII = 7-bit (128 chars); Unicode = up to 32-bit (UTF-8/UTF-16/UTF-32) Simplify circuits and prove equivalence — common in Paper 3 theory questions.
AND (A·B), OR (A+B), NOT (Ā), NAND (A·B with overbar), NOR (A+B with overbar), XOR (A⊕B) Identity
A + 0 = A | A · 1 = A Null
A + 1 = 1 | A · 0 = 0 Idempotent
A + A = A | A · A = A Complement
A + Ā = 1 | A · Ā = 0 De Morgan's
¬(A · B) = Ā + B̄ | ¬(A + B) = Ā · B̄ Distributive
A · (B + C) = A·B + A·C Group adjacent 1s in powers of 2 (1, 2, 4, 8) including wrap-around.
Larger groups simplify the expression more — always cover every 1 with the largest valid group. Use don't-care conditions (X) to extend groupings where outputs are unspecified.
Know each algorithm's behaviour and the data structures used to implement it.
Bubble sort
Best O(n), Average O(n²), Worst O(n²) — adjacent swap; use a flag to detect early termination Insertion sort
Best O(n), Average O(n²), Worst O(n²) — efficient on small / nearly-sorted data Merge sort
O(n log n) all cases — divide-and-conquer; needs O(n) extra space Quick sort
Best/Average O(n log n), Worst O(n²) — pivot selection matters Linear search
O(n) worst case; works on unsorted data Binary search
O(log n); requires a sorted list; halve the search space each iteration Logical data structures examined in both Paper 3 and Paper 4.
Stack (LIFO)
Operations: push, pop, peek, isEmpty. Used in function calls and expression evaluation Queue (FIFO)
Operations: enqueue, dequeue, isEmpty. Circular queues use front/rear pointers modulo array size Linked list
Each node stores data + pointer to next node; head pointer accesses the list Binary tree
Traversals: pre-order (N-L-R), in-order (L-N-R), post-order (L-R-N) Hash table
key → index via hash function; handle collisions via chaining or open addressing Cambridge has a specific pseudocode style — examiners deduct marks for incorrect syntax.
DECLARE Identifier : DataType (e.g. DECLARE Total : INTEGER) CONSTANT Pi = 3.14159 Data types
INTEGER, REAL, STRING, CHAR, BOOLEAN, DATE IF...THEN...ELSE
IF condition THEN ... ELSE ... ENDIF CASE
CASE OF identifier value1 : ... value2 : ... OTHERWISE : ... ENDCASE FOR
FOR i ← 1 TO 10 ... NEXT i WHILE
WHILE condition DO ... ENDWHILE (condition tested at top) REPEAT
REPEAT ... UNTIL condition (condition tested at bottom; runs at least once) PROCEDURE Name(params) ... ENDPROCEDURE → called with CALL Name(args) FUNCTION Name(params) RETURNS DataType ... RETURN value ... ENDFUNCTION Parameter passing
BYVAL (default) passes a copy; BYREF passes a reference OPENFILE "data.txt" FOR READ / WRITE / APPEND / RANDOM READFILE / WRITEFILE / CLOSEFILE Always close files after use to free system resources.
Layered models, addressing, and relational design appear every series.
OSI (7 layers)
Application | Presentation | Session | Transport | Network | Data Link | Physical TCP/IP (4 layers)
Application | Transport | Internet | Network Access Bandwidth vs latency
Bandwidth = max data rate (bps); latency = round-trip delay (ms) Throughput
Actual useful data rate, always ≤ bandwidth due to overhead and congestion IPv4
32-bit; written as four octets, e.g. 192.168.1.10 IPv6
128-bit; written as eight 16-bit hex groups, e.g. 2001:0db8::1 Public vs private
Private ranges: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 Subnet mask
Identifies network vs host portion of an IP (e.g. /24 = 255.255.255.0) 1NF
Eliminate repeating groups; every cell holds a single atomic value; primary key identifies each row 2NF
1NF + remove partial dependencies (every non-key attribute depends on the WHOLE primary key) 3NF
2NF + remove transitive dependencies (non-key attributes depend ONLY on the primary key) SELECT
SELECT col1, col2 FROM table WHERE condition ORDER BY col1 ASC|DESC; JOIN
SELECT ... FROM A INNER JOIN B ON A.id = B.aId; Aggregates
COUNT(*), SUM(col), AVG(col), MIN(col), MAX(col) — combine with GROUP BY ... HAVING ... Modify data
INSERT INTO table (cols) VALUES (...); UPDATE table SET col = val WHERE ...; DELETE FROM table WHERE ...; Examiners want clear distinctions between models and roles.
Waterfall
Linear: Analysis → Design → Implementation → Testing → Maintenance. Hard to revisit earlier stages Iterative
Repeated cycles refine the system; useful when requirements evolve Rapid Application Development (RAD)
Prototype-driven; heavy user involvement; short timescales Agile
Short sprints, working software each iteration, responsive to change White-box
Tests internal logic / code paths Black-box
Tests inputs vs expected outputs without internal knowledge Levels
Unit → Integration → System → Acceptance Test data
Normal, boundary, and erroneous (invalid) values Distinguish encryption (reversible) from hashing (one-way).
Symmetric
Same key encrypts and decrypts (e.g. AES). Fast, but key distribution is hard Asymmetric
Public key encrypts, private key decrypts (e.g. RSA). Solves key exchange but slower Digital signature
Sender hashes message, encrypts hash with private key. Receiver decrypts with public key and compares hashes One-way function: easy to compute hash from data, infeasible to reverse Used for password storage and integrity checks (e.g. SHA-256).
Something you know (password) | Something you have (token / phone) | Something you are (biometric) Multi-factor authentication (MFA)
Combines two or more independent factors above Practical application papers reward clean code, dry-runs, and full trace tables.
Read the scenario twice — underline inputs, processes, and outputs before writing pseudocode. Use trace tables to walk through loops; show each iteration row, including the loop counter and any flag. Use Cambridge pseudocode style consistently — incorrect syntax loses easy marks.
Choose ONE language (VB.NET, Python, or Pascal/Delphi) and stay consistent across the paper. Validate inputs (range, type, presence) before processing; use functions/procedures to modularise. Comment key sections briefly — examiners credit clear intent when code is partially correct. Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
Write out bubble sort, insertion sort, binary search, and stack/queue operations on paper. Examiners regularly ask for traces and partial implementations.
Use Cambridge's exact conventions — DECLARE, ←, ENDIF, NEXT i. Inconsistent syntax costs marks even when the logic is right.
Take a flat data set and normalise it to 3NF. Identify partial and transitive dependencies explicitly — this is a near-certain Paper 3 question.
A common Paper 3 mark is lost by confusing the two. Hashing is one-way; encryption is reversible with the right key.
Quick answers about this free PDF and how to use it for exam revision and active recall.
Yes. This Tutopiya formula sheet is free to use and you can download it as a PDF from this page for offline revision. There is no payment or account required for the PDF download.
This page groups key Computer Science formulas in one place for revision. Master Cambridge A Level Computer Science (9618) with this 2026 reference sheet. Covers data representation, Boolean algebra, algorithms, ADTs, networking, databases, the SDLC, and security essentials for Papers 1–4. Always cross-check with your official syllabus and past papers for your exam session.
No. In the exam you must follow only what your exam board allows in the hall—usually the official formula booklet or data sheet where provided. This page is a revision and teaching aid, not a replacement for board-issued materials.
It is written for students preparing for assessments at Post-Secondary in Computer Science, including classroom revision, homework support, and independent study. Teachers and tutors can also share it as a quick reference.
Work through past paper questions, quote the correct formula before substituting values, and check units and notation every time. Pair this sheet with timed practice and mark schemes so you see how examiners expect working to be set out.
Explore Tutopiya’s study tools, past paper finder, and revision checklists linked from our tools hub, or book a trial lesson with a subject specialist for personalised support alongside this formula reference.
Work through 9618 theory and programming questions with an experienced Cambridge A Level Computer Science tutor. We focus on pseudocode precision, algorithm design, and Paper 4 implementation strategies.
Pair this reference sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This reference sheet aligns with Cambridge Assessment International Education International A Level Computer Science (9618) syllabus content.
Always use Cambridge's official pseudocode conventions and verify algorithm complexity using the methodology in the syllabus.