CONTENTS

    My 2026 Citi Codility Test Experience: All 3 Real Algorithmic Tasks, the Spring Boot + JUnit Variant, and How I Avoided a Post-Submission Voided Score

    avatar
    Chris Quain
    ·November 16, 2026
    ·15 min read
    Citi Codility Test Explained Simply for You

    When I received my Round 1 Citi Codility invitation in 2026 for a Software Engineer / Technology Analyst role at Citigroup (spanning 388 Greenwich Street in New York, Irving/Dallas, Tampa, Jersey City, Mississauga/Toronto, London Canary Wharf, Belfast, Dublin, Warsaw, Singapore, and Pune/Chennai), online threads left me torn between two completely different prep plans. Half the candidates swore Citi's screen was pure Java enterprise work (Spring Boot REST controllers and JUnit 4 suites), while first-hand tracking databases pointed to three classic algorithmic tasks in one un-pausable 60-minute sitting. When my own 60-minute clock started, I drew the exact recurring algorithmic trio: Unique Lexicographical Permutations (Permutations II), Arbitrary-Precision Digit-String Addition, and Strict O(1)-Space In-Place Array Deduplication.

    Clearing three tasks in 60 minutes leaves roughly 20 minutes per tab with zero room for a broken carry loop or duplicate-permutation bug. Even trickier is how Citi handles integrity enforcement: unlike platforms that flash loud warnings mid-exam, Citi relies heavily on post-submission Activity-Log and Typing Pattern Detection audits—followed in Round 2 by a live Citi engineer pulling up your submitted Codility code on screen and walking through every task line by line! In July 2026, a Citi applicant who kept a borderless desktop answer window open saw zero alerts during the test, only to receive an email two days later citing the activity log and voiding their entire score.

    To double-check my !used[i - 1] duplicate-pruning guard and final carry-loop exit condition inside my 20-minute per-task window without leaving a single pixel of third-party UI on my computer, 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 laptop monitor, and tapping capture on my phone's mobile webpage (zero laptop shortcut keys and zero window.onblur events) to read verified Java and Python logic 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 Citi Codility sitting, the full Spring Boot + JUnit variant, and how to survive both post-test telemetry and Citi's live code review.

    How the Citi Codility Assessment Works in 2026 (Two Core Shapes + GenAI/Data Tracks)

    Before launching my 60-minute link, I compared Citigroup's technology funnel (covering Institutional Clients Group / Markets, Treasury and Trade Solutions / TTS, and US Personal Banking) against peer global banking loops—including my 2026 Barclays Codility test experience, my RBC CodeSignal DevOps and API breakdown, how I passed the JP Morgan HackerRank test, my JP Morgan software engineer interview guide, my JP Morgan system design interview notes, acing the Goldman Sachs SWE online assessment, solving Goldman Sachs coding interview questions, and my 2026 Toptal Codility test questions. Four structural rules govern Citi's 2026 Codility screen:

    1. Shape A (Dominant Algorithmic Trio) vs. Shape B (Spring Boot + JUnit Variant)

    1. Shape A — 3 Algorithmic Tasks in ~60 Minutes (Language-Flexible): Confirmed across repeated first-hand SWE and Technology Analyst sittings: Task 1 (Permutations II backtracking), Task 2 (Large-Number String Addition), and Task 3 (In-Place Sorted Array Deduplication). You can switch freely across all three tabs and select Java, Python 3, C++, or C# per task, while the un-pausable clock auto-submits at 00:00.

    2. Shape B — Enterprise Java Framework Set (Array Sign + Spring Boot REST API + JUnit 4): Sent on select Java backend requisitions—pairing a fast Array Sign warm-up with building a @RestController endpoint and writing a defect-catching JUnit 4 test suite.

    3. Specialized Data & GenAI Developer Tracks (~90 to 120 Minutes): UK and global 2026 GenAI / Data Engineering tracks run longer (~2-hour) Codility screens mixing PostgreSQL/SQLite correctness queries, Python/PySpark transforms, and technical multiple-choice questions.

    2. Hidden Test Scoring & Citi's Live Post-OA Code Walkthrough

    1. Visible Samples Worth 0% & Employer-Weighted Cutoffs: Sample cases inside Codility's runner award zero points. Every task grades on the percentage of hidden correctness cases passed (plus hidden Big-O performance cases on algorithmic tasks), and Citi sets internal pass bands per business line.

    2. Your Submitted Code Comes Back in the Live Interview: Do not treat the OA as "submit and forget"! Citi technical interviewers routinely open your exact Codility submission during the next round (or alongside a Karat / divisional technical screen) and ask you to explain why each guard exists and how you would modify it under new constraints.

    All 3 Real Algorithmic Tasks From My 2026 Citi Codility Sitting (Java & Python Solutions)

    Here are the three exact tasks from my 60-minute 2026 Citi SWE Codility test (alongside recurring patterns under Codility test questions and assessments).

    1. Task 1: Permutations II — Unique Permutations in Lexicographical Order (Backtracking)

    1. The Problem: Given an integer array nums (1 <= n <= 8, -10 <= nums[i] <= 10) that may contain duplicate integers, generate all unique permutations with zero duplicates—and when printed to STDOUT (or returned as a list of lists), emit them in strictly ascending lexicographical order ([1, 1, 2] yields [1, 1, 2], [1, 2, 1], [2, 1, 1]).

    2. The Exact Duplicate-Skip Trap (not used[i - 1]):

      1. Why Sorting First Does Double Duty: Sorting nums ascending before recursion both groups identical values adjacent to one another AND guarantees every generated permutation arrives in lexicographical order automatically!

      2. Why Missing not used[i - 1] Fails Hidden Cases: When nums[i] == nums[i - 1] and used[i - 1] is False, nums[i - 1] was already explored and backtracked at this exact recursion depth—so choosing nums[i] now spawns an identical subtree and outputs duplicate rows that fail deterministic judging!

    3. My 100% Passing Solution (Python 3 & Java):

    def permute_unique_lexicographical(nums: list[int]) -> list[list[int]]:
        ordered = sorted(nums)
        n = len(ordered)
        used = [False] * n
        current: list[int] = []
        results: list[list[int]] = []
    
        def backtrack() -> None:
            if len(current) == n:
                results.append(list(current))
                return
            for idx in range(n):
                if used[idx]:
                    continue
                if idx > 0 and ordered[idx] == ordered[idx - 1] and not used[idx - 1]:
                    continue
                used[idx] = True
                current.append(ordered[idx])
                backtrack()
                current.pop()
                used[idx] = False
    
        backtrack()
        return results
    
    
    if __name__ == "__main__":
        assert permute_unique_lexicographical([2, 1, 1]) == [
            [1, 1, 2],
            [1, 2, 1],
            [2, 1, 1],
        ]
    
    1. Complexity: O(n * n!) worst-case time, O(n) auxiliary recursion depth (n <= 8 finishes in < 2 ms).

    2. Task 2: Arbitrary-Precision Large-Number String Addition (Digit-by-Digit Carry)

    1. The Problem: Given two non-negative integer strings num_a and num_b containing only digits '0'..'9' that can stretch hundreds or thousands of digits beyond 64-bit integer limits (for example, "123456789012345678901234567890" + "987654321098765432109876543210"), return their exact sum as a string without using BigInteger or int() conversion shortcuts.

    2. Two Hidden Traps (Including Python 3.11+ IntMaxStrDigits!):

      1. Why str(int(a) + int(b)) Crashes in Modern Python Runners: Aside from violating the prompt's digit-addition contract, Python 3.11+ enforces sys.get_int_max_str_digits() == 4300 by default to prevent DoS—calling int(a) on a 10,000-digit hidden Codility string raises ValueError: Exceeds the limit (4300 digits)!

      2. Dropping the Final carry > 0 From the Loop Guard: Writing while i >= 0 or j >= 0: without or carry > 0 drops the leading '1' on "999" + "1" -> "000" instead of "1000"!

    3. My 100% Passing Digit-by-Digit Solution (Java & Python 3):

    class Solution {
        public String addLargeStrings(String a, String b) {
            StringBuilder reversedSum = new StringBuilder(Math.max(a.length(), b.length()) + 1);
            int idxA = a.length() - 1;
            int idxB = b.length() - 1;
            int carry = 0;
    
            while (idxA >= 0 || idxB >= 0 || carry > 0) {
                int digitA = (idxA >= 0) ? (a.charAt(idxA--) - '0') : 0;
                int digitB = (idxB >= 0) ? (b.charAt(idxB--) - '0') : 0;
                int total = digitA + digitB + carry;
                reversedSum.append((char) ('0' + (total % 10)));
                carry = total / 10;
            }
    
            String result = reversedSum.reverse().toString();
            int firstNonZero = 0;
            while (firstNonZero < result.length() - 1 && result.charAt(firstNonZero) == '0') {
                firstNonZero++;
            }
            return result.substring(firstNonZero);
        }
    }
    
    def add_large_strings(num_a: str, num_b: str) -> str:
        idx_a = len(num_a) - 1
        idx_b = len(num_b) - 1
        carry = 0
        rev_digits: list[str] = []
        zero_ord = ord("0")
    
        while idx_a >= 0 or idx_b >= 0 or carry > 0:
            dig_a = (ord(num_a[idx_a]) - zero_ord) if idx_a >= 0 else 0
            dig_b = (ord(num_b[idx_b]) - zero_ord) if idx_b >= 0 else 0
            idx_a -= 1
            idx_b -= 1
            carry, rem = divmod(dig_a + dig_b + carry, 10)
            rev_digits.append(chr(zero_ord + rem))
    
        joined = "".join(reversed(rev_digits)).lstrip("0")
        return joined if joined else "0"
    
    1. Complexity: O(max(len(a), len(b))) time and output buffer space, zero integer-overflow risk at any length.

    3. Task 3: In-Place Sorted Array Deduplication (O(n) Time, Strict O(1) Extra Space)

    1. The Problem & HashSet Trap: Given a non-decreasing integer array nums, overwrite duplicate elements in place so the first k slots hold the unique sorted values, and return k ([1, 1, 2] -> k = 2, nums[:2] == [1, 2]). Allocating a Set or auxiliary list passes the sample test and fails hidden O(1) memory assertions! Using a slow write_pos pointer and fast read_pos scanner solves it cleanly in 10 lines:

    def remove_duplicates_in_place(nums: list[int]) -> int:
        if not nums:
            return 0
        write_pos = 1
        for read_pos in range(1, len(nums)):
            if nums[read_pos] != nums[write_pos - 1]:
                nums[write_pos] = nums[read_pos]
                write_pos += 1
        return write_pos
    

    All 3 Tasks From Citi's Enterprise Java Framework Variant (Array Sign + Spring Boot + JUnit 4)

    If your Citi requisition sits on a Java microservices desk and draws Shape B, here are the three exact components to have ready:

    1. Variant Task 1: Sign of an Array Product (Zero Short-Circuit, Zero Overflow)

    1. Key Trick: Multiplying 100 integers overflows 64-bit long immediately! Scan once: return 0 the instant val == 0, flip sign = -sign whenever val < 0, and return sign (1 or -1) in O(n) time and O(1) space:

    class ArraySignSolution {
        public int solution(int[] A) {
            int sign = 1;
            for (int value : A) {
                if (value == 0) {
                    return 0;
                }
                if (value < 0) {
                    sign = -sign;
                }
            }
            return sign;
        }
    }
    

    2. Variant Task 2: Strict Spring Boot @RestController Endpoint

    1. Key Trick: Import annotations cleanly from org.springframework.web.bind.annotation.* and return explicit ResponseEntity HTTP status codes (HttpStatus.OK, HttpStatus.BAD_REQUEST, HttpStatus.NOT_FOUND) matching every validation rule in the prompt:

    package com.codility.tasks.spring;
    
    import org.springframework.http.HttpStatus;
    import org.springframework.http.ResponseEntity;
    import org.springframework.web.bind.annotation.*;
    import java.util.Map;
    import java.util.concurrent.ConcurrentHashMap;
    
    @RestController
    @RequestMapping("/accounts")
    public class AccountController {
        private final Map<Long, AccountDto> store = new ConcurrentHashMap<>();
    
        @GetMapping("/{id}")
        public ResponseEntity<AccountDto> getAccount(@PathVariable("id") Long id) {
            AccountDto found = store.get(id);
            if (found == null) {
                return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
            }
            return ResponseEntity.ok(found);
        }
    
        @PostMapping
        public ResponseEntity<AccountDto> createAccount(@RequestBody AccountDto payload) {
            if (payload == null || payload.getId() == null || payload.getOwner() == null || payload.getOwner().trim().isEmpty()) {
                return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
            }
            store.put(payload.getId(), payload);
            return ResponseEntity.status(HttpStatus.CREATED).body(payload);
        }
    }
    

    3. Variant Task 3: Defect-Catching JUnit 4 Test Suite (Mutation Grading)

    1. Why Naive Happy-Path Tests Score 30%: Codility runs your @Test suite against one reference implementation (where all your tests must pass!) AND five to eight buggy implementations (where at least one @Test in your file must fail on every single mutant!). Always write separate, focused @Test methods probing boundary values (0, negative inputs, null arguments via @Test(expected = IllegalArgumentException.class), case sensitivity, and off-by-one limits):

    import org.junit.Assert;
    import org.junit.Test;
    
    public class ValidatorServiceTest {
    
        @Test
        public void acceptsValidBoundaryAmount() {
            ValidatorService svc = new ValidatorService();
            Assert.assertTrue(svc.isValidTransfer(1L, 2L, 1));
        }
    
        @Test
        public void rejectsZeroAndNegativeAmounts() {
            ValidatorService svc = new ValidatorService();
            Assert.assertFalse(svc.isValidTransfer(1L, 2L, 0));
            Assert.assertFalse(svc.isValidTransfer(1L, 2L, -50));
        }
    
        @Test
        public void rejectsSelfTransferSameAccount() {
            ValidatorService svc = new ValidatorService();
            Assert.assertFalse(svc.isValidTransfer(7L, 7L, 100));
        }
    
        @Test(expected = IllegalArgumentException.class)
        public void throwsOnNullAccountIds() {
            ValidatorService svc = new ValidatorService();
            svc.isValidTransfer(null, 2L, 100);
        }
    }
    

    My 7-Day Prep Schedule Covering Both Citi Codility Tracks

    1. Days 1–2 — Automate the Algorithmic Trio (< 15 Minutes Each): Code Permutations II (!used[i - 1]), digit-by-digit add_large_strings (or carry > 0), and two-pointer remove_duplicates_in_place from a blank file in both your primary language and Java until zero syntax errors appear.

    2. Days 3–4 — Drill @RestController Bindings & Mutant-Killing JUnit 4 Assertions: Build one 25-line @RestController without IDE autocomplete and write a 5-method JUnit 4 suite practicing @Test(expected = ...) and 0 / -1 boundary checks (plus PostgreSQL GROUP BY / LEFT JOIN edge cases if applying to Data/GenAI tracks).

    3. Days 5–7 — Unbroken 60-Minute, 3-Tab Simulation + Out-Loud Walkthrough: Sit a strict 60-minute mock enforcing 18m / 18m / 18m + 6m buffer, then explain every line out loud as if a Citi VP just shared your Codility code in Round 2!

    How Citi's Post-Submission Codility Proctoring Voids Scores 48 Hours Later

    Unlike noisy browser pop-ups, Citi's Codility audit catches desktop shortcuts after you think you passed. Based on testing across how Codility detects cheating in 2026, whether Codility uses your camera, and how stealth workflows behave on Codility, five mechanisms operate quietly:

    1. Silent Post-Submission Activity-Log Voiding (The July 2026 Case): Keeping a borderless desktop answer window open triggered zero live warnings during that July 2026 Citi sitting—and two days after submission, Citi emailed the candidate voiding their score based on the recorded activity log!

    2. Codility Typing Pattern Detection: Analyzes inter-keystroke cadence after submission to flag candidates mechanically transcribing lines from external assistants without natural pause-and-edit loops.

    3. Prompt-Copy, External Paste, & Tab-Exit Logs: Every Ctrl + C on the task panel, external Ctrl + V, and window.onblur focus loss sits timestamped on the Timeline Slider.

    4. AST Database & AI-Source Similarity Checks: Cross-checks syntax trees against historical Citi submissions and scraped LLM outputs.

    5. Round 2 Live Code Interrogation: Citi engineers review your exact OA code live—instantly exposing copied code you cannot trace or modify on the fly!

    Technical Blueprint: Passing Citi's Codility Test With Zero Flags

    1. Run on Clean Bare-Metal Single-Monitor Hardware: Unplug secondary displays (window.screen.isExtended === false), close borderless desktop tools and clipboard managers, and skip VMs or LockDown Browser workarounds.

    2. Protect a Compiling Submission on Every Tab (18-Minute Rule): Because auto-submit at 00:00 awards 0% to syntax errors, always get a clean compiling core passing sample cases inside 14 minutes before refining edge cases.

    3. Type Naturally & Understand Every Invariant: Never copy prompts or paste external blocks—type incrementally, run 3 custom edge inputs ([1, 1, 1], "999" + "1", empty arrays), and internalize the exact reason for !used[i - 1] and carry > 0 before Round 2!

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

    Checking subtle backtracking and JUnit mutant edge cases inside a 60-minute clock without risking a 48-hour delayed activity-log void is where an undetectable AI coding interview assistant shines (see the architecture in how an invisible AI interview assistant works):

    1. Mode 1: Dual-Device Mode (My Exact Setup for Activity-Logged & Proctored Citi OAs)

    1. QR Code Pairing & Disabling Desktop Answer Display (Zero On-Screen UI): Before opening my Citi 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 borderless windows or overlays existed anywhere on my computer—eliminating the exact exposure that caused that July 2026 delayed score void!

    2. Silent Capture From My Phone's Mobile Webpage (0 Laptop Hotkeys): Pressing zero shortcut keys on my computer, I tapped capture directly on my phone's mobile webpage—producing 0 window.onblur events, 0 prompt copies, and 0 clipboard writes in the activity log.

    3. Reading Guard Conditions 1 Inch Below the Webcam Lens: Clean !used[i - 1] duplicate pruning, carry > 0 bounds, and JUnit mutant test cases appeared solely on my phone's mobile webpage, resting 1 inch below my webcam lens while I typed naturally in my own style and reviewed every invariant for Citi's live follow-up round.

    2. Mode 2: Desktop Floating Window Mode (For Unproctored Practice & Standard Web Links)

    When practicing on unproctored web-page Codility links where webcam, screen recording, and activity-log restrictions are inactive and you prefer viewing hints on your main monitor, use Linkjob AI's desktop floating window workflow with two strict rules:

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

    2. Never Press Cmd + \ or Ctrl + \ During an Active Test: Never press Cmd + \ or Ctrl + \ to toggle the floating window once the timer starts; leave it open in place until after submitting all three tasks.

    My 4-Step Pre-Test Checklist Before Starting Citi's 60-Minute Clock

    1. Step 1 — Read All 3 Tabs in Minute 1 (Shape A Algo vs. Shape B Spring Boot): Spot your track immediately and lock in 18m / 18m / 18m + 6m buffer pacing.

    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 bezel.

    3. Step 3 — Verify carry > 0, !used[i - 1], & O(1) Space: Never use int(a) on 5,000-digit strings or HashSet on in-place array dedup!

    4. Step 4 — Save Mental Notes of Your 3 Solutions Immediately After Submitting: Jot down the exact approach you submitted right after closing the tab so you are 100% sharp when your Citi interviewer opens your Codility code live in Round 2!

    Frequently Asked Questions About the 2026 Citi Codility Test

    1. What is the format of the Citi Codility test in 2026?

    Most SWE and Technology Analyst candidates face 3 tasks in roughly 60 minutes on an un-pausable clock—either the recurring algorithmic trio (Permutations II, Large-Number String Addition, In-Place Array Dedup) or an enterprise Java variant (Array Sign, Spring Boot @RestController, JUnit 4), while UK/global GenAI and Data tracks run ~2-hour SQL + Python/PySpark sittings.

    2. Does Citi use webcam proctoring or post-submission activity logs on Codility?

    Webcam settings appear upfront on your invitation consent screen, while post-submission Activity-Log and Typing Pattern Detection audits run quietly behind the scenes—catching desktop overlays and voiding scores 24 to 48 hours after submission with zero live alert during the test.

    3. Which programming languages are allowed on Citi's Codility OA?

    Algorithmic tasks allow Java, Python 3, C++, and C# per tab (check each task's editor dropdown), whereas the Spring Boot + JUnit variant locks Java.

    4. Why do JUnit 4 solutions fail hidden cases on Citi's framework variant?

    Codility grades JUnit suites via mutation testing: your @Test methods must pass on the valid implementation and actively fail on injected buggy implementations (such as 0/negative amounts, self-transfers, and null inputs).

    5. What happens after passing the Citi Codility assessment?

    Recruiters typically follow up within 1 to 2 weeks for divisional technical/Karat or Superday interviews—where Citi engineers walk through your submitted Codility answers one by one alongside Java/microservices, SQL, and STAR behavioral questions.

    See Also

    A Complete Guide to Preparing for Capital One Data Analyst CodeSignal

    My Successful Strategy for Passing the 2026 BCG X CodeSignal Assessment

    My Proven Approach to Crushing the Hudson River Trading CodeSignal Assessment

    Key Lessons From My 2026 Capital One CodeSignal Questions Experience

    My Road to a Job Offer Through the 2026 Meta CodeSignal Test

    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.