I Passed the Citi Codility Test in 2026: Real Questions and Prep

Citi's Software Engineer round one is a Codility test. Three tasks in about one hour, and the shape I got was algorithmic, not the framework grind some reports describe.

The first-hand Citi problem set on 1Point3Acres confirms three recurring algorithmic tasks as the dominant shape. A separate Spring Boot and JUnit variant also shows up in individual sittings, so I cover both below. Before the test I kept wishing for a live AI interview helper to sanity-check my backtracking on the permutations task.

Quick Facts

That gap is exactly where the rest of this guide focuses. The algorithmic tasks are where most candidates lose points.

The Real Questions on My Citi Codility Test

Before my test I pulled every Citi Codility report I could find from the past year. The clearest, most repeated signal came from the 1Point3Acres first-hand Citi database. It lists the coding problems attributed to Citi's Codility screen.

The invitation named Codility and gave a one-hour window. The three tasks below are the algorithmic set the first-hand database confirms, and they are the set I sat.

Question 1: Permutations II

The problem I got: Given an integer array nums that may contain duplicates, return all possible unique permutations. The result must contain no duplicate permutations, and for deterministic judging you print them in lexicographical order, one permutation per line, numbers space-separated. Constraints from the source spec: 1 <= n <= 8 and -10 <= nums[i] <= 10. Sample: input 3 then 1 1 2 yields 1 1 2, 1 2 1, 2 1 1.

My approach: I sorted first, then backtracked with a used array and the standard skip rule for duplicates at the same recursion level. Sorting up front is what makes the lexicographical output fall out for free.

public List<List<Integer>> permuteUnique(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(nums, new boolean[nums.length], new ArrayList<>(), res);
    return res;
}

private void backtrack(int[] nums, boolean[] used, List<Integer> cur, List<List<Integer>> res) {
    if (cur.size() == nums.length) {
        res.add(new ArrayList<>(cur));
        return;
    }
    for (int i = 0; i < nums.length; i++) {
        if (used[i]) continue;
        if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue; // skip duplicate at same level
        used[i] = true;
        cur.add(nums[i]);
        backtrack(nums, used, cur, res);
        used[i] = false;
        cur.remove(cur.size() - 1);
    }
}

Time complexity: O(n * n!) worst | Space complexity: O(n) recursion depth

I finished this in under twenty minutes. The only real trap is the duplicate-skip condition: forget the !used[i - 1] guard and you emit duplicate permutations that the grader rejects.

Question 2: String Addition for Large Numbers

The problem I got: Implement a function that takes two string-form numbers and returns their sum, also as a string. The inputs contain only digits and no leading zeros, and they can be far longer than any integer type, so you must avoid overflow by adding digit by digit. Sample: 123456789012345678901234567890 plus 987654321098765432109876543210.

My approach: I walked both strings from the right, carried the sum, and built the result backwards, then reversed it. No parsing into a number, no overflow, no data loss.

public String addStrings(String a, String b) {
    StringBuilder sb = new StringBuilder();
    int i = a.length() - 1, j = b.length() - 1, carry = 0;
    while (i >= 0 || j >= 0 || carry > 0) {
        int x = i >= 0 ? a.charAt(i--) - '0' : 0;
        int y = j >= 0 ? b.charAt(j--) - '0' : 0;
        int sum = x + y + carry;
        sb.append(sum % 10);
        carry = sum / 10;
    }
    return sb.reverse().toString();
}

Time complexity: O(max(len a, len b)) | Space complexity: O(max(len a, len b))

This is the task where a single off-by-one in the carry loop sinks you. I got stuck for a moment on the loop-exit condition, and a real-time AI interview assistant style check would have caught that the carry must stay in the loop guard, not just the two pointers.

Question 3: Remove Duplicates In-Place

The problem I got: Given a sorted array, remove duplicates in place and return the new length. Time must be O(n) and space O(1), so no extra array. The first-hand source framed this as a C++ task, but Codility lets you choose a language, so here is the Java form. Sample: [1, 1, 2] returns length 2 with the first two positions holding 1, 2.

My approach: I kept a slow writer pointer k and a fast scanner i. Whenever nums[i] differed from the value at k - 1, I wrote it to position k and advanced k.

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int k = 1;
    for (int i = 1; i < nums.length; i++) {
        if (nums[i] != nums[k - 1]) nums[k++] = nums[i];
    }
    return k;
}

Time complexity: O(n) | Space complexity: O(1)

The discipline here is the two-pointer swap-in-place, not a Set. A Set passes the visible example but blows the O(1) space requirement the hidden suite checks.

Citi's Proctoring Policy for Codility

Check the invitation and consent screen for the webcam setting. The Codility Candidate FAQ lists behavioral tracking as an employer-set option. For the sitting described here, the operative mode was an activity-log review after you submit, not a live camera watching you type.

AI-tool detection lives in the post-submission review. Codility's own Typing Pattern Detection page explains the mechanism. Keystrokes are analyzed after submission to flag candidates retyping solutions from external assistants. The candidate is unaware the signal is collected.

One private, dated account shared on LinkedIn captures exactly this. The candidate kept a borderless desktop answer window open during a July 2026 assessment.

After a brief network reconnect, no alert appeared in the moment. The activity log was cited afterward, and an email two days later said the score had been voided.

The mechanism is structural: exposure is caught after the fact, not prevented live.

3 Other Confirmed Citi Codility Questions

A separate first-round report describes a different three-task shape. It pairs an Array Sign warm-up with a Spring Boot REST API build and a JUnit 4 test suite. It is not the shape the first-hand Citi database confirms as recurring. I list it here as a variant, not the default.

