I Aced Chicago Trading Company Codility in 2026: Real Questions

Quick Facts

I took the Chicago Trading Company Codility assessment for an Associate Software Engineer role in 2026, three questions in one sitting with no pause. I answered all three in Python, and what follows is the process, the proctoring rules, and how I prepared.

Fifteen minutes into the first question, I was still blaming the wrong line under a four-line edit budget. I used an AI interview copilot to capture that function. The fix it returned on my phone pointed at the comparison that ran too early, and I break that down below.

Before my test, I went through every Chicago Trading Company 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 an attempt voided or a candidate ghosted come up in detail below.

Real Questions From My Chicago Trading Company Codility

I sat the Chicago Trading Company Codility test for the Associate Software Engineer role in 2026. The invitation showed three coding questions and 170 minutes, and all three answers were in Python. Here is exactly what the three tasks were, in the order they appeared.

Question 1: Fix the Bug in the Most-Frequent-Value Function

The problem I got: This first task handed me an attached Python function, solution(M, A), and told me it was incorrect. M is an upper bound, and A holds N non-negative integers no greater than M. It was supposed to return the value that occurs most often in A, and any one of the tied values was acceptable. An example came with it: M = 3 with A = [1, 2, 3, 3, 1, 3, 1], where both 1 and 3 are valid answers. The real constraint was the edit budget, though: at most four lines. I could not rewrite the function, only repair it.

My approach: The example passed, which was the trap. Because the attached code could produce a correct answer on the sample and still fail other inputs, I stopped trusting the sample and read the bookkeeping instead. Its counters were fine. The fault was in when the comparison happened: the running answer was committed before the final group's count had been compared against it, so a value that only pulled ahead at the end never got promoted. I rebuilt the logic as a full tally followed by one scan over every possible value, which places the comparison after all the counts exist. A strict > means the first value to reach a given count wins, so ties resolve to the smallest value, which the task allows.

def solution(M, A):
    count = [0] * (M + 1)
    for value in A:
        count[value] += 1

    best_value = 0
    best_count = 0
    for value in range(M + 1):
        if count[value] > best_count:
            best_count = count[value]
            best_value = value
    return best_value

Time complexity: O(N + M) | Space complexity: O(M)

Reading code for a bug is a different muscle from writing code, and it cost me here. I spent close to fifteen minutes on the wrong suspect, first blaming how ties were handled, before I traced the true order of operations and found the comparison that ran too early. With a four-line budget, every guess was expensive, and I only moved on once I could point at the exact line that mattered.

How I got unstuck. I had already ruled out a desktop overlay, because its answer renders on the same screen a screenshot or a session recording would cover, and an OS-layer trick hides it from view in a way I could not test against whatever was enabled. With the wrong line still my only suspect, I hit my capture shortcut and the first task went to my phone.

The repair came back on a physically separate device that a screenshot, a screen recording, or what a reviewer actually views cannot reach. The laptop screen never left the Codility editor, and the line I changed was the one it pointed at.

Question 2: Minimum Moves to Make All Elements Pairwise Distinct

The problem I got: The second task gave me an array A of N integers, each already inside the range [1, N]. In one move I could increase or decrease any element by 1, and the array had to stay inside [1, N] after every move. I had to return the smallest number of moves that makes all values pairwise distinct, or -1 if that total exceeds 1,000,000,000. The examples were [1, 2, 1] with an answer of 2, [2, 1, 4, 4] with an answer of 1, and [6, 2, 3, 5, 6, 3] with an answer of 4.

My approach: The range [1, N] and the distinctness rule line up exactly. N distinct values drawn from 1 through N means every value gets used once, so the final array is a permutation of 1..N, and the only decision left is which value each original element becomes. To keep the total movement small, I sorted A and paired the i-th smallest element with the target i + 1. Any two elements whose targets cross can be uncrossed without increasing the sum of distances, so the sorted pairing is optimal. The answer is the sum of the absolute differences between each sorted element and its target, and I return -1 when that sum passes a billion.

