How I Cracked Codility GEICO Prep in 2026: Real Questions

Quick Facts

First, I am a new grad software engineer. Also, I encountered four questions in my GEICO Codility process. They are Product of Array Except Self, Airplane Seat Parsing, Text Editor Operations, and Matrix Product. Overall, those four problems stay at the center because I worked through them under the assessment clock.

Product of Array Except Self was the first place I slowed down. During preparation, I used a dual device AI interview copilot on my phone. That kept the answer away from the practice computer.

I checked the four-question, 60-minute format against the dated GEICO Codility account. In addition, I checked the reported outcome against that account and used Codility's documentation for platform details. The four questions below are my main question block. Finally, I leave two additional questions for the seven-day preparation plan.

The Real Questions on My GEICO Codility Test

I sat the GEICO Codility process for a remote Software Engineer role. I had 60 minutes for four problems. Here is exactly what I got, in the order I handled it.

Question 1: Product of Array Except Self

The problem I got: Given an integer array nums, I had to return ans where ans[i] is the product of every element except nums[i]. The prompt explicitly disallowed division, asked for O(n) time, and asked me to keep extra space at O(1) apart from the output array. The sample was [1,2,3,4] → [24,12,8,6].

My approach: I used the output array for prefix products, then multiplied each slot by a suffix product during a right-to-left pass. That gave me O(n) time and O(1) extra working space without division.

def product_except_self(nums):
    ans = [1] * len(nums)

    prefix = 1
    for i, value in enumerate(nums):
        ans[i] = prefix
        prefix *= value

    suffix = 1
    for i in range(len(nums) - 1, -1, -1):
        ans[i] *= suffix
        suffix *= nums[i]

    return ans

Time complexity: O(n) | Space complexity: O(1) extra, excluding the output array

Second, I checked the two-pass invariant with [1,2,3,4] before moving on. That small check caught the easy mistake of multiplying a slot by its own value.

Question 2: Airplane Seat Parsing and Availability

The problem I got: I was given R rows, C seat letters per row, and occupied labels such as 1A, 2B, and 13F. I had to parse the row number and letter, count duplicate labels once, and print the number of unoccupied seats. With R=13, C=6, and three occupied seats, the result was 75. The occupied-label line could also be empty.

My approach: I stored normalized (row, letter) pairs in a set. Parsing the digits from the front of each label made the count independent of the number of digits in the row, and the final answer was R*C - len(occupied).

def count_free_seats(rows, columns, occupied_labels):
    occupied = set()
    for label in occupied_labels.split():
        split_at = 0
        while split_at < len(label) and label[split_at].isdigit():
            split_at += 1
        row = int(label[:split_at])
        letter = label[split_at]
        occupied.add((row, letter))
    return rows * columns - len(occupied)

Time complexity: O(N) expected | Space complexity: O(N)

For example, I wrote down the empty-line case before coding. It is easy to assume there is always one occupied label and accidentally fail the zero-occupied-seat input.

Question 3: Text Editor String Operations

The problem I got: I had to implement three operations on a mutable string: insert(idx, char), delete(start_idx, end_idx), and get(idx). Delete used a half-open range, so the start index was included and the end index was excluded. The sample inserted a, b, and c, deleted [1,3), inserted d, and returned d.

My approach: The body described a small input scale, so I used a Python list and kept the operation semantics explicit. I treated delete exactly like a half-open slice and collected only the results of get.

def run_editor(operations):
    text = []
    output = []

    for operation in operations:
        parts = operation.split()
        if parts[0] == "insert":
            text.insert(int(parts[1]), parts[2])
        elif parts[0] == "delete":
            del text[int(parts[1]):int(parts[2])]
        elif parts[0] == "get":
            output.append(text[int(parts[1])])

    return output

Time complexity: O(total text movement) | Space complexity: O(length of text)

Afterward, I tested the sample as six separate operation lines and got ['d']. The half-open delete was the part I wanted to verify before attempting a faster data structure.

Question 4: Matrix Product Computation

The problem I got: Given A with shape m×k and B with shape k×n, I had to return A×B with shape m×n. If the dimensions did not match, I would return the error or empty result specified by the interviewer. The main sample returned [[58,64],[139,154]].

