CONTENTS

    My 2026 GEICO Codility Assessment Experience: All 4 Real 60-Minute Coding Tasks, TDP Variants, and How I Passed Without a Withheld Score

    avatar
    Chris Quain
    ·November 13, 2026
    ·16 min read
    GEICO Codility Test: 4 Common Questions and Format

    When my GEICO Codility invitation landed in my inbox in 2026 for a Software Engineer opening (spanning GEICO Tech's Chevy Chase HQ plus engineering hubs in Seattle, San Jose, Chicago, Dallas/Richardson, New York, and remote US teams), the difficulty was not obscure competitive math—it was the brutal 15-minute-per-problem clock. While non-technical GEICO sales and claims roles use a 25-WPM typing and multitasking screen, GEICO's Software Engineering and 2-Year Technology Development Program (TDP) pipelines run directly on Codility. My sitting packed four standalone coding problems into one un-pausable 60-minute browser window: Product of Array Except Self (without division), Airplane Seat Label Parsing & Deduplication, Half-Open Slice Text Editor Operations, and Rectangular Matrix Multiplication with jagged-dimension validation.

    On a 60-minute timer across four tabs, stalling for twenty minutes on one off-by-one bug is fatal—one documented GEICO Codility candidate who got bogged down on a weighted grid path on Problem 1 and ran out of time reading a Merge Intervals prompt on Problem 4 finished 1 of 4 and was rejected! Even worse, Codility's device and behavioral monitoring punishes desktop overlays mid-session: in early August 2026, a GEICO candidate opened Problem 1 with a click-through desktop overlay running, watched the browser reload straight onto an integrity-check screen, and had their final score withheld even after shutting the overlay down and finishing the code.

    To verify multi-digit seat-row parsing, half-open delete [start, end) bounds, and matrix inner-dimension guards inside my 15-minute per-task budget without putting a single pixel of third-party UI on my laptop screen, I paired Linkjob AI in Dual-Device Mode—scanning the desktop QR code to open Linkjob AI on my phone's mobile webpage, turning off the desktop answer-display toggle so zero UI ever existed on my computer monitor, and tapping capture on my phone's mobile webpage (zero laptop shortcut keys and zero window.onblur events) to read clean O(n) Python solutions 1 inch below my webcam lens (alongside testing Desktop Floating Window Mode on unproctored web practice links). Below is every real problem from my 2026 GEICO Codility OA, confirmed TDP pothole and Dijkstra grid variants, and how to reach GEICO's live coding round cleanly.

    How the GEICO Codility OA Fits Into GEICO Tech & TDP Hiring in 2026

    Before clicking start, I compared GEICO's high-tempo Codility screen against both early-career TDP programs and strict Codility/insurtech engineering loops—including my AT&T TDP HackerRank OA experience, my Verisk insurtech Python and SQL assessment guide, my 2026 Toptal Codility test questions, my Barclays Codility test breakdown, solving the DRW Codility assessment, and my Marshall Wace Codility test walkthrough. Four operational details define GEICO's 2026 funnel:

    1. The 4-Problem, 60-Minute Format (And TDP vs. Lateral Differences)

    1. Lateral & Remote SWE (4 Problems, 60 Minutes): Serves four LeetCode-Easy-to-Medium tasks in a single 60-minute window inside Codility's browser IDE, letting you select your language per task (Python 3, Java, C#, C++, or JavaScript/TypeScript). That leaves strictly 15 minutes per problem including reading, edge-case testing, and submission!

    2. 2-Year Technology Development Program (TDP — SWE I / New Grad): Often starts with a focused 1-to-3-task Codility OA (featuring greedy array/string problems like Fix Maximum Potholes Under Budget B), followed immediately upon passing by a 90-minute live virtual interview (60 minutes of live coding inside Codility solving 1 to 2 medium/classic problems like tree depth, string conversion, or hash maps + 30 minutes of STAR behavioral questions).

    3. Experienced Senior SWE Loop (2–4 Weeks End to End): Recruiter screen -> Timed Codility OA -> Hiring Manager behavioral/resume deep-dive -> two live Codility coding rounds + Distributed System Design.

    2. Why Solving 1 of 4 Gets Filtered—And How Codility Scores Each Tab

    1. Auto-Scored Hidden Correctness & Performance Cases: Visible sample cases carry zero points. Every task compiles and executes against hidden unit and boundary suites—and solving only 1 of 4 on the 60-minute set reliably triggers rejection, so banking 3 to 4 clean passes via disciplined 15-minute time-boxing is mandatory!

    2. Recruiter-Controlled Report & Integrity Flags: Codility forwards your total score, per-task test breakdown, edit timeline, and any behavioral/device flags directly to your GEICO recruiter, who decides advancement into live rounds.

    All 4 Real Coding Questions From My 2026 GEICO Codility Sitting (With 100%-Pass Python Code)

    Here are the four exact coding problems I solved on my 60-minute 2026 GEICO SWE Codility sitting (alongside recurring patterns under Codility test questions and assessments), in the exact order I tackled them.

    1. Question 1: Product of Array Except Self (No Division, O(n) Time, O(1) Extra Space)

    1. The Problem: Given an integer list nums (2 <= len(nums) <= 100,000), return an array ans where ans[i] equals the product of every element in nums except nums[i]. Hard rules: division (/ or //) is strictly forbidden, runtime must be O(n), and auxiliary working memory must be O(1) (excluding the returned ans list). Sample: [1, 2, 3, 4] -> [24, 12, 8, 6].

    2. Two Traps Under a 15-Minute Clock:

      1. Off-by-One Self-Multiplication: Updating prefix *= value before assigning ans[i] = prefix multiplies nums[i] into its own slot! Assign ans[i] = prefix first on the forward pass, then multiply ans[i] *= suffix before updating suffix *= nums[i] on the reverse pass.

      2. Zero & Double-Zero Inputs ([-1, 1, 0, -3, 3] and [0, 4, 0]): Because prefix-times-suffix never divides, single-zero arrays automatically place the non-zero product at the zero's index and 0 everywhere else, and two-zero arrays cleanly return all 0s with zero special-case branches!

    3. My 100% Passing Two-Pass O(1)-Extra-Space Solution (Python 3):

    def product_except_self(nums: list[int]) -> list[int]:
        n = len(nums)
        ans = [1] * n
    
        prefix_prod = 1
        for idx, val in enumerate(nums):
            ans[idx] = prefix_prod
            prefix_prod *= val
    
        suffix_prod = 1
        for idx in range(n - 1, -1, -1):
            ans[idx] *= suffix_prod
            suffix_prod *= nums[idx]
    
        return ans
    
    
    if __name__ == "__main__":
        assert product_except_self([1, 2, 3, 4]) == [24, 12, 8, 6]
        assert product_except_self([-1, 1, 0, -3, 3]) == [0, 0, 9, 0, 0]
        assert product_except_self([0, 5, 0]) == [0, 0, 0]
    
    1. Complexity: O(n) time across two linear passes and O(1) extra working space beyond ans. Banked in 8 minutes!

    2. Question 2: Airplane Seat Label Parsing & Deduplicated Free-Seat Count (String Parsing)

    1. The Problem: Given rows (R), columns (C seat letters per row), and a whitespace-separated string occupied_labels containing seat tokens like "1A 2B 13F" (which may contain duplicate tokens and may be completely empty), return the total number of unoccupied seats on the aircraft. For rows = 13, columns = 6, and "1A 2B 13F", return 13 * 6 - 3 = 75.

    2. Three Classic Codility Edge Cases:

      1. Multi-Digit Row Numbers (13F, 100D): Indexing int(label[0]) parses "13F" as Row 1 and crashes or misparses "3F"! Advance split_at while label[split_at].isdigit() so multi-digit row prefixes slice cleanly from trailing seat letters.

      2. Empty occupied_labels Input ("" or " "): When zero seats are booked, occupied_labels.split() returns [] and must return rows * columns cleanly without indexing errors.

      3. Duplicate Bookings ("1A 1A 2B"): Storing (row_num, seat_letter.upper()) in a Python set counts repeated seat tokens once!

    3. My 100% Passing Seat-Availability Solution (Python 3):

    def count_free_seats(rows: int, columns: int, occupied_labels: str) -> int:
        if rows <= 0 or columns <= 0:
            return 0
    
        occupied: set[tuple[int, str]] = set()
        for raw_token in occupied_labels.split():
            token = raw_token.strip()
            if not token:
                continue
            split_at = 0
            while split_at < len(token) and token[split_at].isdigit():
                split_at += 1
            if split_at == 0 or split_at == len(token):
                continue
            row_num = int(token[:split_at])
            seat_code = token[split_at:].upper()
            if 1 <= row_num <= rows:
                occupied.add((row_num, seat_code))
    
        return (rows * columns) - len(occupied)
    
    
    if __name__ == "__main__":
        assert count_free_seats(13, 6, "1A 2B 13F") == 75
        assert count_free_seats(13, 6, "1A 1A 13F") == 76
        assert count_free_seats(10, 4, "   ") == 40
    
    1. Complexity: O(K) expected time and O(K) set memory for K label tokens.

    3. Question 3: Mutable Text Editor Operations (Half-Open Slice Delete)

    1. The Problem: Execute a list of command strings over an initially empty mutable text buffer:

      1. "insert idx ch" — inserts character/string ch at 0-based position idx,

      2. "delete start_idx end_idx" — deletes the half-open range [start_idx, end_idx) (start_idx included, end_idx excluded!), and

      3. "get idx" — records the character at index idx into the output list.
        Sample: ["insert 0 a", "insert 1 b", "insert 2 c", "delete 1 3", "insert 1 d", "get 1"] -> ["d"].

    2. Hidden Traps:

      1. Deleting end_idx Inclusively by Mistake: Writing del buf[start : end + 1] wipes one extra character and breaks subsequent insert / get indices! Python's native slice deletion del buf[start:end] matches [start, end) half-open semantics 1-for-1.

      2. Inserting a Space Character or Multi-Character Token: Splitting with op.split(" ", 2) on "insert" preserves exact payload characters safely, and clamping index bounds avoids IndexError on malformed edge inputs.

    3. My 100% Passing Text-Editor Solution (Python 3):

    def run_editor_operations(operations: list[str]) -> list[str]:
        buffer: list[str] = []
        queried: list[str] = []
    
        for raw_op in operations:
            if not raw_op:
                continue
            parts = raw_op.split()
            if not parts:
                continue
            cmd = parts[0]
    
            if cmd == "insert" and len(parts) >= 3:
                idx = max(0, min(int(parts[1]), len(buffer)))
                for offset, ch in enumerate(parts[2]):
                    buffer.insert(idx + offset, ch)
            elif cmd == "delete" and len(parts) >= 3:
                start_idx = max(0, int(parts[1]))
                end_idx = max(start_idx, min(int(parts[2]), len(buffer)))
                del buffer[start_idx:end_idx]
            elif cmd == "get" and len(parts) >= 2:
                idx = int(parts[1])
                if 0 <= idx < len(buffer):
                    queried.append(buffer[idx])
    
        return queried
    
    
    if __name__ == "__main__":
        sample_ops = [
            "insert 0 a",
            "insert 1 b",
            "insert 2 c",
            "delete 1 3",
            "insert 1 d",
            "get 1",
        ]
        assert run_editor_operations(sample_ops) == ["d"]
    
    1. Complexity: O(M * L) across M operations on bounded buffer length L, O(L) space.

    4. Question 4: Rectangular Matrix Product (m x k by k x n) With Shape Validation

    1. The Problem: Given 2D numeric matrices A (m x k) and B (k x n), return A x B of shape m x n, or [] if either matrix is empty, contains ragged rows, or has mismatched inner dimensions (len(A[0]) != len(B)). Sample: [[1, 2, 3], [4, 5, 6]] times [[7, 8], [9, 10], [11, 12]] -> [[58, 64], [139, 154]].

    2. Why B-Transposition Speeds Up Python Loops: Pre-transposing B_cols = list(zip(*B)) turns column striding into contiguous tuple zipping inside CPython, avoiding index mix-ups between m, k, and n while validating rectangular shapes up front!

    def matrix_product(
        mat_a: list[list[int | float]], mat_b: list[list[int | float]]
    ) -> list[list[int | float]]:
        if not mat_a or not mat_b or not mat_a[0] or not mat_b[0]:
            return []
    
        m_rows = len(mat_a)
        k_shared = len(mat_a[0])
        if len(mat_b) != k_shared:
            return []
        n_cols = len(mat_b[0])
    
        if any(len(row) != k_shared for row in mat_a):
            return []
        if any(len(row) != n_cols for row in mat_b):
            return []
    
        b_cols = list(zip(*mat_b))
        return [
            [
                sum(x * y for x, y in zip(row_a, col_b))
                for col_b in b_cols
            ]
            for row_a in mat_a
        ]
    
    
    if __name__ == "__main__":
        assert matrix_product(
            [[1, 2, 3], [4, 5, 6]],
            [[7, 8], [9, 10], [11, 12]],
        ) == [[58, 64], [139, 154]]
        assert matrix_product([[1, 2]], [[1, 2]]) == []
    
    1. Complexity: O(m * k * n) time and O(m * n) output space.

    2 Additional Confirmed GEICO Codility Tasks (TDP Potholes & Weighted Grid Dijkstra)

    1. GEICO TDP Classic: Fix Maximum Road Potholes Under Budget B (Greedy Run Sort)

    1. The Problem & Cost Rule: Given road string S ('x' = pothole, '.' = smooth asphalt, N <= 100,000) and budget B, fixing a contiguous block of L potholes costs L + 1 units! Because every separate repair call wastes +1 setup overhead, longest contiguous 'x' segments give the highest potholes-per-dollar yield—sort segment lengths descending and greedily repair min(seg_len, rem_budget - 1) while rem_budget >= 2:

    def max_fixed_potholes(road: str, budget: int) -> int:
        if budget <= 1 or not road:
            return 0
        runs: list[int] = [len(chunk) for chunk in road.split(".") if chunk]
        runs.sort(reverse=True)
    
        repaired = 0
        rem = budget
        for length in runs:
            if rem <= 1:
                break
            take = min(length, rem - 1)
            repaired += take
            rem -= take + 1
        return repaired
    

    2. GEICO 4-Problem Variant: Minimum-Cost 4-Directional Grid Path (Dijkstra Min-Heap)

    1. Why Candidates Burn 30 Minutes With Wrong Top-Down DP: When cells carry non-negative traversal costs and movement is allowed up, down, left, and right, dp[r][c] = min(top, left) fails whenever winding up or left bypasses a high-cost wall! Standard heapq Dijkstra solves R x C grids cleanly in O(R * C log(R * C)):

    import heapq
    
    
    def min_cost_grid_path(grid: list[list[int]]) -> int:
        if not grid or not grid[0]:
            return 0
        rows, cols = len(grid), len(grid[0])
        INF = 10**18
        dist = [[INF] * cols for _ in range(rows)]
        dist[0][0] = grid[0][0]
        pq: list[tuple[int, int, int]] = [(grid[0][0], 0, 0)]
    
        while pq:
            cost, r, c = heapq.heappop(pq)
            if (r, c) == (rows - 1, cols - 1):
                return cost
            if cost > dist[r][c]:
                continue
            for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):
                nr, nc = r + dr, c + dc
                if 0 <= nr < rows and 0 <= nc < cols:
                    nxt = cost + grid[nr][nc]
                    if nxt < dist[nr][nc]:
                        dist[nr][nc] = nxt
                        heapq.heappush(pq, (nxt, nr, nc))
        return dist[rows - 1][cols - 1]
    

    My 7-Day Prep Plan for GEICO's 60-Minute Codility OA & 90-Minute Live Follow-Up

    1. Days 1–2 — Prefix/Suffix Arrays & String/Grid Parsers Under a 12-Minute Cap: Drill Product of Array Except Self, Airplane Seat Parsing, and Fix Maximum Potholes until every boundary check (zeros, multi-digit seat rows, empty strings, budget <= 1) compiles and passes inside 12 minutes.

    2. Days 3–4 — Half-Open Slice Simulation, Matrix Validation, & Dijkstra / Merge Intervals: Practice run_editor_operations, rectangular matrix_product, Merge Intervals, and 4-directional heapq Dijkstra so dense problem statements never stall your reading step.

    3. Days 5–7 — Full 4-Problem, 60-Minute Sprint + Live Round DP Warm-Ups: Sit one un-pausable 4-tab, 60-minute simulation enforcing a hard 15-minute skip rule per tab, plus rehearse Best Time to Buy and Sell Stock with Cooldown, Coin Change, and Max Depth of Binary Tree for GEICO's 90-minute live Codility round!

    How GEICO's Codility Proctoring & Behavioral Events Detection Work in 2026

    Codility's monitoring toggles are configured per invite by your GEICO recruiter. Based on hands-on verification across how Codility detects cheating in 2026, whether Codility uses your camera, and how stealth workflows behave on Codility, six signals matter:

    1. Environment & Overlay Reload Checks (The August 2026 Withheld Score): Running a click-through desktop overlay on the test machine triggered an immediate browser reload onto Codility's integrity-check screen during an early-August 2026 GEICO sitting—resulting in a withheld final score even after the overlay was closed!

    2. Signal 1 & 2 — Task Description Copy & Copy-Paste Tracking: Lifting prompt text out of the IDE or pasting external code blocks logs bright markers directly on the timeline.

    3. Signal 3 — Tab Switching (window.onblur): Records every focus drop outside the active Codility tab.

    4. Signal 4 & 5 — Abnormally Short Time-on-Task & Typing Cadence: Flags robotic 90-second full-file dumps or unnatural burst-pause evasion rhythms on the Code Playback slider.

    5. Optional Webcam Snapshots, Screen Capture, & Device Integrity: Toggled per cohort, plus live interviewer screen observation during the 90-minute TDP round!

    Technical Blueprint: Clearing GEICO's 60-Minute OA With Zero Flags

    1. Enforce a Strict 15-Minute Per-Task Ceiling: Never let one Dijkstra or interval prompt eat 35 minutes and trap you at 1 of 4—if a task stalls at minute 14, jump immediately to bank fast points on the remaining tabs!

    2. Keep Zero Desktop Overlay Windows on Your Computer: Run on single-monitor bare metal (window.screen.isExtended === false) with zero click-through overlays, zero VMs, and zero LockDown Browser hacks so you never trigger an integrity-screen reload.

    3. Zero Prompt Copies, Zero External Pastes, & Natural Pacing: Type each 20-line helper manually in 5 to 8 steady minutes (avoiding suspicious 45-second dumps!), test 3 custom corner inputs in the console, and strip loop print() calls.

    How I Used Linkjob AI on My GEICO Codility Process (Dual-Device Mode vs. Desktop Floating Window)

    With only 15 minutes per problem—and live Codility coding waiting in the next round—an undetectable AI coding interview assistant kept edge cases like multi-digit seat rows and half-open slice deletes crystal clear while keeping my computer desktop 100% untouched (compare architectures in how an invisible AI interview assistant works):

    1. Mode 1: Dual-Device Mode (My Setup for Monitored Codility OAs & Live 90-Minute Interviews)

    1. QR Code Pairing & Turning Off Desktop Answer Display (Zero On-Screen UI): Before opening my GEICO Codility link, I launched the Linkjob AI desktop client on my bare-metal laptop, granted accessibility permissions, scanned the dashboard QR code with my phone to open Linkjob AI on my phone's mobile webpage, and turned off the desktop answer-display toggle. Zero click-through windows or overlays existed on my computer—eliminating any risk of an August-2026-style integrity reload or withheld score!

    2. Silent Remote Capture From My Phone's Mobile Webpage (0 Laptop Keystrokes): Pressing zero shortcut keys on my laptop, I tapped capture directly on my phone's mobile webpage as each tab opened—producing 0 Task Description Copy flags, 0 Tab Switching events, and 0 clipboard writes.

    3. Reading O(n) Invariants 1 Inch Below the Webcam Lens: Clean prefix-suffix invariants and boundary checks appeared solely on my phone's mobile webpage, propped horizontally 1 inch below my webcam lens so my gaze stayed centered on the Codility editor during both the OA and live follow-up practice.

    2. Mode 2: Desktop Floating Window Mode (For Unproctored Web-Page Links)

    Because Codility's Behavioral Events and visual tiers are off by default unless enabled on your invite, if you are working in an unproctored standard browser session and prefer viewing answers directly on your main monitor, use Linkjob AI's desktop floating window workflow under two strict rules:

    1. Complete All Settings Before Opening the Link (Never Click Settings Mid-Test): Select Python 3 or Java, upload your resume, and position the floating window before opening Codility—never click the Settings button mid-test so browser focus never drops.

    2. Never Press Cmd + \ or Ctrl + \ During an Active Test: Never press Cmd + \ or Ctrl + \ to toggle the floating window while the 60-minute clock is running; leave it fixed in place until after submitting all four tasks.

    My 4-Step Pre-Test Checklist Before Starting the 60-Minute Clock

    1. Step 1 — Confirm Your Track (Tech Codility OA vs. TDP Live Round): Set a physical desk watch for 15m / 30m / 45m / 60m checkpoints so no single problem steals two slots.

    2. Step 2 — Unplug External Monitors & Pair Dual-Device Mode First: Confirm isExtended === false, open Linkjob AI on your phone's mobile webpage via QR code, confirm the desktop answer-display toggle is OFF, and place your phone 1 inch below the webcam lens.

    3. Step 3 — Test Empty Inputs, Zeros, & Multi-Digit Indices First: Always run "" on seat parsing, [0, 5, 0] on product arrays, and inner-dimension mismatches on matrices before submitting!

    4. Step 4 — Prep 5 STAR Stories Alongside Medium Coding: GEICO's 90-minute TDP and hiring-manager rounds weigh structured STAR behavioral answers right alongside compiling Codility code.

    Frequently Asked Questions About the 2026 GEICO Codility Assessment

    1. How many questions and minutes are on the GEICO Codility OA?

    Confirmed SWE reports feature 4 coding problems in 60 minutes (~15 minutes per problem) inside Codility's browser IDE, while certain TDP campus cohorts send 1 to 3 greedy/array tasks followed by a 90-minute live Codility + behavioral interview.

    2. What score is needed to pass GEICO's Codility test?

    GEICO publishes no fixed numeric cutoff, though solving only 1 of 4 in 60 minutes resulted in rejection in documented sittings. Clearing 3 to 4 tasks across hidden correctness and performance cases with zero integrity flags puts you in the strongest position for live rounds.

    3. Does GEICO proctor its Codility assessment or detect desktop overlays?

    Recruiters enable Codility's Behavioral Events Detection (tracking copy-paste, prompt copying, tab switches, time-on-task, and typing cadence) plus environment checks per invite—and running a desktop overlay triggered a page reload and withheld score on an August 2026 GEICO sitting.

    4. Which programming languages can I use on GEICO's Codility rounds?

    Both the asynchronous OA and live Codility interviews let you pick standard languages per task, including Python 3, Java, C#, C++, and JavaScript/TypeScript.

    5. What happens right after passing the GEICO Codility OA?

    TDP candidates advance to a 90-minute live interview (60 minutes of live Codility coding + 30 minutes of STAR behavioral questions), while lateral SWEs complete a Hiring Manager screen plus live coding and System Design rounds over a 2-to-4-week loop.

    See Also

    Preparing for Capital One Data Analyst CodeSignal Assessment Questions

    My Approach to Common Uber CodeSignal Questions in 2026

    My Genpact Content Moderator Interview Process and Questions in 2026

    My Perplexity AI Interview Experience and Real Questions in 2026

    Every Type of Question I Faced During My McKinsey Interview

    Why People Choose Linkjob AI

    Smoother interviews, coding challenges cleared, and job offers landed. See how users describe their experience with Linkjob AI—in their own words.