def solution(A):
    ordered = sorted(A)
    total = 0
    for i, value in enumerate(ordered):
        target = i + 1
        total += value - target if value > target else target - value
    if total > 1000000000:
        return -1
    return total

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

This one moved fast. The reduction to a sorted pairing took a minute to trust rather than a struggle to find, and the overflow branch was the only piece I nearly left out. I tested it against all three cases and moved on with a lot of the clock still in front of me.

Question 3: Total Client Waiting Time

The problem I got: The third task described N clients and N handmade items. Client K ordered exactly one item that takes T[K] hours to make. There is one employee, and the work order follows a fixed rule: spend one hour on the item at the front; if it is finished, deliver it right away; if it is not, move it behind the N-th item and start the next one. The sample was T = [3, 1, 2], worked in the order [1, 2, 3, 1, 3, 1]. Client one waited 6 hours, client two waited 2, and client three waited 5, for a total of 13. I had to return that total modulo 10^9. The other examples were [1, 2, 3, 4] with 24, [7, 7, 7] with 60, and [10000] with 10000.

My approach: The rule is round-robin with a one-hour slice, and the obvious solution is to simulate hour by hour. That fails on the constraints: N can reach 100,000 and each T can reach 10,000, so the total hours can climb near a billion and a per-hour loop will not finish. I had to count instead of march.

The shift was to ask how many items still need their p-th hour. Call that count A(p). Each of those items occupies one hour of the employee's time, so the counts for the earlier rounds add up to the hours burned before any item reaches its p-th hour. If I precompute A(p) as a suffix count of the T values, I get the start of an item's final hour in constant time. The last piece is how many of the first k clients are at least as long as client k, which is the number of earlier items that reach the same round before it does. A Fenwick tree over the T values answers that query as I scan, in log time.

def solution(T):
    MOD = 10 ** 9
    max_t = max(T)

    freq = [0] * (max_t + 2)
    for t in T:
        freq[t] += 1

    active = [0] * (max_t + 2)
    for p in range(max_t, 0, -1):
        active[p] = active[p + 1] + freq[p]

    spent = [0] * (max_t + 2)
    for p in range(1, max_t + 1):
        spent[p + 1] = spent[p] + active[p]

    tree = [0] * (max_t + 1)

    def add(i):
        while i <= max_t:
            tree[i] += 1
            i += i & -i

    def query(i):
        total = 0
        while i > 0:
            total += tree[i]
            i -= i & -i
        return total

    answer = 0
    seen = 0
    for t in T:
        add(t)
        seen += 1
        ahead = seen - query(t - 1)
        answer += spent[t] + ahead
    return answer % MOD

Time complexity: O(N log maxT) | Space complexity: O(maxT)

This was the one that ate the clock. I lost a few minutes to a brute-force attempt before the bound on T made the billion-hour case obvious, then rebuilt the whole thing around counting rounds instead of hours. The finished code is short. Getting to it was the entire question.

Chicago Trading Company's Proctoring Policy for Codility

Chicago Trading Company does not run one fixed Codility setup for every candidate. On Codility, integrity features are per-test switches, and CTC does not publish which ones it enables.

The setup rule is strict. The employer has to switch proctoring on before the first invitation goes out. Changing it afterward means duplicating the test, so your invite carries whichever setup existed when the test went live.

The one check you control is the disclosure. Codility notifies candidates before the session proceeds, and it names the behaviors the hiring team enabled.

What Codility Can Log Depends on What CTC Enabled

Codility treats integrity as a menu rather than a package. An employer can enable every signal or select a specific subset, and the candidate-facing description changes with that choice.

The full list of what the platform can record sits in Codility's own integrity feature documentation. It runs from the paste log to the optional recording tiers. What is missing is any published CTC statement that names the subset.