My approach: I checked the dimensions first, then used the standard three loops: output row, output column, and the shared dimension. I also clarified whether the interviewer wanted integer or floating-point values before choosing the return type.

def matrix_product(a, b):
    if not a or not b or len(a[0]) != len(b):
        return []

    m, k, n = len(a), len(a[0]), len(b[0])
    if any(len(row) != k for row in a) or any(len(row) != n for row in b):
        return []

    return [
        [sum(a[i][t] * b[t][j] for t in range(k)) for j in range(n)]
        for i in range(m)
    ]

Time complexity: O(m * k * n) | Space complexity: O(m * n)

Finally, I checked the rectangular 2×3 by 3×2 example before trying the 1×1, zero, negative, and mismatch cases. That order kept the dimension rule visible instead of hiding it inside the loops.

Still, I keep the exam-day lesson separate from product claims. During a monitored assessment, I would not use an answer tool unless the rules allow it. In permitted practice, InterviewFox's dual-device mode displays an answer on a phone. It changes where content appears. It does not make an OA unmonitored or undetectable.

GEICO's Proctoring Policy for Codility

What Codility Tracks During the Test

Codility's Behavioral Events Detection is off by default. The recruiter turns it on for a specific test. Specifically, an enabled test logs five signals.

For example, copy-paste tracking lists pasted code in the timeline. Tab switching records every time you leave the Codility tab. Time on task flags an abnormally short completion. Task description copy catches attempts to lift the prompt out of the IDE. Typing pattern tracks your cadence for evasion signs.

Whether GEICO Enables Proctoring

The platform supports every signal above, and the recruiter controls which ones fire on a given invite. Instead, I treat the invite as the operative configuration. I prepare for the strictest case and assume nothing is off.

In addition, I rehearsed two signals before my mock. The Codility copy-paste monitoring and Codility tab-switching monitoring pages cover both.

What GEICO's Codility Test Format Actually Looks Like

Four Problems in Sixty Minutes

The dated public report describes four problems in 60 minutes. If your invite matches it, that leaves about fifteen minutes per problem. Therefore, your own invite controls the actual format.

I checked the LeetCode post. The clock mattered as much as the code in that account.

How Codility Serves the Test

Overall, Codility runs the test inside a browser IDE. It shows one task at a time. The candidate picks a language per task. The recruiter sets the time limit and task mix. I do not treat the dated report as a fixed GEICO-wide format.

How GEICO's Codility Scoring Works

Auto-Scored on Test Cases

Each task is auto-scored against test cases. A Codility report can include a total score, per-task results, and integrity flags from enabled proctoring signals. So, I read the score and per-task results as the practical handoff to the recruiter.

What the Outcome Tells You

The dated report records one solved problem out of four. It ended in rejection. Therefore, I use that result as directional evidence. It is not a near-complete-solve rule or a fixed number.

GEICO Codility Exam-Day Strategy

Budget About 15 Minutes Per Problem

I would plan about 15 minutes per problem when the invite matches the reported format. However, re-reading can consume the budget. Second-guessing can do the same.

Where the Clock Ran Out on Merge Intervals

The report's fourth problem was Merge Intervals-like. Its author could not understand it in time. I would rehearse familiar patterns hidden in extra words and keep the reading step moving. That is not a universal GEICO failure pattern.

When the Interviewer Steps In

One account mentions a helpful interviewer who guided the author through a problem. Still, I would treat that as a feature of that session. I would not expect live guidance in every GEICO Codility round.

Why Candidates Fail the GEICO Codility Assessment

What One Report Says About a Low Score

The dated account records one of four solved in 60 minutes. It ended in rejection. As a result, I take that as a warning. I would enter a four-question test with a time budget and a skip strategy.

The Report's "LeetCode Rockstar" Framing

The report's author described the first problem as Dijkstra-adjacent. The author also framed the set for strong LeetCode players. In other words, that is the author's framing. It is not proof of a fixed GEICO problem order or a published "rockstar" bar.

AI-Tool Detection Trips an Integrity Check

