CONTENTS

    My 170-Minute Chicago Trading Company Codility Assessment in 2026: All 3 Real Tasks, Pre-Resume Rules, and How I Passed

    avatar
    Chris Quain
    ·November 13, 2026
    ·17 min read
    Chicago Trading Company Codility Assessment Guide 2026

    When I applied for an Associate Software Engineer / Campus SWE role at Chicago Trading Company (CTC) in 2026—the derivatives market-making powerhouse headquartered at 425 South Financial Place in Chicago with desks in New York and London—two surprises hit me before I even saw Question 1. First, CTC flips the normal hiring funnel upside down: the Chicago Trading Company Codility assessment is a pre-resume gate (often preceded 48 hours earlier by a 15-minute, 50-question Criteria Cognitive Aptitude Test / CCAT), meaning recruiters only inspect your resume after your coding submission clears their automated bar. Second, when my Codility link arrived, it showed 3 coding tasks on a massive 170-minute un-pausable clock—a generous-looking timer that lures candidates into writing naive O(N * max_T) simulations that pass every visible sample and score 0% on hidden 10^9-hour Performance tests!

    During my own 170-minute Chicago Trading Company Codility sitting, I solved all three tasks in Python 3: a 4-Line-Budget Mode / Frequency Bug-Fix (where an early > comparison fails single-element arrays), Minimum +1/-1 Moves to Make [1 .. N] Elements Distinct (where forgetting the > 1,000,000,000 -> -1 cap wipes out hidden boundary cases), and Round-Robin Total Client Waiting Time (where N = 100,000 and T[i] = 10,000 require a Fenwick Tree + Value-Suffix Decomposition instead of marching hour by hour). Because Codility hides your final score upon submission, locks proctoring switches per batch before the first invite goes out, and logs every prompt copy, external paste (insertFromPaste), "Out of Focus" (window.onblur) switch, and Timeline Slider edit, guessing on a 4-line edit limit or leaving a desktop overlay on-screen is a needless risk.

    To pinpoint the exact buggy line on Task 1 and verify my Fenwick tree bounds on Task 3 with zero browser telemetry flags, I paired Linkjob AI in Dual-Device Mode—scanning a QR code on my desktop dashboard to open Linkjob AI on my phone's mobile webpage, turning off the desktop answer-display toggle so zero UI ever existed on my laptop monitor, and tapping my phone's mobile webpage capture button (pressing zero laptop shortcut keys!) to read verified solutions 1 inch below my webcam lens (while also testing Desktop Floating Window Mode on unproctored web links). Below is everything that showed up on my 2026 CTC Codility OA, why some 97% scorers still get filtered at the resume gate, and how I advanced cleanly into CTC's technical interview loop.

    How the Chicago Trading Company Codility OA Fits Into CTC's 2026 Funnel

    Before starting my 170-minute clock, I compared CTC's market-making funnel against its Chicago and global prop-trading neighbors—including how I solved the 2026 DRW Codility assessment, my Akuna Capital HackerRank test breakdown, my Citadel CoderPad interview and assessment guide, crushing the Susquehanna International Group CodeSignal test, what I got on my Virtu Financial HackerRank test, and my Marshall Wace Codility test breakdown. Here are the three structural quirks that define CTC's 2026 process:

    1. Pre-Codility CCAT + The Pre-Resume Gate Order of Operations

    1. Optional Stage 1A — The 15-Minute, 50-Question CCAT: On many 2026/2027 campus SWE and Quantitative Trading tracks, CTC first sends an aptitude and behavioral screen (Criteria Cognitive Aptitude Test: 50 rapid-fire mental math, verbal, logic, and spatial questions in 15 minutes with no calculator—nobody finishes all 50 cleanly; answering 36 to 42+ accurately clears the bar), sending the Codility coding link 1 to 2 days later for SWE tracks.

    2. Why High Codility Scores Still Face a Resume Screen Afterward: CTC's campus recruiting documentation states explicitly that passing the online assessment triggers human resume review rather than an automatic phone interview. That explains why some candidates get a rejection email 12 hours after submitting (automated score/integrity threshold miss) while others pass 100% of visible cases and wait 1 to 3 weeks while engineering managers screen resumes against C++, Python, C#, Java, or low-latency systems fit!

    2. Inside the 170-Minute, 3-Question Codility Sitting

    1. 3 Tasks & Generous-Looking ~3-Hour Clock: Every 2024–2027 SWE candidate report agrees on 3 coding tasks in one continuous, un-pausable sitting, with invitation cards showing 170 minutes (or roughly 3 hours on 2027 campus relays). CTC also provides an official Codility practice link alongside your real invitation—always run that practice test first to verify compiler versions!

    2. Compile-First Partial Credit & Hidden Scores: Codility awards partial credit across hidden Correctness and Performance test cases only if your code compiles cleanly, and hides your numerical score completely once you submit.

    All 3 Real Tasks From My 2026 Chicago Trading Company Codility Sitting (With 100%-Pass Python Code)

    Here are the three exact tasks from my 2026 Chicago Trading Company Associate SWE Codility sitting (alongside recurring patterns tracked in Codility test questions and assessments), in the exact order they appeared.

    1. Task 1: Most Frequent Bounded Element Under a Strict 4-Line Edit Budget (Bug-Fix)

    1. The Problem Prompt: You are handed a pre-written function solution(M: int, A: list[int]) -> int (1 <= len(A) <= 100,000, 0 <= A[i] <= M <= 10,000) intended to return whichever integer occurs most frequently inside A (returning any tied winner if multiple values share the highest frequency). The starter code contains a subtle bug, and Codility restricts you to modifying at most 4 lines (rewriting the whole function from scratch is penalized/rejected by the line-diff grader!).

    2. Why Candidates Burn 20 Minutes Blaming Tie-Breaking Instead of Execution Order: In Codility's classic buggy starter template, max_occ = 1, index = -1, and inside the loop the code checks if count[A[i]] > 0: -> tmp = count[A[i]] -> if tmp > max_occ: max_occ = tmp; index = i -> count[A[i]] = tmp + 1! Look closely at what fails when A = [0] or A = [1, 2, 3] (all distinct elements occurring once):

      1. On the first appearance of A[i], count[A[i]] is 0, so the if count[A[i]] > 0: branch never runs!

      2. index stays stuck at its initial -1—so return A[index] accidentally returns A[-1] in Python (or crashes with ArrayIndexOutOfBoundsException in Java/C++/C#!), or fails whenever A = [5, 5, 2] vs. singletons!

      3. The Clean 2-Line Surgical Fix: Initialize index = 0 (instead of -1, since len(A) >= 1 is guaranteed!) and compare if tmp + 1 > max_occ: (max_occ = tmp + 1) when updating, keeping total modified lines well inside the 4-line budget!

    3. My 100% Passing Surgical 3-Line Diff (Python 3):

    def solution(M: int, A: list[int]) -> int:
        N = len(A)
        count = [0] * (M + 1)
        max_occ = 1
        # Fixed Line 1: initialize index = 0 instead of -1 so all-distinct arrays return a valid element
        index = 0
        for i in range(N):
            if count[A[i]] > 0:
                tmp = count[A[i]]
                # Fixed Lines 2-3: compare new frequency (tmp + 1) against max_occ before incrementing
                if tmp + 1 > max_occ:
                    max_occ = tmp + 1
                    index = i
                count[A[i]] = tmp + 1
            else:
                count[A[i]] = 1
        return A[index]
    
    if __name__ == "__main__":
        print(solution(3, [1, 2, 3, 3, 1, 3, 1]))  # 1 or 3 (both appear 3 times)
        print(solution(5, [4]))                    # 4 (singleton safe!)
        print(solution(5, [1, 2, 3]))              # 1 (all-distinct safe!)
    

    2. Task 2: Minimum +1/-1 Moves to Make All Values Pairwise Distinct in [1 .. N] (10^9 Cap Trap!)

    1. The Problem Prompt: Given an integer array A of length N (1 <= N <= 200,000) where every element currently satisfies 1 <= A[i] <= N, one move increments or decrements any single element by 1. Return the minimum number of moves required so that all N elements lie inside [1 .. N] and are pairwise distinct—or return -1 if the minimum move count strictly exceeds 1,000,000,000! (Samples: [1, 2, 1] -> 2, [2, 1, 4, 4] -> 1, [6, 2, 3, 5, 6, 3] -> 4.)

    2. The Exchange-Argument Insight & Two Fatal Traps:

      1. Why Sorted Pairing A_sorted[i] -> i + 1 Is Always Optimal: Choosing N distinct integers from the exact range [1 .. N] forces the final multiset to be {1, 2, ..., N}—every integer from 1 to N appears once! By the 1D optimal-transport uncrossing lemma, pairing the i-th smallest input value A_sorted[i] (0-indexed) with target i + 1 minimizes sum(abs(A_sorted[i] - (i + 1))) in O(N log N) time!

      2. Trap — Missing the > 1,000,000,000 -> -1 Return & 32-Bit Overflow: At N = 200,000 with A = [1] * 200000, total moves equal 19,999,900,000—which both overflows 32-bit signed int in C++/Java/C# and exceeds 1,000,000,000! Leaving out if moves > 1_000_000_000: return -1 fails hidden stress cases instantly.

    3. My 100% Correctness & 100% Performance Hand-Typed Python Solution:

    def solution(A: list[int]) -> int:
        LIMIT = 1_000_000_000
        sorted_a = sorted(A)
        total_moves = 0
    
        for idx, val in enumerate(sorted_a):
            target = idx + 1
            diff = val - target if val >= target else target - val
            total_moves += diff
            if total_moves > LIMIT:
                return -1
    
        return total_moves
    
    if __name__ == "__main__":
        print(solution([1, 2, 1]))           # 2
        print(solution([2, 1, 4, 4]))        # 1
        print(solution([6, 2, 3, 5, 6, 3]))  # 4
    

    3. Task 3: Total Round-Robin Client Waiting Time (O(N log(max_T)) Fenwick Tree vs. 10^9-Hour Timeout)

    1. The Problem Prompt: N clients (1 <= N <= 100,000) stand in queue 0, 1, ..., N - 1, where client k requires T[k] hours of service (1 <= T[k] <= 10,000). A single specialist serves clients in 1-hour round-robin slices: client 0 gets 1 hour, client 1 gets 1 hour, ..., wrapping back around while skipping finished clients. A client's total waiting/turnaround time is the total hours elapsed from t = 0 until their final (T[k]-th) hour completes. Return the sum of completion times across all N clients (check whether your prompt asks for raw 64-bit integer or modulo 10^9—Codility's classic total_waiting_time takes % 1_000_000_000!). Samples: [3, 1, 2] -> 13, [1, 2, 3, 4] -> 24, [7, 7, 7] -> 60, [10000] -> 10000.

    2. Why Hour-by-Hour Simulation Dies & Counting Rounds Solves 10^9 Hours in 0.09s:

      1. At N = 100,000 and T[k] = 10,000, total hours reach 1,000,000,000 (10^9)—a queue simulation times out completely!

      2. Instead, compute exact finish[k] analytically! How much time passes up to and including client k's p-th (p = T[k]) slice?

        1. Every client j with T[j] < p finishes all T[j] of their hours before round p, contributing sum(T[j] for all j with T[j] < p).

        2. Every client j with T[j] >= p completes p - 1 full earlier rounds (1 .. p - 1), contributing (p - 1) * count(all j with T[j] >= p).

        3. Inside round p itself, only clients j <= k (earlier in line, plus k itself) with T[j] >= p take their p-th hour before or at client k's completion, contributing count(j <= k with T[j] >= p)!

      3. Terms (1) and (2) depend only on p = T[k] and are precomputed in O(max_T) using frequency arrays, while Term (3) is answered in O(log(max_T)) per client with a 15-line Fenwick Tree (Binary Indexed Tree) as you scan k = 0 .. N - 1!

    3. My 100% Correctness & 100% Performance Hand-Typed Python Solution:

    def solution(T: list[int], use_mod_billion: bool = True) -> int:
        if not T:
            return 0
    
        MOD = 1_000_000_000
        max_t = max(T)
    
        # Precompute global frequency, prefix sum of values < p, and suffix count of values >= p
        freq = [0] * (max_t + 2)
        for val in T:
            freq[val] += 1
    
        sum_strictly_less = [0] * (max_t + 2)
        running_val_sum = 0
        for v in range(1, max_t + 1):
            sum_strictly_less[v] = running_val_sum
            running_val_sum += v * freq[v]
    
        count_at_least = [0] * (max_t + 2)
        running_cnt = 0
        for v in range(max_t, 0, -1):
            running_cnt += freq[v]
            count_at_least[v] = running_cnt
    
        # Fenwick tree tracking prefix clients j <= k seen so far
        bit = [0] * (max_t + 2)
    
        def bit_add(idx: int) -> None:
            while idx <= max_t:
                bit[idx] += 1
                idx += idx & (-idx)
    
        def bit_prefix_sum(idx: int) -> int:
            s = 0
            while idx > 0:
                s += bit[idx]
                idx -= idx & (-idx)
            return s
    
        total_wait = 0
        seen_so_far = 0
    
        for p in T:
            bit_add(p)
            seen_so_far += 1
            # Clients j <= k with T[j] >= p equals (seen_so_far) - (seen_so_far with T[j] <= p - 1)
            earlier_ge_p = seen_so_far - bit_prefix_sum(p - 1)
    
            finish_k = (
                sum_strictly_less[p]
                + (p - 1) * count_at_least[p]
                + earlier_ge_p
            )
            total_wait += finish_k
            if use_mod_billion:
                total_wait %= MOD
    
        return total_wait
    
    if __name__ == "__main__":
        print(solution([3, 1, 2], use_mod_billion=False))     # 13
        print(solution([1, 2, 3, 4], use_mod_billion=False))  # 24
        print(solution([7, 7, 7], use_mod_billion=False))     # 60
        print(solution([10000], use_mod_billion=False))       # 10000
    

    How CTC's Codility Proctoring & Integrity Switches Work in 2026 (5 Signals)

    As I documented across how Codility detects cheating, can Codility detect copy and paste, can Codility detect tab switching when proctoring is enabled, whether Codility records your screen, and whether Codility uses your camera, Codility locks integrity switches per batch before the first invite is sent, and your pre-session disclosure screen names every active signal:

    1. Always-On Timeline Slider & Bug-Fix Edit Replay: CTC engineers scrub through your Timeline Slider—seeing 15 wild trial-and-error guesses on Task 1's 4-line bug fix or an instant 50-line Fenwick paste raises immediate suspicion.

    2. External Paste Attribution (insertFromPaste) & Prompt Copy Tracking: Copying task descriptions (Ctrl + C) or pasting from a local IDE (Ctrl + V) plants flagged markers directly onto your Candidate Report.

    3. "Out of Focus" Tab/Window Absence (window.onblur): Switching away from the Codility tab records exact departure timestamps and away-durations—contributing to Codility's four-band Behavioral Integrity Risk rating.

    4. Batch-Wide AST Similarity Checks: Normalizes Python, C++, Java, and C# syntax trees across the entire CTC campus/lateral applicant pool, flagging shared Discord/GitHub code and verbatim LLM templates.

    5. Per-Test Webcam, Screen, or Device Integrity Disclosures: Whenever full screen/webcam recording or the standalone Codility App is toggled on for a cohort, Codility displays an explicit consent prompt before your 170-minute clock begins.

    My Technical Blueprint to Clear CTC's Codility Gate Cleanly

    Applying the habits from how to use AI safely on Codility and how an invisible AI interview assistant works, plus lessons from my 2026 Toptal Codility test, I followed four strict rules:

    1. Rule 1: Compile First, Optimize Second, & Respect Bug-Fix Line Budgets: Non-compiling code scores 0—always diff your Task 1 fix against "Reset" so you stay strictly inside the 2-to-4-line modification limit!

    2. Rule 2: Keep Answers Off the Monitored Computer Screen: Rather than gambling on whether screen capture or Device Integrity is active on your cohort, view your reference code on a separate smartphone mounted 1 inch directly below your webcam lens.

    3. Rule 3: Check Overflow & Error-Sentinel Clauses Twice (> 10^9 -> -1 & % 10^9): Re-read the final paragraph of Task 2 and Task 3 for -1 overflow sentinels and modulo 1,000,000,000 rules before clicking Submit!

    4. Rule 4: Strip All print() Calls & Run 5 Custom Inputs: Delete debug prints so stdout never causes TIMEOUT ERROR on N = 100,000 Performance runs, and test [4] singletons, [1] * N overflow, and [7, 7, 7] ties in Codility's bottom console.

    How I Used Linkjob AI on My 170-Minute CTC Codility OA (Dual-Device vs. Floating Window)

    Fifteen minutes into Task 1, spotting why count[A[i]] > 0 skipped singletons under a 4-line edit budget—and later verifying the Fenwick round-counting decomposition on Task 3—took seconds with my AI interview assistant. Here is how both modes of this invisible coding interview assistant work:

    1. Mode 1: Dual-Device Mode (My #1 Setup for CTC Codility & Live Technical Screens)

    Because Dual-Device Mode removes 100% of AI windows from your laptop screen (working cleanly across proctored Codility links, Device Integrity, LockDown Browser, and live screen-shared interviews), this was my exact setup:

    1. QR Code Pairing to My Phone's Mobile Webpage & Turning Off Desktop Display: Before opening my CTC Codility link, I launched the Linkjob AI desktop app, granted accessibility permissions, scanned the dashboard QR code with my phone camera to open Linkjob AI in my phone's mobile webpage, and turned off the desktop answer-display toggle. Zero UI or overlays existed on my laptop display.

    2. Silent Remote Capture From My Phone's Mobile Webpage: Across all 3 tasks, I tapped the capture button directly on my phone's mobile webpage—capturing the starter bug-fix code and math constraints silently with zero laptop keystrokes, zero prompt Ctrl + C, and 0 "Out of Focus" (window.onblur) events.

    3. Reading Surgical Bug-Fix & Fenwick Code 1 Inch Below My Webcam: Within seconds, the exact 3-line tmp + 1 > max_occ diff, the 1,000,000,000 -1 guard, and the 45-line Fenwick round counter appeared solely on my phone's mobile webpage, mounted 1 inch below my webcam lens. I typed everything manually, verified all sample and boundary cases, and finished 65 minutes ahead of my 170-minute timer!

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

    If your CTC pre-start disclosure screen requests no Screen/Video recording and no Codility App check and you prefer viewing solutions on your main monitor, use Linkjob AI's Desktop Floating Window Mode while obeying two strict rules:

    1. Complete All Configuration Before Opening the Link (Never Click Settings Mid-Test): Launch Linkjob AI, select Python 3, C++20, Java, or C#, and position the semi-transparent floating window beside the Monaco editor before opening Codility. Once the 170-minute timer starts, never click the "Settings" button or any menu inside the floating window so Chrome never logs an "Out of Focus" marker (window.onblur).

    2. Never Press Cmd + \ or Ctrl + \ During the Assessment: Never press Cmd + \ or Ctrl + \ to toggle the floating window open or closed while an active Codility session is running. Leave it fixed in place until you submit Task 3 and close the browser tab.

    My 4-Step Pre-Test Checklist Before Launching CTC's Codility Link

    1. Step 1: Warm Up Mental Math for CCAT & Run CTC's Codility Practice Link: Drill 15-minute no-calculator fractions/percentages if your track includes CCAT first, and run the official Codility practice test included in CTC's email.

    2. Step 2: Read the Pre-Start Disclosure Screen & Pre-Pair Linkjob AI: Check active proctoring switches, unplug secondary monitors (window.screen.isExtended === false), and pair Dual-Device Mode via QR code to your phone's mobile webpage with desktop answer display turned OFF.

    3. Step 3: Budget 20m Task 1 / 25m Task 2 / 55m Task 3 (Leaving 70m Buffer): Never rush a permanent Codility task submission when you have 170 minutes—test every error sentinel (-1 caps and modulo 10^9) carefully before locking!

    4. Step 4: Polish C++ / Python / C# Systems & Options Basics on Your Resume: Remember that passing Codility triggers CTC's human resume screen—make sure low-latency, multithreading, or quantitative projects stand out clearly at the top of your resume!

    Frequently Asked Questions About the Chicago Trading Company Codility OA (FAQ)

    1. How many questions and minutes are on the 2026 Chicago Trading Company Codility OA?

    Every recent SWE and Associate SWE report confirms 3 coding questions in one un-pausable sitting, with timers set at 170 minutes (or roughly 3 hours across 2026–2027 cohorts), typically mixing 1 bug-fixing task, 1 greedy/sorting math task, and 1 O(N log V) data-structure optimization task.

    2. Do you need a 100% Codility score to pass at Chicago Trading Company?

    CTC publishes no fixed cutoff, awards partial credit on compiling code, and hides your score after submission. Because Codility acts as a pre-resume gate, scoring 85% to 100% across hidden Correctness and Performance tests unlocks human resume review—where your project depth and GPA/systems background determine interview invites.

    3. Does Chicago Trading Company also send a CCAT aptitude test?

    Yes, on many campus SWE and trading tracks, applicants first receive the 15-minute, 50-question Criteria Cognitive Aptitude Test (CCAT) (no calculator) plus a behavioral survey 1 to 2 days before the Codility coding link arrives; pure trading tracks rely primarily on the aptitude/quant sequence rather than SWE Codility.

    4. Why is Linkjob AI's Dual-Device Mode ideal for CTC's 170-minute Codility OA?

    Scanning the desktop QR code opens Linkjob AI on your phone's mobile webpage, and turning off the desktop answer-display toggle leaves zero UI or windows on your computer monitor—pinpointing exact 4-line bug-fix edits and O(N log V) Fenwick logic silently from your phone with 0 "Out of Focus" markers and 0 clipboard pastes.

    5. How long does CTC take to respond after Codility, and what comes next?

    Automated threshold rejections can arrive within 12 to 24 hours, while shortlisted resumes typically hear back within 1 to 3 weeks for a behavioral/HR or HireVue screen, a technical coding & systems phone interview (C++, C#, Java, or Python + concurrency/OOP), and a final Chicago Superday!

    See Also

    My Successful Strategy For Passing The BCG X CodeSignal Assessment In 2026

    How I Successfully Completed All Three McKinsey Solve Games In 2026

    My Proven Approach To Crushing The Hudson River Trading CodeSignal Assessment

    Effective Preparation Strategies For Capital One Data Analyst CodeSignal Questions

    My Guide To Passing The 2026 TikTok CodeSignal Online Assessment With Key Tips

    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.