Pearson Edexcel International GCSE (9–1) Computer Science - Exhaustive Study Notes

EDEXCEL INTERNATIONAL GCSE (9–1) COMPUTER SCIENCE OVERVIEW AND STRUCTURE

Authorship and Publication Information: * Authors: David Waller, Chris Charles, Pete Dring, Alex Hadwen-Bennett, Jason Welch, Shaun Whorton. * Series Editor: Ann Weidmann. * Publisher: Pearson Education Limited, 80 Strand, London. * ISBN: 978 1 292 31022 0. * Official Website: https://qualifications.pearson.com.
Course Structure (Units 1–6): * Unit 1: Problem Solving (Page 2). * Unit 2: Programming (Page 32). * Unit 3: Data (Page 108). * Unit 4: Computers (Page 158). * Unit 5: Communication and the Internet (Page 200). * Unit 6: The Bigger Picture (Page 242). * Exam Preparation (Page 272).
Assessment Overview: * Paper 1: Principles of Computer Science (4CP0/01): * Weighting: $50\%$ of total marks. * Mark Total: $80$ marks. * Duration: $2$ hours. * Availability: January, June, and October. * Structure: Multiple-choice, short open-response, open-response, and extended open-response questions. * Paper 2: Application of Computational Thinking (4CP0/02): * Weighting: $50\%$ of total marks. * Mark Total: $80$ marks. * Duration: $3$ hours. * Programming Languages: Python, C#, or Java. * Structure: Task-based questions carried out on a computer, plus traditional written responses.
Assessment Objectives (AO): * AO1: Demonstrate knowledge and understanding of key principles ( $27.5\%$ overall). * AO2: Apply knowledge and understanding of key concepts ( $42.5\%$ overall). * AO3: Analyse problems in computational terms to design, program, test, evaluate, and refine solutions ( $30\%$ overall).

UNIT 1: PROBLEM SOLVING – UNDERSTANDING ALGORITHMS

Definition of an Algorithm: * An algorithm is a precise, unambiguous method for solving a problem. * Subject Vocabulary: * Unambiguous: Instructions that cannot be misunderstood (e.g., "turn left" vs. "turn"). * Sequence: An ordered set of instructions. * Construct: A command to control the flow (sequence, selection, repetition).
Characteristics of Successful Algorithms: * Accuracy: Must lead to the expected outcome. * Consistency: Must produce the same result every time it is run. * Efficiency: Must solve the problem in the shortest possible time using minimal computer resources.
Expressing Algorithms: * Written Descriptions: Simple text-based steps (e.g., instructions for making a cup of coffee). * Flowcharts: Visual diagrams using specific symbols: * Oval (Start/End): Indicates initiation or termination. * Parallelogram (Input/Output): Indicates data entry or display. * Rectangle (Process): Indicates an action to be performed. * Diamond (Decision): Indicates a choice (Yes/No). * Arrows: Show the logical flow of the algorithm. * Pseudocode: A structured, code-like language used to describe logic without specific language syntax rules.
Arithmetic Operators in Pseudocode: * Addition (+): Adds values ( $8 + 5 = 13$ ). * Subtraction (-): Subtracts second from first ( $17 - 4 = 13$ ). * Multiplication (): Multiplies values ( $6 \times 9 = 54$ ). Real Division (/): Divides and returns decimals ( $13 / 4 = 3.25$ ). * Integer Division (DIV): Returns only the whole number part ( $13 \text{ DIV } 4 = 3$ ). * Modulus (MOD): Returns the remainder ( $13 \text{ MOD } 4 = 1$ ). * Exponentiation (^): To the power of ( $3^3 = 3 \times 3 \times 3 = 27$ ).
Variables and Constants: * Variable: A container for data that can change during execution (e.g., total, firstName). * Constant: A container for data that stays the same (e.g., pi, monthsInYear). * Naming Conventions: Camel Case (firstName), Pascal Case (FirstName), or Snake Case (first_name).

