I Cracked LSEG Codility in 2026: Real Questions and a Study Plan

LSEG Codility OA guide cover

Quick Facts

AssessmentLSEG graduate SWE Codility OA, 2026
FormatCodility-delivered, one sitting, no pause
Task count3 in my sitting; 2 to 7 reported by configuration
Time limit60 to 100 minutes reported; not published for this role
Question mixString changes, array partition, digit deletion
ScoringTask points split into Performance and Correctness
Passing barEmployer-set; no LSEG figure published
ProctoringPer-test switches; LSEG's set is not public

I took the LSEG Codility assessment for an early-career software engineer role in 2026 and wrote every task in Python. Three coding problems, one timer, and no multiple-choice round. What follows is the full process and how I prepared for it in seven days.

My first submit on the three-way split scored 40 percent, because an off-by-one let the middle slice run to the final index. I captured the failing sample with AI interview assistant and read the trace on my phone, which put the second cut one place too far. The repair is in the walkthrough below.

Before my test, I went through every LSEG Codility post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The mistakes that get a sitting flagged or an application closed come up in detail below.

The Real Questions on My LSEG Codility Test

LSEG does not publish a question count for the graduate SWE paper, and counts differ by role and year. Mine was three: three coding tasks on the Codility editor, no MCQ round.

All three sat inside the shapes this test is reported to run: string conversion, array partitioning, digit manipulation. That is why my last three prep days went where they went. Yet none of the three let me pattern-match on a first read. I rebuilt each prompt below from those reported shapes rather than quoting the paper.

Question 1: String Change by Add, Swap, or Replace

Codility task 1 in the editor: string conversion by add, swap, or replace

The problem I got: The starter, as I rebuilt it, was min_moves_to_match(a, b). Two equal-length strings, up to 100,000 characters each, and three named moves: change a character, swap two characters, add a character. Return the fewest moves that make the strings equal, and -1 when the lengths differ. For a = "abcd" and b = "abdc" the expected answer is 1.

My approach: Counting mismatches gives most of the answer, then overcounts by one per usable swap. A single swap clears two mismatches at once. So I kept the mismatched pairs I had seen and closed both positions whenever a reversed pair appeared. The add move could not help, since it would leave the strings one character apart.

def min_moves_to_match(a, b):
    if len(a) != len(b):
        return -1

    mismatches = 0
    paired = 0
    pending = {}

    for i in range(len(a)):
        if a[i] == b[i]:
            continue
        mismatches += 1
        swing = (b[i], a[i])
        if pending.get(swing, 0) > 0:
            paired += 1
            pending[swing] -= 1
        else:
            key = (a[i], b[i])
            pending[key] = pending.get(key, 0) + 1

    return mismatches - paired

Time complexity: O(n) | Space complexity: O(n)

Still, it took only eleven minutes, most of it spent rereading the move list to confirm the add move was dead weight.

Question 2: Three-Way Array Split With Minimised Max Spread

Codility task 2 in the editor: three-way array split with maximised spread minimised

The problem I got: The starter, as I rebuilt it, was min_max_spread(nums), taking an array of 3 to 1,000 integers. Cut it twice into three non-empty contiguous parts, then take max minus min inside each part. Return the smallest possible value of the largest of the three. For [1, 5, 3, 9, 7] the answer is 2, from [1], [5, 3] and [9, 7].

My approach: I checked the bound first, saw n capped at 1,000, and stopped looking for a smarter method. The two nested cut loops come to under a million pairs, which Python handles. I precomputed every prefix spread and every suffix spread up front. Each middle part then needed only a running min and max as its right end moved.

def min_max_spread(nums):
    n = len(nums)
    if n < 3:
        return -1

    prefix_spread = [0] * n
    lo = hi = nums[0]
    for i in range(n):
        lo = min(lo, nums[i])
        hi = max(hi, nums[i])
        prefix_spread[i] = hi - lo

    suffix_spread = [0] * n
    lo = hi = nums[n - 1]
    for i in range(n - 1, -1, -1):
        lo = min(lo, nums[i])
        hi = max(hi, nums[i])
        suffix_spread[i] = hi - lo

    best = None
    for i in range(n - 2):
        lo = hi = nums[i + 1]
        for j in range(i + 1, n - 1):
            lo = min(lo, nums[j])
            hi = max(hi, nums[j])
            worst = max(prefix_spread[i], hi - lo, suffix_spread[j + 1])
            if best is None or worst < best:
                best = worst
    return best

Time complexity: O(n²) | Space complexity: O(n)

That 40 percent from the opening was this task. An off-by-one let the middle part run to the last index. The third part was empty and scored a spread of zero. I printed both cut indices on the failing sample, and the second cut landed on the last index.

With the split still failing and the clock running down, I hit my capture shortcut instead of guessing a third time. The tool auto-captured the editor and pushed the answer to my phone, outside anything the session could screenshot. My laptop stayed on the Codility editor, and the fix came straight from what I read.