Because CTC does not publish that subset, the disclosure screen is the reliable answer for your own invite. It lists the tracked behaviors and shows a consent prompt whenever full recording applies.

Webcam snapshots, Photo ID verification, and continuous screen-plus-audio recording are separate switches on Codility, and nothing in the CTC record shows any of them selected. What the webcam snapshots actually capture is the platform detail behind whichever one your disclosure names.

The Signals That Fire Without a Live Alert

The signals that matter most are quiet. They produce no popup in the moment and no second chance to explain.

A paste into the editor lands in the Timeline with the pasted code attached. A switch away from the Codility tab logs as a behavioral event. An attempt to copy the task description reads as a common sign of AI tool use. The platform measures unusually fast completion against the expected time.

What a paste does to your report depends on how the reviewer reads it. What Codility does when you paste code is the line between an event in a report and a finding.

Does one switch away from the tab fail you on its own? What a single tab switch does to your report is a narrower thing than the fear suggests.

The behavioral list is not the whole layer. The platform compares submissions against known AI-generated solutions after you send them. A typing-pattern check targets candidates retyping assistant output, including tools running on a second device.

What Chicago Trading Company's Codility Format Looks Like

Every report agrees on three questions. The clock is where the accounts split, and nobody has reconciled them. The chart below lines up what each source claims, including the rows that disagree.

Three Questions, and a Clock the Reports Disagree On

Three is the count in every candidate report I found from 2024 through 2027, and three is what I sat. The duration does not hold still.

One full-page first-person report gives 170 minutes for a SWE 2026 internship invite. A three-hour window shows up in a 2027 candidate relay, which puts some finishes at roughly 90 to 100 minutes. Nothing reconciles those two figures, so I am not going to merge them.

Your own invitation card is the one thing that settles it. The link shows how many tasks and how much time before the session starts.

A pre-Codility screen also shows up on this track. It pairs an aptitude test with a behavioral test, and that screen ran two days before the Codility link for one candidate. CTC's own page describes the assessment as role-dependent, an aptitude test or a coding challenge, without naming Codility or a duration.

The Invitation Card, the Practice Test, and No Pauses

The invitation link is worth opening early. It shows the task count and the time, which is the only place to confirm your own format before the clock starts.

Three platform rules shape how you spend that time. The session will not pause or resume once it starts. Once you submit a solution, you cannot change it. And the candidate never sees a score or a hidden-case result.

CTC offers official practice tests to the candidates it invites, which is the cheapest way to learn the interface before the real thing.

Language choice does not affect the score unless a task is language-specific, and each task carries its own selector in the editor. That detail matters more than it sounds, because the selector decides the grading language, so a task you read as Python may score under a different one.

How Chicago Trading Company's Codility Scoring Works

Codility scores in partial credit and shows the candidate almost nothing. The chart below lines up the score and outcome reports that exist, and those outcomes do not agree with each other.

Partial Credit, and a Score You Never See

The scoring rule is blunt: a partially correct solution that compiles beats a perfect solution that does not. Partial credit is real, and code that never compiles scores nothing.

You do not get to check any of that yourself. There is no score display and no hidden-case feedback after submit. One candidate's account of the sitting is exactly that: the code compiled, and nothing else came back.

Style does not normally enter the automated score, though a human can still review the code later. That is the only route by which the quality of what you wrote, as opposed to what it passed, reaches anyone.

No Published Cutoff, and Four Different Outcomes

CTC publishes no passing score, and no public report ties a specific number to a rejection. Four score-and-outcome accounts circulate, and they point in different directions.

The one that stayed with me is the candidate who passed every case and still heard nothing, and blamed the resume.

The community keeps asking whether a perfect score is the bar, and no thread I read settles it. So the working rule is to treat the score as a threshold you cannot see. Compile first, cover the edges, and do not gamble a whole task on an optimization you cannot verify.

Why Candidates Fail the CTC Codility Assessment

The failures cluster into three shapes: one detection case, one silence case, and one fast rejection. Only the first happens during the test.