UNIT 1: CREATING ALGORITHMS & SORTING/SEARCHING

Core Programming Constructs: * Sequence: Step-by-step instructions in order. * Selection: Allows a choice between alternatives (e.g., IF statements). * Iteration: A process repeated until a condition is met (often called a "loop").
Sorting Algorithms: * Bubble Sort: * Method: Compares adjacent pairs and swaps them if in the wrong order. This continues in "passes" until a full pass occurs with no swaps. * Category: Brute Force algorithm. * Merge Sort: * Method: Divides a list into halves repeatedly until each list has one item, then merges them back in order. * Category: Divide and Conquer algorithm. * Efficiency: Significantly faster than Bubble Sort for lists larger than $1000$ items.
Searching Algorithms: * Linear Search: * Method: Sequential search from the start to the end of a list. * Requirement: Works on unsorted lists. * Binary Search: * Method: Selects the median (middle value) and determines if the target is higher or lower, discarding the half that doesn't contain the target. Repeated through recursion. * Requirement: The list must be sorted beforehand. * Efficiency Example ( $1000$ items): * Linear Search Worst Case: $1000$ comparisons (Average $500$ ). * Binary Search Worst Case: $10$ comparisons.

UNIT 1: DECOMPOSITION AND ABSTRACTION

Computational Thinking Components: * Decomposition: Breaking a complex problem into smaller, manageable sub-problems (e.g., breaking "Noughts and Crosses" into interface, logic, and win-condition subprograms). * Abstraction: Removing or hiding unnecessary details to focus on important points (e.g., a flight simulator models flight physics but ignores the seat fabric color).
Computational Logic in Problem Solving: * Analyzing requirements involves defining Inputs, Outputs, Processing, and Initialisation.

UNIT 2: PROGRAMMING – DATA TYPES AND CONSTRUCTS

Data Types: * Integer: Whole numbers (e.g., $30$ ). * Real / Float: Numbers with fractional parts (e.g., $25.5$ ). * Boolean: Two values (True or False). * Character: A single letter, symbol, or space (e.g., 'm'). Note: Python does not have a dedicated character type. * String: A sequence of characters (e.g., "Catherine").
Type Coercion: Converting the value of a variable from one data type to another (e.g., an Integer mixed with a Real in a calculation results in a Real).
Relational and Logical Operators: * Relational: == (Equal), != (Not equal), > (Greater), < (Less), >= and <=. * Logical: AND, OR, NOT.
Iteration (Loops): * Definite: Used when the number of repetitions is known (e.g., FOR loops). * Indefinite: Used when the duration depends on a condition (e.g., WHILE loops).
Data Structures: * 1D Array/List: Organised collection of related values of the same type. * 2D Array: Matrix of rows and columns (e.g., results[row, column]). * Record: A structure storing related values of different data types; individual elements are called fields.

UNIT 2: INPUT/OUTPUT, SUBPROGRAMS, AND TESTING

Validation Techniques (Ensuring data is reasonable): * Range Check: Within specified limits. * Presence Check: Ensures data was entered. * Look-up Check: Compares input against a predefined list. * Length Check: Ensures input has the correct number of characters.
External File Handling: * File Handle: Label assigned to access a file. * Operations: Open (Read 'r', Write 'w', Append 'a'), Write, Close.
Subprograms: * Functions: Perform a task and return a value to the main program. * Procedures: Perform a task but do not return a value. * Parameters: Variables in the subprogram that receive values. * Arguments: Actual values passed into the subprogram. * Scope: * Local Variable: Exists only within the subprogram. * Global Variable: Accessible throughout the entire program.
Error Types: * Logic Error: Thought process is wrong; code runs but gives the wrong output (fix with Trace Tables). * Syntax Error: Breaking grammar rules of the language; prevents execution. * Runtime Error: Program crashes during execution (e.g., division by zero).
Testing Categories: * Normal Data: Well within limits. * Boundary Data: At the outer edges (min/max) of acceptance. * Erroneous Data: Data that should be rejected (e.g., negative age).