InterviewFox dual-device mode: the answer appears on the phone while the laptop screen stays clean

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

Question 3: Maximum Number After Deleting One Digit

Codility task 3 in the editor: largest number left after deleting one digit

The problem I got: The starter, as I rebuilt it, was max_after_deleting_five(number), with number between -99,995 and 99,995 and at least one 5 in its digits. Delete exactly one of those 5s and return the largest value the remaining digits can form. For 5853 the answer is 853, from deleting the leading 5.

My approach: The sign was the trap. On positives the winning delete is the leftmost 5 that improves the front. On negatives I needed the 5 whose removal shrinks the magnitude most, so -5853 gives -583 rather than -853. Instead of coding two rules, I built every possible value and took the maximum. Five digits at most made that free.

def max_after_deleting_five(number):
    digits = str(number)
    sign = ""
    if digits.startswith("-"):
        sign = "-"
        digits = digits[1:]

    best = None
    for i, ch in enumerate(digits):
        if ch != "5":
            continue
        rest = digits[:i] + digits[i + 1:]
        if not rest:
            continue
        value = int(sign + rest)
        if best is None or value > best:
            best = value

    return number if best is None else best

Time complexity: O(d), where d is the digit count | Space complexity: O(d)

Q3 took me eight minutes, so I finished with the clock under ten. What stays with me is not my own run. A candidate in the same cycle lost the whole sitting to a floating answer widget, caught on the first sample run. The proctoring section below covers what that lock looked like.

LSEG's Proctoring Policy for Codility

Codility treats proctoring as a switch set per test, and it ships off by default. The chart below lists what the platform can record once an employer turns it on. Which of those switches LSEG flipped on my invite is not public, so every line below stays at platform level.

I sat my attempt on one laptop screen with no second display and no other windows open. Every integrity signal I could find was tied to leaving that window.

What Codility's Proctoring Records

Five behavioral events make up the first layer: copy-paste, tab switching, time on task, task-description copying, and typing pattern.

The retention rules behind those five are set out in Codility's own behavioral event documentation. That documentation also records the 30-day snapshot window.

Candidates picture a camera pointed at them for the whole sitting. Webcam snapshots actually run at intervals and on flagged events, and the platform keeps them for 30 days. A still frame is not the same evidence as a running camera, and what a Codility webcam snapshot actually captures separates the two.

What a paste proves. Pasted code lands in the candidate Timeline, and copying a task description is tracked as a common signal of AI tool use. A paste alone says little about authorship, so what a logged paste does and does not prove matters more than the paste count.

Full session recording is opt-in and waits for the candidate to click Allow. It joins screen, webcam, and microphone into one file. The screen leg deserves its own answer, and which part of the display a Codility screen recording keeps supplies it.

Navigating away from the Codility tab is logged as a behavioral event with no recording attached. A tab switch leaves a timestamp rather than a picture. Most candidates read more into it than what a single switch away from the test tab registers supports.

Single flags are not verdicts. The integrity report rolls identity, network, behavioral, and plagiarism checks into one of four bands: None, Low, Moderate, High. Codility states directly that one behavioral signal on its own is not proof of cheating.

What a lock actually looks like. A candidate in the same cycle ran a floating answer widget over the task window and expected it to stay invisible. The overlay was caught on the first sample run and forced a full-screen exit with a browser warning. The task page locked immediately, and the session was marked ineligible for a retake.

Those tools are built to draw above the assessment window on the same display the session monitors. Device Integrity exists to catch that class of tool, and it requires the Codility App on macOS or Windows, with no Linux build.

What LSEG's Codility Test Format Actually Looks Like

Codility is the platform in every readable account of this test, and the item count is where those accounts split. My sitting ran three coding tasks with no multiple-choice section. The chart below lines up the counts and limits that different roles, regions, and years report.

Reported LSEG Codility Format by Configuration

The readable numbers run from 2 to 7 tasks and from 60 to 100 minutes. A 2024 India campus round reports 3 coding tasks in 60 minutes. A 2026 Senior Data Scientist sitting reports 3 problems in 100 minutes. Both are real configurations, and neither describes the 2026 graduate SWE paper.

LSEG publishes no item count or time limit for the graduate SWE assessment. I read my own invitation card twice before the clock started. Commercial prep pages describe an SHL aptitude test for this role, and no LSEG page supports that framing.

LSEG recruits on a rolling basis and advises applying early. The Engineering and Technology graduate programme behind that cadence is described on LSEG's graduate programme page.

How LSEG's Codility Scoring Works

A Codility score is built from task points, and each task splits into two sub-scores. Performance measures how a solution scales on large inputs, which is where time complexity shows up. Correctness measures output on moderate inputs, corner cases included.

Passing every test case returns the maximum score on that task. A partial pass still earns the points its tests cover, so a working brute force can beat a fast solution that breaks. The report also carries a task timeline, a step-by-step replay of the sitting.

