
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.
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:
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-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).
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.
1 of 4 Gets Filtered—And How Codility Scores Each TabAuto-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!
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.

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.
No Division, O(n) Time, O(1) Extra Space)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].
Two Traps Under a 15-Minute Clock:
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.
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!
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]
Complexity: O(n) time across two linear passes and O(1) extra working space beyond ans. Banked in 8 minutes!
String Parsing)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.
Three Classic Codility Edge Cases:
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.
Empty occupied_labels Input ("" or " "): When zero seats are booked, occupied_labels.split() returns [] and must return rows * columns cleanly without indexing errors.
Duplicate Bookings ("1A 1A 2B"): Storing (row_num, seat_letter.upper()) in a Python set counts repeated seat tokens once!
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
Complexity: O(K) expected time and O(K) set memory for K label tokens.
Half-Open Slice Delete)The Problem: Execute a list of command strings over an initially empty mutable text buffer:
"insert idx ch" — inserts character/string ch at 0-based position idx,
"delete start_idx end_idx" — deletes the half-open range [start_idx, end_idx) (start_idx included, end_idx excluded!), and
"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"].
Hidden Traps:
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.
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.
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"]
Complexity: O(M * L) across M operations on bounded buffer length L, O(L) space.
m x k by k x n) With Shape ValidationThe 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]].
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]]) == []
Complexity: O(m * k * n) time and O(m * n) output space.
B (Greedy Run Sort)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
Dijkstra Min-Heap)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]
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.
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.
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!
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:
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!
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.
Signal 3 — Tab Switching (window.onblur): Records every focus drop outside the active Codility tab.
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.
Optional Webcam Snapshots, Screen Capture, & Device Integrity: Toggled per cohort, plus live interviewer screen observation during the 90-minute TDP round!
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!
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.
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.
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):
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!
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.
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.
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:
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.
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.
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.
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.
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!
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.
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.
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.
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.
Both the asynchronous OA and live Codility interviews let you pick standard languages per task, including Python 3, Java, C#, C++, and JavaScript/TypeScript.
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.
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
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.
