Pearson Edexcel A Level Computer Science 9CS0
Every Big-O class, Boolean law, fetch-execute step, and assembly mnemonic from Topics 1–8 of the Pearson Edexcel A Level Computer Science specification (9CS0).
Our formula 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.
Edexcel A Level Computer Science (9CS0) blends theoretical computer science (algorithms, complexity, Boolean logic) with practical systems knowledge (CPU architecture, networks, security) and the 75-mark NEA project. This 2026 formula sheet condenses every numerical and structural rule across all 8 topics so you can revise efficiently for Papers 1, 2, and the project.
Big-O complexity classes for every searching and sorting algorithm
Boolean algebra laws including De Morgan's and Karnaugh maps
Fetch-execute cycle, registers, and assembly mnemonics
Network protocols, OSI/TCP-IP layers, and security threats
Problem-solving abstractions and how data is represented.
Problem-solving constructs.
Decomposition | Abstraction | Pattern recognition | Algorithm design — the four pillars Finite state machines (FSM): states, transitions, alphabet — accepting vs non-accepting; Mealy (output on transition) vs Moore (output on state) Regular expressions, BNF (Backus-Naur Form), context-free grammars Halting problem — undecidable: no algorithm can determine for all programs whether they will halt.
Integers, fixed and floating point.
Binary → Hex
Group bits in 4s from the right (1010 1111 = AF) Two's complement
Negative number: invert all bits, add 1; range with n bits = −2^(n−1) to +2^(n−1) − 1 Floating point (IEEE 754 single)
1 sign bit | 8 exponent bits (bias 127) | 23 mantissa bits — value = (−1)^s × 1.M × 2^(E−bias) Normalisation
Mantissa starts with the most significant 1 in the bit immediately after the point (binary) Multimedia data sizes.
Bitmap file size (bits)
Width × Height × Bit depth ÷ 8 (for bytes) Sound sampling — Nyquist
Sampling rate ≥ 2 × maximum frequency Sound file size (bits)
Sampling rate × Bit depth × Channels × Duration Lossy (JPEG, MP3) discards data; lossless (PNG, FLAC, ZIP) reversible — RLE, Huffman, dictionary coding Security primitives and key data structures.
Symmetric (AES) — same key both ends; Asymmetric (RSA) — public/private key pair; Hashing (one-way) for passwords; digital signatures combine hash + asymmetric encryption Arrays, records, queues (linear, circular, priority), stacks (LIFO), linked lists, hash tables (with collision: chaining or open addressing), graphs, trees (binary search trees) Binary search tree: left subtree < root < right subtree → O(log n) average search; degenerates to O(n) if unbalanced.
Searching, sorting, traversal, and complexity classes.
From fastest to slowest growth.
O(1) constant | O(log n) logarithmic | O(n) linear | O(n log n) linearithmic | O(n²) quadratic | O(2ⁿ) exponential | O(n!) factorial Best (Ω), worst (O), average (Θ) — Edexcel mostly tests worst-case.
Find an element in a collection.
Linear search
Check each element in turn → O(n); works on unsorted data Binary search
Halve the search range each step → O(log n); requires sorted data Binary tree search
Traverse left/right based on comparison → O(log n) average, O(n) worst (unbalanced) Memorise time complexities and stability.
Bubble sort
Repeated adjacent swaps → O(n²); simple, in-place Insertion sort
Insert each element into its correct position in the sorted prefix → O(n²); good for nearly-sorted data Merge sort
Divide-and-conquer recursive → O(n log n); not in-place (extra memory) Quicksort
Pivot partitioning → O(n log n) average, O(n²) worst (already sorted, bad pivot) Traversal and shortest-path.
Graph traversal — BFS (queue, level-order) | DFS (stack/recursion, deep first) Tree traversal — Pre-order (root → left → right) | In-order (left → root → right; gives sorted output for BST) | Post-order (left → right → root) Dijkstra's algorithm
Single-source shortest path on weighted graph (non-negative weights); priority queue O((V+E) log V) A* search
f(n) = g(n) + h(n) — actual + admissible heuristic; finds optimal path if h is admissible How programs are structured.
Procedural
Sequence of instructions, procedures/functions; e.g., C, Pascal Object-Oriented
Objects with state and behaviour; e.g., Java, Python, C++ Declarative — Logic
Facts and rules (e.g., Prolog) Declarative — Functional
Pure functions, immutability, recursion (e.g., Haskell, Lisp) The five pillars examiners ask for.
Class / object
Class is a blueprint; object is an instance Encapsulation
Bundle data + methods; restrict access via private/public modifiers Inheritance
Subclass inherits attributes and methods from a superclass; promotes reuse Polymorphism
Same interface, different behaviour — overriding (sub) and overloading (multiple signatures) Abstraction
Hide complexity behind a simple interface (abstract classes, interfaces) Recursion: base case + recursive case; uses the call stack (risk: stack overflow). Iteration: loops, faster, no stack risk. Exception handling: try / catch (handle) / finally (cleanup) / throw (raise) — e.g., Java, Python; checked vs unchecked exceptions CPU architecture, memory, storage, and operating systems.
Von Neumann vs Harvard, and what makes a CPU fast.
Von Neumann
Single memory and bus for instructions and data → simpler, but Von Neumann bottleneck Harvard
Separate instruction and data memory/bus → faster, used in embedded systems and DSPs Performance factors: clock speed (Hz), number of cores, cache size/levels (L1, L2, L3), pipelining, word size, FSB width Step-by-step what the CPU does.
Fetch
PC → MAR; memory at MAR → MDR; MDR → CIR; PC incremented Decode
CU decodes the instruction in CIR; identifies opcode and operands Execute
ALU performs the operation; result stored in ACC or written back to memory Registers
PC (Program Counter) | MAR (Memory Address Register) | MDR (Memory Data Register) | CIR (Current Instruction Register) | SR (Status Register / flags) | ACC (Accumulator) RAM (volatile, primary, read/write) | ROM (non-volatile, boot firmware) | Cache (small, fastest) | Virtual memory (disk used as RAM extension via paging) Storage: magnetic (HDD), solid-state (SSD, flash), optical (CD/DVD/Blu-ray) OS functions: process management, memory management, file management, device management (drivers), security, user interface Standard Edexcel/LMC instruction set.
Data movement
LDA <addr> — load from memory into ACC | STA <addr> — store ACC to memory Arithmetic
ADD <addr> — add memory to ACC | SUB <addr> — subtract memory from ACC Comparison & branching
CMP — compare | BRA <label> — unconditional branch | BRZ <label> — branch if zero | BRP <label> — branch if positive I/O
INP — read input into ACC | OUT — output ACC | HLT — halt Network architecture, protocols, and threats.
Layered architecture.
TCP/IP — 4 layers
Application | Transport (TCP/UDP) | Internet (IP) | Network access (Ethernet, Wi-Fi) OSI — 7 layers
Physical → Data Link → Network → Transport → Session → Presentation → Application IPv4 — 32-bit addresses (≈4.3 billion); IPv6 — 128-bit addresses; DNS resolves human-readable names to IPs Packet switching
Data split into packets, routed independently → efficient, fault-tolerant (the Internet) Circuit switching
Dedicated path established for entire session → traditional telephony Protocols
HTTP/HTTPS (web), FTP (file transfer), SMTP (send mail), POP3 (download mail, removes from server), IMAP (sync mail across devices) Hardware: routers (between networks), switches (within LAN), hubs (broadcast — obsolete), NICs, gateways Threats: malware (virus, worm, trojan, ransomware, spyware), phishing, social engineering, DoS/DDoS, SQL injection, MITM Defences: firewalls (packet filtering, stateful), encryption (TLS/HTTPS), strong authentication (2FA), proxies, IDS/IPS, regular patching, user training Ethics, law, and the 75-mark non-exam assessment.
Ethical, legal, and environmental considerations.
Ethics: privacy, surveillance, automation/job loss, AI bias, digital divide, accessibility (WCAG) UK legislation
Computer Misuse Act 1990 | Data Protection Act 2018 (UK GDPR) | Copyright, Designs & Patents Act 1988 | Regulation of Investigatory Powers Act 2000 Environmental: e-waste, energy consumption (data centres), green computing, sustainable development 75 marks — the most weighted single assessment.
Five stages: Analysis (problem, stakeholders, requirements) → Design (algorithms, UI, data structures) → Development (iterative, with testing) → Testing (functional, robustness, normal/boundary/erroneous) → Evaluation (against requirements + future improvements) Evidence each stage with annotated screenshots, test tables, and reflective commentary in the report.
Laws and Karnaugh-map simplification you will be tested on.
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 Commutative
A + B = B + A | A · B = B · A Associative
(A + B) + C = A + (B + C) | (A · B) · C = A · (B · C) Distributive
A · (B + C) = A·B + A·C | A + (B · C) = (A + B)·(A + C) De Morgan's
(A + B)' = Ā · B̄ | (A · B)' = Ā + B̄ AND (·) | OR (+) | NOT (¬/Ā) | NAND | NOR | XOR (⊕, exclusive OR) Karnaugh maps
Plot truth table on a Gray-code grid → group adjacent 1s in powers of 2 (1, 2, 4, 8...) → derive simplified SOP expression NAND and NOR are functionally complete — any Boolean expression can be built from either alone.
Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
Lock down O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ) and the typical algorithm in each class — this is the single most-asked algorithms topic.
Practise tracing every register (PC, MAR, MDR, CIR, ACC) through a 3–5 instruction program until you can talk through every step from memory.
Practise 5–10 Boolean simplification problems per week using identities and Karnaugh maps. Always state the law you applied at each step.
Write up Analysis, Design, and Testing as you build — not at the end. Annotated screenshots and test evidence in real time save weeks of retrofit work.
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 Pearson Edexcel A Level Computer Science (9CS0) with this 2026 formula sheet. Covers all 8 topics — computational thinking, data, algorithms, programming, computer systems, networks, issues, and the NEA — with … 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 algorithms, assembly tracing, and the NEA project with an experienced Pearson Edexcel A Level Computer Science tutor. We focus on theoretical precision, Big-O reasoning, and high-mark NEA documentation.
Pair this formula sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This formula sheet aligns with Pearson Edexcel A Level Computer Science (9CS0) specification content for assessment in 2026.
Always state Big-O complexity, justify algorithm choice, and reference the relevant law when simplifying Boolean expressions.