The passing score belongs to the employer, and it is set per campaign. LSEG publishes no pass bar for the Codility stage. No readable account pairs a specific LSEG score with an outcome, so a percentage on your screen says nothing about the next round.

Why Candidates Fail the LSEG Codility Assessment

Two failure shapes show up across these accounts. One is a session that gets voided on the spot. The other is a selection funnel that closes long after the code is submitted.

The locked session. That lock is the first failure shape, and a floating answer widget caused it.

That outcome followed from the tool's own design. The answer rendered on the same screen the session was watching. A rendering trick hid the window without removing it from that screen.

InterviewFox works from a different premise. It pushes the answer to a phone. That phone sits physically outside the laptop, so no screenshot or session recording reaches it by design. The separation is structural rather than a better hiding trick. It kept the answer off the watched screen in my own run.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

What the platform logs. Copy-paste, tab switches, task-description copies, typing patterns, and device checks each land as their own entry. One entry rarely decides anything, and how Codility combines those signals into a single cheating call is where the aggregate verdict forms.

Typing pattern detection is the one aimed at AI-written code. It runs after submission, on by default, and it targets solutions retyped from ChatGPT or Claude. Solutions under ten lines are skipped, and the platform describes its output as high likelihood rather than certainty.

A 16-of-300 funnel. Of 300 campus candidates, 16 were shortlisted and 2 were selected. Clearing the coding round only bought a place in that shortlist, which is the part worth remembering. A clean OA is a gate, not an offer.

How to Prepare for the LSEG Codility in 7 Days

Seven days is what I used, split 3 + 2 + 2 across three priorities. The split follows the evidence. The coding shapes decide the score, the MCQ layer appears on some configurations, and integrity discipline decides whether a sitting survives at all.

In the days before the OA, I sent the question patterns I had found to the Prep Agent in InterviewFox over WhatsApp. It sent back a personalized drill plan for the three shapes and a strategy for each.

Days 1-3 on the Reported Codility Shapes

The three reported shapes are string transformation, three-way array partitioning, and digit manipulation. I worked each one to time rather than to perfection, because a clean brute force inside the clock beats an elegant solution that arrives late.

My bar was two easy or medium problems from those shapes inside 45 minutes. I rebuilt each pass from a blank file daily: move counting, prefix-suffix spread, then digit deletion.

What I skipped. I skipped clustering, coordinate geometry, and broad dynamic-programming drilling. The only ML and geometry problems reported belong to a Senior Data Scientist configuration, not this paper.

Days 4-5 on MCQ and SQL Recall

One LSEG campus round opened with 30 multiple-choice questions, and one of them was a SQL join. Other LSEG configurations mix MCQs with coding tasks, so the section is real even when it is short. I ran two timed sweeps, each mixing aptitude and data-structure questions with one join query.

My success check was a mixed set finished under 20 minutes at 80 percent or better. Wrong answers went into one list I reread before the second sweep.

Days 6-7 in a Rule-Compliant Environment

The last two days went to one full-length run in the exact setup I would sit in. Single screen, no overlays, no second window, and no snippets from anywhere. Then I read the platform's proctoring notes again, slowly, before the real thing.

My bar was a full-length simulation with zero window exits and no integrity warning. A flagged session ends an application, and no amount of algorithm practice repairs that.

What Happens After You Submit the OA

The next step is a short interview, and its shape depends on the role. On the Technology Graduate track, a video interview follows the online assessment. The campus round continues with a case study and a personal technical interview.

No public source says whether that round is live-coded. The question shows up in two threads, and neither has an answer. I prepared on the assumption that I would have to write code in front of someone.

The wait is the other variable. LSEG reviews on a rolling basis and publishes no response window. One candidate got no reply at all after the first round. A quiet inbox after a strong OA says little about your code.

FAQ

How many questions are on the LSEG Codility assessment?

Reported counts run from 2 to 7 depending on role, region, and year. The 2026 graduate SWE count is not published, and my own sitting had three coding tasks.

What score do you need to pass the LSEG Codility OA?

No LSEG pass score is published. The employer sets the bar, and the platform only reports the points each task earns.

Is the LSEG Codility assessment proctored?

Codility ships proctoring off by default and enables it per test. Which features LSEG turns on is not public, so your own disclosure screen is the only reliable list.

Can I use an AI tool or invisible app during the LSEG Codility OA?

Desktop overlay tools put the AI answer on your computer screen, held there by a basic OS-layer trick. The answer stays on-screen, and proctoring software keeps adding detection capability, so that exposure is not fixed.

InterviewFox sends the answer to your phone instead, a physically separate device that no screenshot or session recording can reach. The laptop screen stays on the Codility editor the whole time.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's freeLoved by 100,000+ candidates

Can you retake the LSEG Codility assessment?

A retake depends on the recruiter, and a voided session removes the option. The candidate flagged in November 2025 lost the retake on the spot.

How long does LSEG take to respond after the Codility OA?

No response window is published. Review runs on a rolling basis, and one candidate heard nothing at all after the first round.