Section A (60 marks - 12 questions, ALL required)
Q#
Topic
Specific Content
1
Programming
JavaScript operators (*, **, /, %, ++)
2
Hardware/Storage
Storage units (GB, TB), HDD vs SSD comparison
3
Computer Architecture
Program counter - purpose
4
Networking
Protocols - definition and examples (WWW infrastructure)
5
Logic Circuits
Half-adder circuit - outputs from inputs
6
Data Representation
ASCII - importance and limitations of encoding standards
7
Number Systems
Binary to hexadecimal conversion
8
Algorithms
Bubble sort - completing algorithm passes
9
Data Quality
Data cleaning - identifying problems in datasets
10
Web Development
HTML structure and syntax
11
Programming
JavaScript conditional logic debugging
12
Algorithms
Heuristics - travelling salesperson problem
Section B (70 marks - 3 questions, ALL required)
Q#
Main Topic
Sub-topics
13
Search Algorithms
Linear search implementation, binary search, time complexity, algorithmic efficiency
14
Theory of Computation
Turing Machines, Finite State Machines, state transitions, AI and society
15
Software Development
Rock Paper Scissors game project - SDLC, team roles, UI design, adaptive technology
Section A (30 marks - answer any 6 of 12)
Q#
Topic
Specific Content
1
Programming
Python code tracing - variables and operators
2
Data Representation
Binary format storage, bits to information conversion
3
Hardware
RAM vs ROM differences, RAM performance impact
4
Algorithms
Variable swapping problem
5
Algorithms
Flowchart tracing and interpretation
6
Programming Logic
Python conditionals - fairness in algorithms
7
Networking
HTTP vs HTTPS, TCP protocol
8
Data Representation
Unicode, emoji characters, hexadecimal to binary
9
Operating Systems
OS definition and layers/functions
10
Software Development
Project manager tasks, low-level vs high-level programming
11
Modelling & Simulation
Benefits of computer modelling, agent-based modelling (COVID-19)
12
Databases
Primary keys, foreign keys, database design
Section B (30 marks - answer any 1 of 3)
Q#
Main Topic
Sub-topics
13
Validation & Testing
Eircode validation, test cases, unit vs system testing, Boolean logic, string slicing
14
Game Theory
Matchstick game - winning/losing positions, game strategy, computational thinking
15
Embedded Systems
Hardware/software, sensors (digital/analogue), real-time systems, universal design, IoT, societal impact
Section A (30 marks - answer any 6 of 12)
Q#
Topic
Specific Content
1
Programming
Python functions, scope, return values
2
Hardware
Volatile memory, registers vs RAM
3
Hardware Evolution
Moore's Law, transistors, integrated circuits
4
Logic Circuits
Truth tables, logic gates, circuit diagrams
5
Algorithms
Flowchart completion (pH algorithm)
6
Networking
Client-server model
7
Security
Ransomware, cybersecurity measures
8
Cloud Computing
Cost and environmental impact
9
AI & Machine Learning
ML applications, bias issues
10
Problem Solving
Coin weighing puzzle, abstraction
11
Modelling
Fibonacci in nature (honey bee ancestry)
12
Theory of Computation
Turing Machine state transitions
Section B (30 marks - answer any 1 of 3)
Q#
Main Topic
Sub-topics
13
Software Development
K-9 Kennels system - information systems, stakeholders, SDLC, wireframes, prototypes, user-centred design, data types
14
Sorting Algorithms
Selection sort, insertion sort, algorithm complexity (Big O notation), test cases
15
Data Validation
ISBN check digits, Python implementation, trace tables, arithmetic operators, algorithm comparison
Section A (54 marks - answer any 9 of 12)
Q#
Topic
Specific Content
1
Programming
Data types identification
2
Number Systems
Hexadecimal advantages, hex to decimal conversion
3
Logic & Boolean
Cartesian plane, truth tables, Boolean expressions
4
User Interface
UI definition and types
5
Networking
TCP/IP protocol layers
6
Embedded Systems
Smart home examples, characteristics
7
Programming
Python while loop trace table
8
Problem Solving
Wolf, goat, cabbage puzzle - state representation
9
Algorithms
Chop Cup puzzle - move sequences
10
Algorithms
Quicksort - partitioning, pivot selection
11
Algorithms
Flowchart analysis - string slicing/concatenation
12
Software Development
SDLC importance, functional vs non-functional testing
Section B (76 marks - answer any 2 of 3)
Q#
Main Topic
Sub-topics
13
Social Impact
Digital working hubs - cultural impact, modelling, assistive technology, graph problems (shortest path), abstraction, facial recognition ethics
14
Computer Architecture
Von Neumann architecture, CPU cycle, registers, ALU/CU, CPU performance, storage (HDD/SSD), virtual memory, cloud computing, business analyst role
15
Search Algorithms
Linear vs binary search, time complexity, recursion vs iteration, recursive functions
Section A (54 marks - answer any 9 of 12)
Q#
Topic
Specific Content
1
Logic Circuits
Logic gate outputs (AND, OR, NOT, etc.)
2
Programming
Python while loop output
3
Number Systems
Decimal to 8-bit binary conversion
4
Problem Solving
Disc swapping puzzle - algorithm design
5
Hardware History
Computer hardware milestones (1930s-1980s)
6
Testing
Unit test vs system test cases (social media app)
7
Emerging Technologies
Quantum computing, Edge computing, IoT, biometrics, blockchain - advantages/disadvantages
8
Hardware
RAM vs ROM - data examples
9
Programming Logic
Leap year algorithm - Python boolean logic
10
User Design
Universal design principles for kiosks
11
Algorithms
Swap algorithm application, general solutions
12
Ethics
Online privacy quote analysis and implications
Section B (76 marks - answer any 2 of 3)
Q#
Main Topic
Sub-topics
13
Artificial Intelligence
AI definition, narrow AI vs AGI, generative AI, computer vision, ML applications, bias reduction, AI pause debate
14
Algorithms
Flowchart interpretation, bubble sort implementation, data types, arrays/lists, Big O notation, algorithm improvements
15
Databases
Database design, records/fields, primary keys, data inconsistencies, data types, relational databases, foreign keys, data redundancy, data analytics, data cleaning
Section A (54 marks - answer any 9 of 12)
Q#
Topic
Specific Content
1
Programming
Python operators (assignment, arithmetic, modulo, comparison)
2
Data Representation
ASCII vs Unicode (memory usage, compatibility)
3
Computational Thinking
Logic puzzle - constraint satisfaction (hackathon)
4
Operating Systems
Resource management vs file management
5
Number Systems
Hexadecimal to decimal conversion (RGB colors)
6
Artificial Intelligence
AI in medical diagnosis - benefits and limitations
7
Algorithms
Linear vs binary search identification and efficiency
8
Networking
IP vs VoIP protocols
9
Programming
Python debugging (FizzBuzz) - syntax and logic errors
10
Automation
Computing in automation, limitations
11
Social & Ethical
Data personalization in social media (elections context)
12
Computer Architecture
CPU components and purposes
Section B (76 marks - answer any 2 of 3)
Q#
Main Topic
Sub-topics
13
Software Development Project
Deposit Return Scheme - project roles, SDLC methodologies, stakeholders, database use cases, AI applications, accessibility, assistive technology, testing types
14
Advanced Algorithms
GCD algorithms (Euclid's), function definition, trace tables, loops, recursion (base/recursive cases), memory utilization, quicksort, partitioning, pivot selection, time complexity
15
Modelling & Simulation
Driving test model - input/output variables, pattern recognition, model limitations/benefits, abstraction, real-world applications, agent-based modelling, emergent behavior, strategy testing
Topic
Appearances
Years
Programming/Code Tracing
6 years
All years (Python/JavaScript)
Algorithms (Sorting/Searching)
6 years
All years
Number Systems/Conversions
5 years
2020, 2021, 2023, 2024, 2025
Computer Architecture/Hardware
5 years
2020, 2021, 2022, 2023, 2024
Networking/Protocols
4 years
2020, 2021, 2023, 2025
AI & Machine Learning
4 years
2020, 2022, 2024, 2025
Data Representation
4 years
2020, 2021, 2023, 2025
Software Development/SDLC
4 years
2020, 2022, 2023, 2025
Databases
3 years
2021, 2022, 2024
Testing
4 years
2021, 2023, 2024, 2025
Logic Circuits/Boolean Logic
4 years
2020, 2021, 2022, 2024
Modelling & Simulation
3 years
2021, 2023, 2025
AI/ML applications and ethics (especially 2024-2025)
Data quality and cleaning
Accessibility and universal design
Real-world project scenarios (DRS, digital hubs, etc.)
Societal impact discussions
Algorithm analysis (complexity, efficiency)
Programming fundamentals (Python focus from 2021+)
Problem-solving puzzles
Software development lifecycle
2020: All questions required in Section A (12 questions)
2021-2022: Choice format (answer 6 of 12)
2023-2025: Answer 9 of 12 questions
Section B: Evolved from answer 1 of 3 (2021-2022) to answer 2 of 3 (2023-2025)
Algorithms Deep Dive (appears every year)
Implementation analysis
Complexity discussion
Comparison of approaches
System Design/Development (appears most years)
Stakeholder analysis
SDLC methodology
User interface design
Accessibility considerations
Theoretical Computer Science (rotating)
Turing Machines (2020, 2022)
Game theory (2021)
Embedded systems (2021)
AI ethics (2020, 2024)
Modelling & simulation (2023, 2025)
Code reading and tracing
Algorithm design and analysis
Number system conversions
Logic circuit analysis
Database design
Hardware/software interaction
Network protocols
Data structures
Computational complexity
AI/ML concepts
Problem decomposition
Algorithm efficiency evaluation
Ethical implications
Design trade-offs
Real-world applications
Technical explanations
Justifying choices
Comparing approaches
Discussing societal impact
Document prepared for exam preparation
Print-ready format
Ireland Leaving Certificate Computer Science Higher Level
Sections A & B Analysis: 2020-2025
Core Concepts:
String manipulation and character checking
Boolean flags (lowercase, uppercase)
Conditional statements (if/elif)
String constants and variables
Loop iteration through strings
Score calculation based on rules
Functions with parameters and return values
Lists and list manipulation
String methods (len())
Core Concepts:
String input and manipulation
sorted() function for comparison
Boolean logic and conditionals
Function definitions with parameters
String concatenation for output
Case-insensitive string comparison (.upper() or .lower())
String methods (.replace() for removing spaces)
Multiple function calls
Core Concepts:
Random number generation (randint())
Lists and list operations (.append())
Loop iteration (range())
Frequency counting with lists
List indexing
Conditional statements
Finding maximum values in lists
String formatting and tabular output
Nested loops for bar chart generation
Core Concepts:
Random number generation (randint())
While loops with multiple conditions
User input validation
Function definitions with parameters
Conditional logic (if/elif/else)
Counter variables and incrementing
List operations for tracking previous guesses
Game loop implementation
Difficulty levels with conditional range selection
Core Concepts:
Lists and list initialization
Random selection (choice())
Conditional comparisons
Loop iteration and counting
Dictionary or counter for frequency tracking
List membership testing (in)
Input validation loops
Multiple random selections
While loops until condition met
Core Concepts:
Lists and list operations
Statistical calculations (mean, median)
Function definitions with return values
Conditional logic for grade assignment
min() and max() functions
Counting with conditions
List sorting
Modulo operator for odd/even detection
List slicing and indexing
Finding longest consecutive sequences
Empty list handling
Conditional statements (if/elif/else)
Lists (initialization, indexing, iteration)
Loop iteration (for/while loops)
Function definitions with parameters
User input (input())
Variables and assignments
String manipulation
Random number generation (2021-2025) - randint() or choice()
Counting/accumulation patterns (2020-2025)
Boolean logic and flags (2020, 2021, 2023, 2024, 2025)
Return values from functions (2020, 2021, 2023, 2024, 2025)
List manipulation (append, modify) (2020, 2022, 2023, 2024)
Multiple conditions in logic (2020, 2021, 2023, 2025)
Finding maximum/minimum values (2022, 2024, 2025, implied in 2020)
String methods (.upper(), .lower(), .replace()) (2021, 2023, 2025)
Input validation loops (2023, 2024, 2025)
Frequency counting (2022, 2024, 2025)
Part (a): Incremental modifications to existing code (7-8 sub-parts)
Part (b): Building a complete program from scratch (open-ended)
2020-2021: More focused on data processing
2022-2025: Increased emphasis on game simulations and interactive loops
From 2021 onward, every exam includes random number generation
Reflects real-world simulation scenarios
Increasing trend (2023-2025) of requiring validation loops
Testing ability to handle edge cases
2022: Frequency analysis
2025: Mean, median, statistical calculations
Shows progression toward data analysis skills
Consistent requirement to write and use functions
Testing understanding of parameters, return values, and modularity
Every year requires sophisticated list manipulation
2025 includes advanced concept: finding longest consecutive sequence
Consistent requirement for formatted output
Tabular displays (2020, 2022)
Meaningful messages (all years)
Simple output changes
Variable modifications
New conditional rules
Function implementation
Loop additions
Advanced feature (edge cases, complex logic)
Initialize data structures
Implement game/simulation loop
Handle user input and validation
Apply scoring/calculation logic
Display formatted results
Handle edge cases
Variables and data types
Conditional logic (if/elif/else)
Loops (for and while)
Lists (indexing, iteration, methods)
Functions (parameters, return values)
String manipulation
Random number generation
Input validation
Counting and accumulation
Boolean flags
Nested loops
List comprehension awareness
Finding min/max/median/mean
Frequency analysis
Consecutive sequence detection
Game loop implementation
Multi-condition validation
Based on trends, the 2026 exam will likely include:
Random module usage (guaranteed)
Input validation loop (very likely)
List processing with statistical analysis
Game or simulation context (Part b)
Function definitions with multiple parameters
A novel challenge combining 2-3 concepts (e.g., tracking patterns in randomized data)
This guide is designed for students sitting the Leaving Certificate Computer Science (LCCS) exam this year, focusing specifically on Section C (Programming), based on the patterns and progression observed in the exams from 2020 to 2025.
Section C is an 80-mark programming question that assesses your ability to implement a complete program based on a set of rules. Success depends on mastering the core principles and applying a solid exam strategy.
The most frequently examined and challenging topics fall into five key areas. Prioritise mastering these over all else:
1. Lists and Data Algorithms (The Complexity Challenge)
This is the area that has shown the greatest increase in complexity (e.g., finding the median, tracking the longest consecutive run in 2025).
Practice:
Data Aggregation: Use lists to count or tally frequencies (as seen in the 2022 Dice Simulation and 2024 Fruit Machine).
Sorting & Statistics: Practice using built-in methods (.sort() or sorted()) and manually implementing algorithms to find the mean, median, mode, max, and min of a list.
Sequential Logic: Master algorithms that require looking at previous and current elements in a loop to track patterns (e.g., finding the "longest run" of increases).
2. Control Flow (The Foundation)
This is the most fundamental and heavily tested area, used in every single paper.
Practice:
Selection (if/elif/else): Become instantly fluent in writing complex nested if statements and combining conditions using and and or operators. These are critical for implementing game rules (2023) and checking scoring conditions (2020, 2024).
Iteration (for/while): Understand the difference between iterating through a list by value (for item in my_list:) and iterating by index (for i in range(len(my_list)):). Use while loops effectively for game loops that run until a condition is met (e.g., guessing game).
3. Functions and Modular Design
Using functions is crucial for structure and often explicitly required by the question.
Practice:
Defining and Calling: Always enclose your main program logic within functions (e.g., def calculate_score(password):).
Parameters and Returns: Practice using functions that accept parameters and return a single, useful value (e.g., returning True/False for an anagram check, or returning the calculated score). This keeps your code clean and manageable.
4. Randomness and Simulation
The LCCS exam has a strong bias toward simulations and games (Dice, Guessing Game, Fruit Machine).
Practice:
import random: Ensure you know how to import the module.
Generating Numbers: Use random.randint(a, b) for generating integers in a range.
Selecting from a List: Use random.choice(my_list) to randomly pick an element from a predefined list of options.
5. Strings and Text Manipulation
While less frequent than lists, string work is required for validation and comparison tasks.
Practice:
Iteration: Use for char in my_string: to check every character (e.g., checking for uppercase/lowercase mix).
Methods: Be fluent with useful string methods like .lower(), .upper(), and .strip() for case-insensitive checks and cleaning input.
1. Read the Rules, Not Just the Code
The marking scheme is based on successfully implementing the rules provided in the text.
Highlight Key Conditions: Underline or highlight every explicit rule (e.g., "+5 points if password > 7 chars," "Check both word1 and word2 are anagrams").
Test Cases: The paper usually provides sample runs. Write down these sample inputs and what the program's output must be. This is your immediate test for correctness.
2. Build Piece-by-Piece
Do not try to write the entire program at once. Tackle the question in the sequence it is asked (usually part (a), then (b), etc.).
Set up the Skeleton: Define the variables and functions needed (even if they are empty for now).
Implement the First Rule: Write the code for the easiest rule first.
Test the First Rule: Run the program immediately to see if that section works before moving on.
Add Next Rule: Incrementally add the next piece of logic and test again. This makes debugging much easier.
3. Prioritise Debugging
You will make mistakes. Debugging is a skill, not a punishment.
The print() Debugging Method: Insert print() statements frequently to check the values of your variables at specific points in the code.
Example: print("Score is now:", score)
Use Comments: If you are struggling with a complex piece of logic, comment out the code, solve the rest of the problem, and return to the tricky part later.
4. File Management is Crucial
The exam environment requires strict file naming and saving procedures. Do not lose marks because of a file name.
Follow Instructions: Use the exact format specified in the question (e.g., Candidate NumberQuestion16_A.py).
Save Frequently: Save your work every few minutes, especially after successfully completing a section. You are responsible for ensuring the correct, latest version of your code is saved for submission.