Pearson Edexcel UK GCSE Computer Science 1CP2
Every formula and core concept for Edexcel GCSE Computer Science (1CP2) — binary and hex, two's complement, CPU architecture, image and sound file size, networks, sorts/searches and exam technique for Paper 1 and Paper 2.
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.
Pearson Edexcel GCSE Computer Science (1CP2 — the current specification, replacing the legacy 1CP1) tests your understanding of how computer systems are built, how data is stored and transmitted, and how to design algorithms and write code. This formula sheet brings together the data-representation formulas, architectural concepts, and algorithmic complexity classes you need across the written Paper 1 and the on-screen programming Paper 2.
Binary, hex, two's complement, ASCII / Unicode conversions
Image and sound file-size formulas with worked examples
CPU architecture, fetch-execute cycle, registers, memory hierarchy
Networks, OSI vs TCP/IP layers, security and algorithmic complexity
Numbers, characters, images, and sound — all stored as binary.
Binary → denary
Sum the place values of each '1' bit (e.g. 1011₂ = 8 + 0 + 2 + 1 = 11) Denary → binary
Repeatedly divide by 2 and read remainders bottom-up, OR subtract largest powers of 2 Hex → binary
Each hex digit = 4 binary bits (e.g. 2F = 0010 1111) Hex → denary
(First digit × 16) + second digit (e.g. 2F = 2×16 + 15 = 47) Hex is used because it's compact and maps cleanly to binary — 1 hex digit = 1 nibble = 4 bits.
Used to represent negative numbers in a fixed number of bits.
Convert positive to negative
Flip all bits then add 1 (e.g. +5 = 00000101 → flip to 11111010 → +1 = 11111011 = −5) Most-significant bit (MSB)
0 = positive, 1 = negative Range (n bits)
−2^(n−1) to +2^(n−1) − 1 (e.g. 8-bit: −128 to +127) ASCII
7-bit code; 128 characters. 'A'=65, 'a'=97, '0'=48. Letters are sequential — 'B'=66, 'b'=98. Extended ASCII
8 bits → 256 characters Unicode
Up to 32 bits — supports every language and emoji. Larger storage but universal compatibility. Bitmap images are grids of pixels.
Resolution
Width × Height in pixels (e.g. 800 × 600) Colour depth (bits per pixel)
Determines number of colours = 2^(colour depth) (e.g. 8-bit = 256 colours, 24-bit = ~16.7M colours) File size (bits)
Width × Height × Colour depth File size (bytes)
(Width × Height × Colour depth) ÷ 8 Higher resolution and colour depth = better quality but bigger file size.
Analogue sound is sampled at intervals to produce digital audio.
Sampling rate (Hz)
Number of samples per second Bit depth
Number of bits used for each sample File size (bits)
Sampling rate × Duration × Bit depth × Number of channels File size (bytes)
(Sampling rate × Duration × Bit depth × Channels) ÷ 8 Higher sampling rate and bit depth = better quality but bigger file size. CD-quality = 44.1 kHz, 16-bit, stereo.
Hierarchy
1 bit → 1 byte (8 bits) → 1 KB (1000 B) → 1 MB → 1 GB → 1 TB → 1 PB Edexcel uses decimal prefixes (×1000) by default — kibi/mebi (×1024) only if specified.
The mathematical basis of every digital circuit and program decision.
Output = A AND B
1 only if BOTH inputs are 1. Truth table: 0,0→0 | 0,1→0 | 1,0→0 | 1,1→1 Output = A OR B
1 if EITHER input is 1. Truth table: 0,0→0 | 0,1→1 | 1,0→1 | 1,1→1 Output = NOT A
Inverts the input. Truth table: 0→1 | 1→0 Example
X = (A AND B) OR (NOT C). Build truth table column-by-column: A, B, C, A AND B, NOT C, X. Always include every input combination — for n inputs you need 2^n rows.
How the processor and memory work together to run programs.
Program instructions and data are stored in the same memory and accessed by the same bus. CPU contains the Control Unit (CU), Arithmetic Logic Unit (ALU), and registers. Fetch
Address from PC → MAR. Memory contents → MDR. Instruction copied into CIR. PC incremented. Decode
Control Unit decodes the instruction in CIR Execute
ALU performs the operation; result stored in ACC or memory PC (Program Counter)
Holds the address of the NEXT instruction MAR (Memory Address Register)
Holds the address of memory currently being read/written MDR (Memory Data Register)
Holds the data being transferred to/from memory ACC (Accumulator)
Holds intermediate results from the ALU CIR (Current Instruction Register)
Holds the instruction currently being executed Clock speed (Hz)
Number of cycles per second — higher = more instructions per second Number of cores
Each core can run instructions independently — more cores = better multitasking Cache size
Faster small memory between CPU and RAM. L1 (smallest, fastest) → L2 → L3 (largest, slowest) RAM
Volatile — loses contents when power off. Stores currently-running programs and data. Read/write. ROM
Non-volatile — keeps contents without power. Read-only. Stores the boot loader (firmware/BIOS). Virtual memory
When RAM is full, part of secondary storage (HDD/SSD) is used as 'extra RAM'. Slower than RAM (page swapping) but prevents crashes. HDD (magnetic)
Cheap per GB, large capacity, but slower, fragile, mechanical SSD (solid state)
Faster, silent, more durable, lower power, but more expensive per GB and limited write cycles Optical (CD/DVD/Blu-ray)
Cheap, portable, durable, but small capacity and slow Choice factors
Capacity, speed, portability, durability, cost per GB How data is transmitted between devices.
LAN (Local Area Network)
Small geographic area (one site/building) — owned by the organisation WAN (Wide Area Network)
Large geographic area (countries/global) — usually leased lines (e.g. the internet) Bus
All devices on one shared cable. Cheap, but collisions and single point of failure. Star
All devices connect to a central switch/hub. Reliable and fast, but central failure breaks the network. Mesh
Every device connects to every other (full) or to multiple others (partial). Highly resilient but expensive cabling. TCP/IP layers (4)
Application → Transport → Internet → Link OSI layers (7)
Application → Presentation → Session → Transport → Network → Data Link → Physical Layering means each layer handles a specific job, making protocols modular and easier to maintain.
IP address (logical)
Identifies a device on a network. IPv4 = 32 bits (e.g. 192.168.0.1). IPv6 = 128 bits (longer, more addresses). MAC address (physical)
48-bit hex address burned into the network interface card. Unique to each NIC. Data is split into packets, each with a header (source/destination IP, sequence number, error check). Packets travel different routes and are reassembled at the destination. Efficient and resilient. Threats and the controls that defend against them.
Virus
Attaches to a host file; spreads when the file runs Worm
Self-replicating; spreads across networks without user action Trojan
Disguised as legitimate software; opens a backdoor when run Ransomware
Encrypts files and demands payment for the decryption key Spyware / Keylogger
Records activity (keystrokes, screenshots) and sends to attacker Phishing
Fake emails/sites trick users into revealing credentials Shouldering / Shoulder surfing
Observing PIN/password entry over someone's shoulder Pretexting
Attacker invents a believable story to extract information Technical
Firewalls, antivirus, encryption, access controls, multi-factor authentication, automatic updates / patching Policy
Strong password policies, user training, principle of least privilege, regular backups, network segmentation Searches, sorts and big-O notation — required for Paper 1 and Paper 2.
Linear search
Check each element from start until match found. O(n). Works on any list, sorted or not. Binary search
Repeatedly halve a SORTED list — compare middle, go left or right. O(log n). Much faster but requires a sorted list. Bubble sort
Compare adjacent pairs and swap if out of order. Repeat until no swaps. Easy but slow — O(n²). Insertion sort
Build sorted portion one element at a time, inserting each into its correct position. O(n²) average; fast on small/nearly-sorted lists. Merge sort
Divide list in half recursively, then merge sorted halves back together. O(n log n) — fastest of the three but uses more memory. O(1)
Constant — same time regardless of input size (e.g. accessing array index) O(log n)
Logarithmic — time grows slowly (binary search) O(n)
Linear — time grows in proportion to input (linear search) O(n log n)
Linearithmic — efficient for large data (merge sort) O(n²)
Quadratic — time grows with the square of input (bubble sort, insertion sort) Core constructs you'll see in Paper 2 (on-screen programming task) and Paper 1 algorithm questions.
Variable
Named storage that CAN change during execution Constant
Named storage that CANNOT change during execution Array (1D)
Indexed list of values of the same type. Access with name[index] (usually 0-based). 2D array
Grid of values — name[row][col] File
Persistent storage on secondary device. Open → read/write → close. Sequence
Statements run one after another, in order Selection
IF / ELIF / ELSE — choose a branch based on a condition Iteration (count-controlled)
FOR loop — repeat a fixed number of times Iteration (condition-controlled)
WHILE loop — repeat while a condition is true Procedure
Reusable block of code; does NOT return a value Function
Reusable block of code; RETURNS a value Parameters
Inputs passed in when the subroutine is called Subroutines support modularity, reusability, and easier debugging.
Edexcel uses one written paper and one on-screen programming paper.
1h 30m, 75 marks, 50% of GCSE. Covers theory: data representation, computer systems, networks, cyber security, ethical/legal issues. Practise 6- and 9-mark extended answers — use clear paragraphs, technical vocabulary, and worked examples.
2h, 75 marks, 50% of GCSE. On-screen, programming-focused. You decompose a problem, design algorithms (pseudocode/flowchart), then code in your chosen high-level language (Python or C#). Test your code with normal, boundary, and erroneous data. Use meaningful identifiers and comments.
Pseudocode keywords
INPUT, OUTPUT / PRINT, IF/THEN/ELSE/ENDIF, WHILE/ENDWHILE, FOR/ENDFOR, FUNCTION/RETURN, ← (assignment) Flowchart shapes
Oval = start/end | Parallelogram = input/output | Rectangle = process | Diamond = decision | Arrow = flow Boost your Cambridge exam confidence with these proven study strategies from our tutoring experts.
Binary ↔ denary ↔ hex conversions appear every year. Drill them daily until they take under 30 seconds — these are easy marks you cannot afford to lose.
Paper 2 is on-screen programming — there is no substitute for writing code. Aim for 30 minutes of Python/C# practice every day in the run-up to the exam.
Trace tables are a guaranteed question type. Set out columns for every variable that changes, and update one row per iteration.
Be able to walk through bubble, merge and insertion sort + linear and binary search step-by-step. Examiners reward correctly-stated algorithm logic over vague descriptions.
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 GCSE Computer Science (1CP2) with this 2026 formula sheet. Covers binary, hex, two's complement, CPU architecture, image/sound file size, networks, big-O for sorts and searches, and exam techniq… 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 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 binary, algorithms, and live programming tasks with an experienced Edexcel GCSE Computer Science tutor. We focus on Paper 2 coding fluency and the high-mark theory questions in Paper 1.
Pair this formula sheet with past papers, revision checklists, and planners — all free on our study tools hub.
This formula sheet aligns with the Pearson Edexcel UK GCSE Computer Science (1CP2) specification examined in 2026 — the current spec replacing the legacy 1CP1.
Always show working for binary/hex/file-size conversions, and test code against normal, boundary and erroneous inputs in Paper 2.