OCR A Level Computer Science H446
All the laws, algorithms and equations you need for OCR A Level Computer Science (H446) — Boolean algebra, complexity, networking, OOP and data representation — for 2026 exams.
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.
OCR A Level Computer Science (H446) examines computer systems (Component 1) and algorithms & programming (Component 2). This 2026 sheet collects every Boolean law, complexity class, algorithm template and data representation formula in one organised reference.
CPU architecture, registers and FDE cycle
Networking: TCP/IP, OSI, IP addressing, encryption
Algorithm complexity: searching, sorting, graphs
Boolean algebra, De Morgan's, K-maps, data representation
Von Neumann, FDE cycle, registers and performance factors.
Von Neumann
Single shared memory and bus for instructions and data Harvard
Separate memory and buses for instructions and data (used in DSPs, embedded systems) Contemporary
Pipelining, multi-core, cache hierarchies, parallel processing Fetch
PC → MAR ; memory[MAR] → MDR ; MDR → CIR ; PC++ Decode
Control unit decodes instruction in CIR Execute
Operation performed (e.g. ALU); result may go to ACC; status flags updated in SR PC (Program Counter), MAR (Memory Address Register), MDR (Memory Data Register), CIR (Current Instruction Register), ACC (Accumulator), SR (Status Register) Clock speed (Hz, instructions/sec), cache size & levels (L1/L2/L3), number of cores, pipelining (overlap fetch/decode/execute) LDA (load), STA (store), ADD, SUB, CMP (compare), BRA (branch always), BRZ (branch if zero), BRP (branch if positive), INP, OUT, HLT Memory hierarchy, storage media, TCP/IP and OSI models.
RAM (volatile, R/W) ; ROM (non-volatile, factory-set firmware) ; Cache (small, fast) ; Virtual memory (disk used as RAM via paging) Storage: magnetic (HDDs, tapes — moving parts), SSD (flash, no moving parts), optical (CD/DVD/Blu-ray — pits & lands) Application (HTTP/HTTPS, SMTP, FTP) → Transport (TCP/UDP) → Internet (IP) → Network/Link (Ethernet, Wi-Fi) Physical → Data Link → Network → Transport → Session → Presentation → Application Data split into packets, each routed independently and reassembled at destination using sequence numbers IPv4
32-bit, written as four 8-bit octets (e.g. 192.168.1.1) — ~4.3 × 10⁹ addresses IPv6
128-bit, written as eight 16-bit hex blocks — vastly larger address space Subnet mask
Identifies network vs host portion (e.g. /24 = 255.255.255.0) Symmetric: same key for encrypt/decrypt (AES) — fast but key-distribution problem Asymmetric (e.g. RSA): public key encrypts, private key decrypts — solves key distribution Hashing (one-way): SHA-256, used for password storage and integrity checks Digital signature: hash of message encrypted with sender's private key — verifies authenticity & integrity HTML (structure), CSS (presentation), JavaScript (client-side behaviour) Client-server model: client requests, server responds (HTTP/HTTPS) Search engine PageRank: PR(A) = (1 − d) + d Σ PR(Tᵢ)/C(Tᵢ) where d = damping factor ≈ 0.85 Big-O for searching, sorting and graph algorithms.
Linear search
O(n) ; works on unsorted data Binary search
O(log n) ; requires sorted data; halves search space each step Bubble sort
Best O(n), Average O(n²), Worst O(n²) ; in-place Insertion sort
Best O(n), Average O(n²), Worst O(n²) ; efficient for small/nearly sorted lists Merge sort
O(n log n) all cases ; stable, requires extra memory Quick sort
Average O(n log n), Worst O(n²) (poor pivot) ; usually in-place Dijkstra
Shortest path from source in weighted graph (non-negative weights), O((V + E) log V) with priority queue A*
Shortest path using heuristic h(n); f(n) = g(n) + h(n) where g = cost so far, h = estimated cost to goal BFS
O(V + E), uses a queue, finds shortest path in unweighted graphs DFS
O(V + E), uses a stack (or recursion), explores deeply before backtracking Pre-order
Root → Left → Right In-order
Left → Root → Right (BST → sorted output) Post-order
Left → Right → Root Common structures and OOP/programming paradigms.
Array — fixed size, O(1) access by index Linked list — dynamic, O(n) access, O(1) insert/delete (given node) Stack — LIFO, push/pop O(1) Queue — FIFO, enqueue/dequeue O(1) Hash table — average O(1) lookup, collisions handled by chaining or open addressing Graph — vertices V, edges E ; represented by adjacency list (sparse) or adjacency matrix (dense) Encapsulation
Bundle data + methods, hide internal state via private fields and public getters/setters Inheritance
Child class inherits attributes & methods from parent (is-a relationship) Polymorphism
Same interface, multiple implementations (overriding, overloading) Abstraction
Expose only essential features; hide complexity behind well-defined interfaces Procedural — sequence of instructions, e.g. C, Python (procedural style) Object-oriented — classes & objects, e.g. Java, C++ Functional — pure functions, no side effects, e.g. Haskell, Lisp Declarative — describe what, not how, e.g. SQL, Prolog Boolean laws, De Morgan's, K-maps and logic gates.
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 Double negation
Ā̄ = A Distributive
A · (B + C) = A·B + A·C ; A + (B · C) = (A + B)(A + C) Absorption
A + A·B = A ; A · (A + B) = A (A + B)' = Ā · B̄ (A · B)' = Ā + B̄ AND: 1 only if both inputs 1 ; OR: 1 if any input 1 ; NOT: inverts NAND: NOT(AND) — universal gate ; NOR: NOT(OR) — universal gate XOR: 1 only if inputs differ (A ⊕ B = A·B̄ + Ā·B) Group 1s in rectangles of size 2ⁿ (1, 2, 4, 8) — adjacent cells differ by one variable (Gray-code ordering) Larger groups = simpler terms; combine all minimal groups for the simplified SOP expression.
Number systems, two's complement, IEEE 754, character & sound encoding.
Binary (base 2): bits 0/1 ; Hex (base 16): 0–9, A–F (A=10, …, F=15) Convert binary → hex by grouping 4 bits ; e.g. 1011 0110₂ = B6₁₆ = 182₁₀ Most significant bit is sign bit (0 = positive, 1 = negative) To negate a number: invert all bits and add 1 (e.g. +5 = 00000101 → −5 = 11111011) Range for n bits: −2ⁿ⁻¹ to 2ⁿ⁻¹ − 1 Number = (−1)^sign × mantissa × 2^exponent Normalisation: shift mantissa so leading bit is 1 (positive) or 0 (negative); adjust exponent accordingly ASCII
7-bit (128 chars) — extended to 8-bit (256 chars) Unicode
Up to 32-bit code points; UTF-8 variable-length 1-4 bytes; supports virtually all writing systems Sampling rate
Samples per second, measured in Hz (e.g. CD = 44.1 kHz) Bit depth
Bits per sample (e.g. 16-bit) determines amplitude resolution Nyquist theorem
Sampling rate ≥ 2 × highest frequency to reconstruct signal accurately Audio file size (bits)
= sample rate × bit depth × duration × channels Resolution = width × height pixels ; bit depth = bits per pixel (e.g. 24-bit colour = 8 bits each R/G/B) Image file size
size (bytes) = (width × height × bit depth) / 8 Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
OCR exam questions test trace tables for assembly, sorts and recursion. Practise tracing line-by-line — speed and accuracy here protect easy marks.
Sort/search Big-O appears every year. Build a one-page cheat card and review it weekly until best/avg/worst case for each algorithm is reflexive.
Drill De Morgan's, K-maps and absorption laws. Always simplify to fewest literals — OCR mark schemes reward minimal expressions.
Component 3 (NEA) is 20% of the grade — start scoping early so your analysis, design and testing match the marking criteria.
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. OCR A Level Computer Science (H446) formula sheet for 2026: CPU architecture, networking, Boolean algebra, De Morgan's laws, algorithm complexity, sorting & searching, OOP and data representation. 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 Upper 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.
Master algorithms, Boolean algebra, networking and the NEA with an experienced OCR A Level Computer Science tutor. We focus on H446 specification, exam technique and project planning.
Pair this formula sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This formula sheet aligns with OCR A Level Computer Science (H446) for the 2026 exam series.
OCR provides limited reference material in the exam — Boolean laws, complexity classes and assembly mnemonics generally need to be memorised.