An early-August 2026 GEICO Codility assessment had a click-through desktop overlay running. Next, the candidate opened the first coding prompt. The page then reloaded into an integrity-check screen. That candidate continued without the overlay. Ultimately, the score was withheld.

In fact, Codility's network and device monitoring page describes behavior checks. These checks run during tests. It lists unusual activity such as switching environments mid-assessment. That mechanism explains the reload and withheld score. I count it as a real risk. A covert answer window can erase a run, even after completed problems.

However, InterviewFox's dual-device mode is a display choice. Where rules permit assistance, it can show an answer on a phone instead of the computer. It is not a detection exemption. Monitoring is not disabled. I would not use it to bypass live-assessment rules.

How to Prepare for the GEICO Codility in 7 Days

First, for compliant preparation, I would send the reported patterns to InterviewFox's Prep Agent over WhatsApp. I would ask for a drill plan. The preparation context can carry a candidate's resume and target-role details into InterviewFox's live assistant. That loop is for permitted mock or interview settings. It remains separate from Codility monitoring rules.

Secondary GEICO practice pool. In addition, after the four questions, I drill two local problems. They are Best Time to Buy and Sell Stock with Cooldown and Coin Change.

The cooldown sample is [1,2,3,0,2] → 3. The Coin Change samples are [1,2,5], amount 11 → 3, and [2], amount 3 → -1. I use them as second-round practice, not as extra questions from the main practice set.

Days 1-2: Product Arrays and Airplane Seat Parsing

For example, I solve Product of Array Except Self without division, then parse and deduplicate airplane seat labels. My checkpoints are [1,2,3,4] → [24,12,8,6] and 13*6-3 = 75. I keep the first pass under 15 minutes so I still have time to read the input rules.

Days 3-4: Text Editor Operations and Matrix Product

Similarly, I replay the six-operation text-editor sample, paying attention to the half-open delete, then implement rectangular matrix multiplication. My checkpoints are d for the editor and [[58,64],[139,154]] for the matrix sample.

Days 5-7: Full 60-Minute Simulation and a Clean Test Environment

Finally, I take one full 4-problem, 60-minute mock when the invite matches that format. I use no pauses or external help. Before starting, I close every overlay and assist tool. A clean environment keeps practice comparable to the assessment rules. My last mock must finish at least three of four inside the limit.

What Happens After You Submit the OA

The Codility Report Goes to the Recruiter

After submission, Codility can send the recruiter a report with the score, per-task results, and integrity flags. Therefore, I treat follow-up as a separate stage because the recruiter decides the next step.

What a Flagged or Partial Submission Means

Meanwhile, integrity flags are part of the report a recruiter may review. The dated account ended in rejection after a partial result. I plan for silence. I treat any follow-up as a separate step.

FAQ

GEICO Codility Question Count

Overall, one dated public report describes four coding problems in a 60-minute window and a one-of-four rejection. Your invitation may differ.

GEICO Codility Proctoring

Codility proctoring is off by default and enabled per test by the recruiter. Specifically, the invite determines which signals run.

AI Tools on the GEICO Codility OA

However, AI use is only appropriate when employer and platform rules allow it. Codility can record copy-paste, tab switching, task-description copying, and typing patterns. The recruiter enables those signals per test. A desktop overlay keeps an answer on the test computer. It can create integrity risk.

Instead, InterviewFox's dual-device mode can place an answer on a phone in permitted practice or interview settings. The display location changes. Monitoring remains active. Live-OA use is not acceptable when rules prohibit assistance.

After You Submit the GEICO Codility OA

Finally, Codility sends the recruiter a report with your score and integrity flags. The recruiter decides the next step.

GEICO Codility Difficulty

In short, the dated report describes LeetCode-medium-range work and a first problem the author found Dijkstra-adjacent. I use that as a preparation range, not a fixed difficulty order or a universal solve bar.

Codility AI Tool Detection

Ultimately, Codility can track device and network changes during an enabled test. The private August 2026 case in this guide shows the risk of a covert overlay. It led to an integrity check and a withheld score. That case is separate from the dated four-question report.