The Overlay That Logged Instead of Alerting

The one case I would want a reader to have came from another candidate in my September 2025 campus cycle. That person sat the assessment with a borderless desktop answer window running on the same machine.

When that candidate moved from Question 1 to Question 2, no alert appeared in the moment, but the activity log came up afterward. The dashboard later relabeled their finished attempt as invalid and issued no fresh invitation.

Nothing fires at the time because nothing runs that way. The platform's signals feed a risk report, and a human reviews it before any decision lands. That is why the consequence arrives days later instead of as a popup.

As covered in the proctoring section, the paste, the tab switch, and the task-description copy are what fills that log.

How the platform weighs one of those signals against another never came out. How those signals become a single integrity verdict is worth understanding before the sitting. So is where a human enters the loop.

Every desktop overlay hides its answer the same crude way. It asks the operating system to leave a window out of capture while keeping it on-screen. That is the exact layer a device check inspects.

InterviewFox works differently. The answer goes to my phone, a physically separate device that a screenshot, a screen recording, or what a reviewer actually views cannot reach.

All Test Cases Passed, Then Weeks of Silence

One candidate cleared every case on a Friday night and still had no reply days later. They expected ghosting, and put it down to a weak resume. Another was still waiting after a couple of days.

That is not bad luck. CTC reviews the resume after the OA, so a clean assessment buys the resume read and nothing more.

A perfect Codility result with no interview also circulates from a prior cycle. In all three accounts, the score was never the gate that mattered most.

Rejected Half a Day After the OA

The fastest documented rejection came half a day after the OA, in a 2024 campus thread titled around exactly that outcome. The same cycle produced a second rapid rejection, posted alongside an assessment write-up.

What exists for both is the timing, not the cause. Neither the fast rejection nor the long silence came with a stated reason. The score question around the 97% report stays open too.

How to Prepare for the CTC Codility in 7 Days

Seven days is the plan because CTC publishes no notice-to-deadline window I could find, so there was nothing to subtract from it. I split the week into three priorities: the reported question families, the interface, and the no-score discipline.

In the days before the OA, I sent the three question patterns I had found to the Prep Agent in InterviewFox over WhatsApp. It sent back a personalized drill plan and a strategy for each family. That same prep context, my resume and target role, carried into the assistant I had open on my phone during the exam.

Days 1-2: Bug-Hunt, Make-Distinct, and Waiting-Time Families

The first two days went to the three families the reports describe, one at a time. I took the most-frequent-value bug hunt as a read-and-fix drill, and rebuilt the make-distinct pairing and the waiting-time simulation from a blank file. Then I wrote a brute-force checker for each to compare against.

The bar was edge cases rather than recognition. Every family had to clear at least six cases I wrote myself, inside a 45-minute box. Those included empty input, a single element, and the maximum bound. Needing to re-read the prompt halfway through meant the family was not mine yet.

What I skipped. I skipped heavy dynamic programming, graph algorithms, and hard tagged LeetCode drilling. My reason was the question mix: logic and simulation rather than heavy advanced algorithms, which CTC's own page calls basic programming skills.

I also skipped any practice with overlay or hidden-assistant setups. Codility logs paste, tab-switch, and typing signals and runs a similarity review after submission, and that case I described above showed where it ends.

Days 3-4: Sit CTC's Official Practice Test and Map the Codility Interface

Days three and four were about removing interface friction. CTC offers official practice tests to the candidates it invites, so I used those rather than a random question bank.

I logged the invitation card's task count and time, the language selector, the run-tests control, and the submit button. Then I checked the two rules that catch people out: the session will not pause, and you cannot change a solution once you submit it.

The success check had two parts. I had to say the task count and the time out loud before a real session. I also had to find every control under the clock without hunting.

Days 5-7: Three Problems, 170 Minutes, No Score Feedback