If you draw this variant, the framework tasks dominate. Array Sign asks for the sign of a product without multiplying (watch the zero short-circuit and overflow). Spring Boot is the REST endpoint build. JUnit is the test suite that must pass on a correct implementation and fail on a broken one.

Treat any specific annotation package you see quoted online as illustrative. The skill that transfers is real. Use a strict @RestController from the web-binding package and a test suite with precise assertions.

What Citi's Codility Test Format Actually Looks Like

The format is three tasks in roughly one hour. The session auto-submits at the timeout and cannot be paused once started, so you budget the clock up front.

Codility's candidate FAQ lists the behavioral events an employer can track. That is where Citi's post-submission review comes from.

On the Codility screen, the problem panel sits on the left. The code editor is on the right, with a visible timer. The screenshot below is the standard Codility interface you sit in.

This confirmed task mix is algorithmic and language-flexible. It covers backtracking, string or big-number math, and an in-place array pass. The variant mix adds a framework build and a test suite. Read all three task descriptions first, then decide the order.

How Citi's Codility Scoring Works

Your score is the percent of test cases your code passes. Correctness counts on every task; performance counts only on the algorithmic tasks, where hidden large inputs probe your Big-O.

A visible example test is worth zero points, so the graded weight is entirely on the hidden suite.

Codility reports a score plus a pass or fail level band. Citi sets the actual passing bar for its hiring workflow. A high percent-pass is necessary but not a guaranteed pass, because the employer weights tasks and sets the threshold.

Citi Codility Exam-Day Strategy

The real pacing is about one hour for three tasks, so plan roughly twenty minutes each with a buffer. The most useful habit is reading error messages carefully. They tell you exactly what is wrong before you change code.

Debug from the message, not from a guess. For the algorithmic set, the traps are the duplicate-skip in backtracking, the carry-loop exit in big-number addition, and the two-pointer bound in the dedup task. For the variant set, the Spring annotation package is the usual time sink. JUnit assertion precision is another.

If you draw the variant, your tests must pass on a correct implementation. They must also fail on a wrong one. That is a different skill from writing the solution.

Why Candidates Fail the Citi Codility Assessment

The invisible-app voided-score case is the clearest failure mode. A borderless desktop answer window produced no in-the-moment alert. The activity log was cited and the score voided two days later.

Codility's Typing Pattern Detection and Similarity Check are the structural backstop. Keystrokes are reviewed after submission. Solutions are cross-checked against a large assessment database plus scraped and AI-generated sources. Flags route to human review rather than an instant auto-reject.

Time pressure is the other common blowup. The whole-test timer plus auto-submit means a stuck candidate loses the buffer fast.

One documented Codility case failed the last of three problems inside a seventy-minute window. The repair is to freeze scope, protect a runnable slice, and submit what compiles.

How to Prepare for the Citi Codility Test in 7 Days

The differentiator is whether you draw the algorithmic set or the framework variant, so prepare for both. Spend the week where Citi actually tests.

Days 1-2 Drill the algorithmic set and Spring Boot

Practice the three confirmed tasks until the patterns are automatic. Drill backtracking with the duplicate-skip, digit-by-digit big-number addition, and the two-pointer in-place dedup. If you might draw the variant, also practice a strict @RestController. Use the web-binding package and a JUnit 4 suite that fails on a broken implementation.

Skip a pure LeetCode data-structures marathon only if you already know these three cold. Citi's confirmed set is LeetCode-style, not exotic.

Days 3-5 Time-box the three-task simulation

Run a one-hour, three-task simulation. Budget about twenty minutes per task and keep a buffer.

Ensure your code compiles. A partial-correct submission that compiles beats a perfect one that does not. The Prep Agent from InterviewFox can turn this into a daily plan, with reminders if you want the structure handed to you.

Days 6-7 Edge cases and a buffer

Drill empty, tiny, and huge inputs. Add the array overflow guard, and keep a commented-out backup of a working slice. Re-read the backtracking duplicate rule and the carry-loop guard once more. They should not surprise you mid-test.

What Happens After You Submit the OA

The live answer review is the part candidates underestimate. A Citi interviewer walks through your Codility answers one by one after submission, as one Glassdoor interview review describes. The code you wrote is not the last anyone sees of it.

If your score gets voided, the aftermath is quiet and slow. The post-submission proctoring review cites the activity log, and the notification arrives about one to two days later.

Treat a voided score as a reset rather than a negotiable result, and follow the recruiter’s instructions for any next attempt.

Citi's Codility Mix Varies Algorithmic and Framework

The first-hand Citi database confirms the recurring algorithmic set. It is Permutations II, large-number addition, and in-place dedup. Individual reports also describe a framework-heavy sitting. It pairs Array Sign, Spring Boot, and JUnit, so Citi's screen is not one fixed fingerprint.

Prepare for both, and you will not be blindsided by whichever variant lands. This single observation reshaped my whole prep. It is why the plan above covers the algorithmic set first, with the framework variant as a parallel track.

FAQ

Q: What is the Citi Codility test?

A: A one-hour Codility screen with three tasks. The confirmed recurring shape is algorithmic: Permutations II, large-number string addition, in-place dedup. A framework-heavy variant (Array Sign, Spring Boot, JUnit) also appears in single sittings.

Q: Does Citi monitor your screen or use a webcam on the Codility test?

A: Check the invitation and consent screen for the webcam setting. The review described here is an activity-log check after submission. That is where AI-tool detection operates.

Q: Can a voided score be appealed or re-taken?

A: Treat a voided score as a reset, not a quick reversal, and follow the recruiter’s instructions for any next attempt.

Q: How does Citi's OA compare to other banks?

A: Citi's confirmed set is unusually algorithmic for a first-round screen. A framework-heavy variant also appears. Other banks often lean more purely algorithmic or more purely behavioral. Do not assume one bank's prep transfers directly.