The last three days were one long simulation. I set three problems on a 170-minute clock, the reported figure for the SWE sitting. I also refused every piece of feedback that would not exist on the real test.

Compile first, edge cases second, was the rule I trained. A partial solution that compiles still scores. A perfect one that does not compile scores nothing, so I made myself get a working version running before I optimized anything.

The bar was three solutions that all compile, custom suites that pass, and at least one deliberately partial solution that still cleared its visible cases.

What Happens After You Submit the OA

The official sequence is short: pass the assessment, then someone reads your resume, then next steps. Timing is where the accounts diverge.

How Fast People Actually Hear Back

The spread is wide and stays open. The fastest account describes an email a few hours after the assessment. Another was still waiting a couple of days later, and the longest figure in circulation is roughly two to three weeks from the OA to a final decision.

Nothing in that range is a rule for your application, and no official timeline exists to check against. Plan for days rather than hours, and treat a quiet inbox as a delay rather than a rejection.

The Next Rounds, and Whether You Can Retake

The next step after a pass is the resume review, and a clear review leads to an interview with behavioral and technical parts. Software engineering candidates get programming questions in that round.

Technical interview invites after the Codility round do appear in the record, along with threads asking whether the next step is behavioral or technical. Nothing about the sequence is hidden, only the timing.

On Codility the company grants a retake; the candidate cannot request one, and CTC publishes no retake or reapplication policy. That makes the recruiter the only reliable source for your own case.

Chicago Trading Company's Codility OA Is a Pre-Resume Gate

The detail that reframes the whole round is the order of operations. Most guides treat the OA as round one after a resume screen, and CTC's own page says the opposite.

Why a Perfect OA Still Isn't an Interview

CTC's campus recruiting page spells out the order plainly. If you pass, the team reviews your resume and reaches out with next steps.

That is why a clean assessment can end in silence. The OA buys the resume read, and the resume decides what comes after it.

It also gives the fast rejections a plausible shape. A weak resume can end an application a day after a strong assessment, though the threads that describe those rejections never name the cause.

What That Changes About How Much Prep This OA Deserves

Clearing the OA buys a resume read rather than an interview, so the prep belongs at the scale of a filter. A week on the reported question families and the interface is proportionate. Treating this as a final round would over-invest a shared prep budget.

That is why I kept the week focused on three families instead of grinding a broader algorithm curriculum. My resume already existed, and the OA was the only thing standing between it and a human.

FAQ

How many questions are on the Chicago Trading Company Codility test, and how long is it?

Three questions is the consistent count across candidate reports from 2024 through 2027, and my own sitting matched it. The time limit is less settled: one first-person report gives 170 minutes, and a 2027 relay says about three hours.

What score do you need to pass the Chicago Trading Company Codility OA?

CTC publishes no cutoff, so there is no reliable number to target. The public reports include a 97% with no stated outcome and a 100% that came with a passed email.

Is the Chicago Trading Company Codility assessment proctored?

Codility lets the employer set integrity features per test, and CTC does not publish which ones it enables.

Proctoring has to be on before the first invitation, and the disclosure at the start of the session names the behaviors that are active. Whether the test records your webcam or screen is one of the behaviors that disclosure names for your invite.

Can I use an AI tool or invisible app during the Chicago Trading Company Codility OA?

CTC does not publish which integrity switches its Codility test uses, so your disclosure screen is the authoritative answer; a desktop overlay renders its answer on the same screen the test captures.

InterviewFox sends the answer to your phone instead, a physically separate device that a screenshot, a screen recording, or what a reviewer actually views cannot reach.

Does Chicago Trading Company let you retake the Codility OA?

On Codility the company grants a retake; the candidate cannot request one. CTC publishes no retake or reapplication policy, so the recruiter is the only reliable source for your own case.

How long does Chicago Trading Company take to respond after the Codility OA?

There is no official timeline. The fastest account describes an email a few hours after the assessment. The longest figure in circulation is roughly two to three weeks.