
When my SIG CodeSignal assessment invitation from Susquehanna International Group landed in my inbox within hours of applying, I almost made the classic mistake of treating an automated invite like a passed resume screen. At SIG—one of the world's largest quantitative options market makers, headquartered in Bala Cynwyd outside Philadelphia with major engineering and trading hubs in New York, Chicago, Dublin, London, and Sydney—CodeSignal acts as a pre-resume gatekeeper. Because almost every Software Engineer (SWE), Technology Associate, and Quantitative Strategy Developer applicant receives the 70-minute automated CodeSignal link first, recruiters only inspect your resume after your certified 200–600 score clears an aggressive cutoff! Every summer and autumn cycle, student forums fill up with candidates asking whether 515/600 (3 of 4 tasks) is enough—and watching their applications go silent because hundreds of competing applicants posted 570 to 600 / 600.
Even trickier, SIG uses different assessments across SWE, Quant Research, and Quant Trading, and then brings CodeSignal back for a live 30-to-90-minute collaborative CodeSignal Interview (testing headline ticker parsing, itinerary reconstruction, and raw C++ std::vector memory ownership) right after a recruiter phone call that can drop four no-calculator mental probability questions on you!
Because SIG's initial CodeSignal runs under full camera, microphone, government ID, and Entire Screen recording, opening browser tabs or desktop overlay apps will void your certification 24 to 48 hours later even if you score 600/600. During my sitting, 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 appeared on my laptop monitor, and checking my Slot 4 hash-map delta updates 1 inch below my webcam lens (saving Desktop Floating Window Mode strictly for unproctored solo warmups). Below is my complete 2026 breakdown of SIG's assessment tracks, four representative Python and C++20 problems with full solutions, and what follows on the road to Bala Cynwyd or Dublin Superday.

Before opening my link, I benchmarked SIG's automated options-firm funnel against peer market-making screens like my Chicago Trading Company options-firm OA guide and my Virtu Financial market-maker OA breakdown. First, make sure you know which of SIG's three 2026 assessments matches your requisition:
Track 1 — Software Engineer, Technology Associate, & Quant Strategy Developer (70 Minutes, 4 Problems, 200–600 Scale):
This is SIG's flagship developer screen on CodeSignal's General Coding Assessment (GCA) framework (70 un-pausable minutes, 4 coding problems unlocked at 00:00, language choice open across Python 3, C++20, Java, and C#—though keep in mind that listing C++ on your resume guarantees deep pointer/buffer ownership grilling in Round 3!). Slots 1 and 2 reward fast reading comprehension, Slot 3 tests multi-step 2D matrix rotation/gravity simulation, and Slot 4 requires incremental hash-map stream counting (O(N) updates rather than O(N^2) recomputation).
Track 2 — Quantitative Research Intern & Hybrid Quant Variants (70 Minutes, 4 to 5 Problems):
Recent 2026 Quantitative Research Intern sittings report either a 5-problem, 70-minute CodeSignal sprint (tighter per-problem clock mixing Python data manipulation, combinatorics, and stream tracking) or pairing a coding screen with SIG's probability battery.
Track 3 — Quantitative Trader & Systematic Research (60-Minute, 17-Question Problem Solving Assessment):
Do not grind binary trees if your invite is for Quantitative Trading! SIG transitioned its primary trader/researcher screen from the legacy 20-minute quiz to a 60-minute, 17-question Problem Solving Assessment (plus occasional post-phone-screen speed-math CodeSignal links) testing conditional probability, Bayes' theorem, expected-value dice/coin stopping games, Markov chains (frog on a grid, bold betting), and a 4x4 deductive grid puzzle with randomized numbers per candidate!
Why 560–600 / 600 Is the Real Target on SIG's Developer GCA:
Because SIG issues developer CodeSignal invites automatically upon application, scoring 500–520 (3/4 tasks) lands in the middle of the applicant pack. Notice also that scoring 600/600 guarantees resume review, not an automatic interview—if your 600/600 gets certified cleanly, a human engineering recruiter then screens your CV projects and university/systems fit within 1 to 3 weeks! Solve Q1 -> Q2 -> Q4 -> Q3 so you bank Q4's high-leverage hash-map optimization before touching Q3's matrix indexing.
Below are four 100% original, runnable solutions covering SIG's 70-minute CodeSignal GCA (Slots 1–4) plus the exact live CodeSignal Interview C++ std::vector container question that eliminates unprepared C++ resume holders in Round 3!
Fast String Tokenization): Extracting Valid Ticker Symbols & Reconstructing Scrambled ItinerariesThe Pattern: Given a financial news headline string headline and a set of listed exchange symbols listed_tickers, extract all unique valid ticker mentions in order of first appearance, where a valid mention is either (a) an uppercase 1-to-5-letter ASCII word enclosed by whitespace or punctuation ("AAPL", "NVDA.", "(MSFT)") that exists in listed_tickers, or (b) preceded by an explicit prefix tag "TICK:" ("TICK:SPY"). Never use slow backtracking regexes when a clean single-pass character scanner handles punctuation boundaries in O(L) time!
def extract_valid_tickers(headline: str, listed_tickers: set[str]) -> list[str]:
"""
Single-pass O(L) scanner without regex edge-case bugs.
Preserves first-seen order and deduplicates repeated mentions.
"""
found: list[str] = []
seen: set[str] = set()
tokens = headline.split()
punct = ".,;:!?()[]{}\"'<>"
for raw_tok in tokens:
cleaned = raw_tok.strip(punct)
if not cleaned:
continue
if cleaned.startswith("TICK:"):
candidate = cleaned[5:]
else:
candidate = cleaned
if 1 <= len(candidate) <= 5 and candidate.isalpha() and candidate.isupper():
if candidate in listed_tickers and candidate not in seen:
seen.add(candidate)
found.append(candidate)
return found
Scrambled Tickets Directed Chain Reconstruction)The Confirmed SIG Problem Pattern: You receive N unordered one-way routing hops [(src, dst), ...] representing a single non-branching itinerary (or order-routing chain) with no cycles and no duplicate cities. Reconstruct the ordered (N + 1)-node route from true origin to final destination in O(N) time!
Why Candidates Accidentally Write O(N^2): Scanning the whole list to find which city has 0 incoming edges and scanning again at each hop takes O(N^2) and times out at N = 100,000. Building next_hop = dict(tickets) and destinations = set(next_hop.values()) locates the unique start node (src not in destinations) in O(N) and walks all N hops in O(1) per step:
def reconstruct_scrambled_route(tickets: list[tuple[str, str]]) -> list[str]:
"""
Reconstructs a unique N-hop non-branching chain in O(N) time and O(N) space.
"""
if not tickets:
return []
next_hop: dict[str, str] = {}
destinations: set[str] = set()
for src, dst in tickets:
next_hop[src] = dst
destinations.add(dst)
origin = ""
for src in next_hop:
if src not in destinations:
origin = src
break
if not origin:
return []
route: list[str] = [origin]
curr = origin
while curr in next_hop:
curr = next_hop[curr]
route.append(curr)
return route
2D Matrix Simulation): Obstacle-Blocked Gravity + 90-Degree Clockwise Box RotationThe Classic SIG / CodeSignal Q3 Time-Trap: Given an R x C character grid representing a chamber containing movable items '#', fixed walls '*', and empty space '.', rotate the chamber 90 degrees clockwise, after which every movable '#' falls straight downward until resting on the bottom floor, a fixed wall '*', or another settled '#'!
The Zero-Bug Trick (Apply Rightward Gravity BEFORE Rotating!):
Simulating downward gravity after rotating means scanning columns vertically across swapped dimensions (C x R). Instead, notice that "downward after a 90-degree clockwise turn" is identical to "sliding rightward inside each row BEFORE rotating"! Sliding '#' toward a write_col pointer inside each row takes 8 lines, and [list(col) for col in zip(*grid[::-1])] rotates 90 degrees clockwise cleanly in O(R * C) time:
def rotate_chamber_with_gravity(chamber: list[list[str]]) -> list[list[str]]:
"""
Slot 3 2D Grid Pattern:
Step 1: Slide movable '#' rightward within each row up to walls '*'.
Step 2: Rotate the settled R x C grid 90 degrees clockwise into C x R.
Time Complexity: O(R * C) | Space Complexity: O(R * C).
"""
if not chamber or not chamber[0]:
return []
rows = len(chamber)
cols = len(chamber[0])
settled = [row[:] for row in chamber]
for r in range(rows):
write_c = cols - 1
for read_c in range(cols - 1, -1, -1):
cell = settled[r][read_c]
if cell == "*":
write_c = read_c - 1
elif cell == "#":
if read_c != write_c:
settled[r][write_c] = "#"
settled[r][read_c] = "."
write_c -= 1
# zip(*settled[::-1]) performs an exact 90-degree clockwise matrix turn
return [list(col) for col in zip(*settled[::-1])]
Confirmed September 2026 SIG Pattern — "Count Kept Over a Stream"): Dynamic Two-Array Target-Sum Query EngineThe Pattern: You are given two integer arrays primary (len <= 2,000) and secondary (len <= 50,000), plus up to 50,000 stream operations of two types:
[0, idx, delta]: Mutate secondary[idx] += delta in place.
[1, target_sum]: Return the total number of index pairs (i, j) such that primary[i] + secondary[j] == target_sum!
Why O(|primary| * |secondary|) Per Query Fails & Which Array Gets the Hash Map:
Look closely at the asymmetric length bounds! secondary has 50,000 elements and mutates 1 index at a time, whereas primary is smaller (<= 2,000) and never mutates (or mutates rarely). Maintain a live frequency dictionary sec_freq over secondary: each [0, idx, delta] update decrements sec_freq[old_val] and increments sec_freq[new_val] in O(1) time, and each [1, target_sum] query loops over primary_freq (<= 2,000 distinct keys!) summing p_cnt * sec_freq[target_sum - p_val]—finishing all 50,000 queries in < 0.25 seconds:
from collections import Counter
def process_stream_pair_queries(
primary: list[int],
secondary: list[int],
operations: list[list[int]],
) -> list[int]:
"""
Slot 4 Stream Maintenance Pattern:
Point updates [0, idx, delta] on `secondary` run in O(1) time.
Pair-sum queries [1, target] iterate over compressed `primary_freq` in O(U_p).
"""
primary_freq = Counter(primary)
sec_vals = secondary[:]
sec_freq = Counter(sec_vals)
answers: list[int] = []
for op in operations:
if op[0] == 0:
idx, delta = op[1], op[2]
old_v = sec_vals[idx]
new_v = old_v + delta
sec_vals[idx] = new_v
sec_freq[old_v] -= 1
if sec_freq[old_v] == 0:
del sec_freq[old_v]
sec_freq[new_v] += 1
else:
target = op[1]
matches = 0
for p_val, p_cnt in primary_freq.items():
matches += p_cnt * sec_freq.get(target - p_val, 0)
answers.append(matches)
return answers
Real Interview Questions. Real Candidates. Continuously Updated
Our interview questions come from real job interviews taken by candidates using Linkjob AI. Based on actual interview experiences and continuously updated with new questions
CodeSignal Interview C++20 Classic: Implementing SimpleVector<T> (push_back & Buffer Ownership)Why Every C++ Candidate at SIG Must Practice This Before Round 3:
Multiple 2025 and 2026 SIG Software Engineer and Trading Systems candidates report being asked on a live CodeSignal pad to implement a minimal std::vector<T> with push_back, 2x geometric reallocation, and Rule of Five move ownership—explaining who owns the heap buffer at every line and why std::move_if_noexcept preserves strong exception safety during reallocation!
#include <cstddef>
#include <memory>
#include <utility>
template <typename T>
class SimpleVector {
public:
SimpleVector() noexcept : data_(nullptr), size_(0U), cap_(0U) {}
~SimpleVector() {
clear_elements();
::operator delete(data_);
}
SimpleVector(const SimpleVector&) = delete;
SimpleVector& operator=(const SimpleVector&) = delete;
SimpleVector(SimpleVector&& other) noexcept
: data_(other.data_), size_(other.size_), cap_(other.cap_) {
other.data_ = nullptr;
other.size_ = 0U;
other.cap_ = 0U;
}
SimpleVector& operator=(SimpleVector&& other) noexcept {
if (this != &other) {
clear_elements();
::operator delete(data_);
data_ = other.data_;
size_ = other.size_;
cap_ = other.cap_;
other.data_ = nullptr;
other.size_ = 0U;
other.cap_ = 0U;
}
return *this;
}
void push_back(const T& val) {
ensure_capacity_for_one();
std::construct_at(data_ + size_, val);
++size_;
}
void push_back(T&& val) {
ensure_capacity_for_one();
std::construct_at(data_ + size_, std::move(val));
++size_;
}
std::size_t size() const noexcept { return size_; }
std::size_t capacity() const noexcept { return cap_; }
T& operator[](std::size_t idx) noexcept { return data_[idx]; }
const T& operator[](std::size_t idx) const noexcept { return data_[idx]; }
private:
T* data_;
std::size_t size_;
std::size_t cap_;
void clear_elements() noexcept {
for (std::size_t i = 0U; i < size_; ++i) {
std::destroy_at(data_ + i);
}
size_ = 0U;
}
void ensure_capacity_for_one() {
if (size_ < cap_) {
return;
}
std::size_t new_cap = (cap_ == 0U) ? 1U : (cap_ * 2U);
T* new_buf = static_cast<T*>(::operator new(new_cap * sizeof(T)));
std::size_t built = 0U;
try {
for (; built < size_; ++built) {
std::construct_at(
new_buf + built,
std::move_if_noexcept(data_[built])
);
}
} catch (...) {
for (std::size_t j = 0U; j < built; ++j) {
std::destroy_at(new_buf + j);
}
::operator delete(new_buf);
throw;
}
std::size_t old_size = size_;
clear_elements();
::operator delete(data_);
data_ = new_buf;
size_ = old_size;
cap_ = new_cap;
}
};
600/600 Scores (And My Stealth Setup)Nothing stings worse than scoring 600/600 in 38 minutes—only to read CodeSignal's dreaded email 48 hours later stating your score could not be certified! Reviewing the exact triggers I broke down in how CodeSignal detects cheating in 2026, SIG's proctored GCA checks four strict layers:
Mandatory Entire Screen Recording + Secondary Monitor Check (isExtended):
CodeSignal rejects single-tab sharing—your entire desktop records for all 70 minutes, and connected HDMI/Sidecar screens must be unplugged prior to launch.
Webcam Eye-Line + Audio Continuity:
Human certification reviewers inspect timestamps flagged for off-screen gaze (30+ degrees sideways), muffled voices, or leaving camera view without closing the session.
Paste Attribution (insertFromPaste) & Suspicion Score:
Pasting external code blocks or dumping 50 lines linearly without natural edits spikes CodeSignal's automated Suspicion Score even before human review!
Because SIG uses CodeSignal twice—first as a proctored 70-minute OA and later as a live CodeSignal Interview screen—I match an undetectable AI coding interview assistant to the exact environment:
Mode 1: Dual-Device Mode (My Mandatory Setup for Proctored SIG CodeSignal OAs & Live Interviews):
First, 15 minutes before starting, I unplug external monitors (window.screen.isExtended === false), launch the Linkjob AI desktop app on my laptop, scan the dashboard QR code with my phone camera to open Linkjob AI on my phone's mobile webpage, and turn OFF the desktop answer-display toggle. Zero UI, zero overlays, and zero floating panels ever render on my laptop display—so Entire Screen recordings and live screen shares (as well as strict browsers like LockDown Browser) stay 100% clean.
Second, as I jump Q1 -> Q2 -> Q4 -> Q3, I tap capture silently on my phone's mobile webpage—triggering 0 laptop shortcut keys, 0 prompt Ctrl + C copies, and 0 window.onblur focus drops.
Third, I prop my phone 1 inch directly below my webcam lens. My gaze stays aligned right along the camera axis while I hand-type modular Python or C++20 code and test custom edge cases every 8–10 lines!
Mode 2: Desktop Floating Window Mode (Strictly for Unproctored Solo Practice):
When rehearsing timed GCA mock sets or OOP class designs solo on unproctored web practice portals, I finish 100% of my language and prompt settings before opening the browser tab (never click Settings mid-session so browser focus stays unbroken) and never press Cmd + \ or Ctrl + \ during an active timer.
Clearing SIG's CodeSignal OA (typically 1–3 weeks for manual resume screening after certification) leads into three unique SIG interview twists that catch pure SWE candidates off guard:
Recruiter Screen (30 Minutes — Watch Out for Live Mental Probability!):
Alongside "Why SIG and options market making?" and a deep walkthrough of one resume project, several SIG recruiters ask 3 to 5 rapid no-calculator probability / expected-value questions aloud (expected value of a single die roll with one optional re-roll = 4.25; conditional probability with two coins; expected flips until HT vs. HH). Brush up on 20 minutes of discrete EV math even for pure SWE roles! For instance, on the classic two-roll fair die prompt (roll once; either cash out its face value in dollars or forfeit it for one final roll), a single final roll averages 3.5, so you keep 4, 5, or 6 on Roll 1 ((4 + 5 + 6) / 6 = 2.5) and re-roll 1, 2, or 3 ((3 / 6) * 3.5 = 1.75), giving an exact optimal value of 4.25 in ten seconds aloud—and on Bayes' two-coin prompt (one fair coin and one double-headed coin in a bag; you draw one at random and flip 2 straight heads—what is the probability the coin is double-headed?), compare likelihood weights 1 * 0.5 = 0.50 vs. 0.25 * 0.5 = 0.125 to state 4 / 5 (80%) cleanly without touching a calculator.
Live Technical CodeSignal Interview (30–90 Minutes):
Practical string/graph coding (ticker extraction, scrambled flight tickets) or raw C++ container memory ownership (std::vector push_back + Rule of Five).
Final Onsite / Superday (Bala Cynwyd, Dublin, or Sydney):
Unlike Big Tech distributed-systems whiteboarding, SIG SWE finals emphasize concrete Low-Level Object-Oriented Design (LLD)—designing clean class hierarchies, interfaces, and extensible pricing/discount rules for a Grocery-Store Checkout Engine or Library Lending System down to exact method signatures—paired with another coding session and manager team-matching! (Quant Trader Superdays replace LLD with a full day of live card/dice expected-value market-making and group bidding games.)
Reuse a Certified 575–600 GCA Score If You Already Hold One: If you certified a 575+ GCA run for another company within the past 6 months, share it directly—otherwise, practice two timed Q1 -> Q2 -> Q4 -> Q3 sets before clicking SIG's link!
Verify Counter Compression on Asymmetric Stream Queries: On Slot 4, always iterate over the unique keys of the smaller/static array rather than scanning 50,000 raw elements per query.
Pair Dual-Device Mode Before Opening Chrome: Confirm isExtended === false, open Linkjob AI on your phone's mobile webpage via QR scan, verify the desktop answer-display toggle is OFF, and mount your phone 1 inch below your webcam lens.
Audit Every Language Listed on Your Resume Before Round 3: Never leave "Proficient in C++" on your SIG resume unless you can write raw ::operator new, std::construct_at, and move-assignment operators by hand!
Usually not during competitive campus and graduate waves. Because SIG sends its 70-minute CodeSignal link automatically before human resume screening, advancing developer candidates typically score 560 to 600 / 600 (4/4 solved cleanly, or 3/4 plus high Q4 partial credit paired with standout systems internships).
Because SIG uses an OA-first, resume-screen-second pipeline! Scoring 600/600 unlocks human recruiter review of your resume against open Bala Cynwyd, New York, Chicago, Dublin, or Sydney headcount—which routinely takes 1 to 4 weeks during peak autumn recruiting.
Yes. SIG's 70-minute developer GCA uses CodeSignal Certified proctoring, requiring government photo ID upload, continuous webcam and microphone recording, single-monitor verification, and full Entire Screen capture reviewed within 24 to 48 hours.
No. Quantitative Trader and most Quantitative Researcher candidates receive SIG's 60-minute, 17-question Problem Solving Assessment (testing probability, expected value, Bayes' rule, Markov chains, and logic grids rather than software engineering DSA), though select Quantitative Research Intern tracks receive a 4-to-5-problem coding CodeSignal test.
Yes—SIG's initial 70-minute developer GCA allows you to code in Python, Java, C++, or C# (Python is fastest for Slot 3 matrix slicing and Slot 4 Counter stream maps!). Just be ready to code in C++ during Round 3 if you apply specifically to a low-latency C++ Trading Systems track or highlight C++ heavily on your CV.
How I Passed the 2026 TikTok CodeSignal Online Assessment: Tips, Strategies, and Preparation Guide
How I Navigated the Visa CodeSignal Assessment and What I Learned
How I Cracked the Ramp CodeSignal Assessment and What You Can Learn
I Cracked the Coinbase CodeSignal Assessment: My Insider Guide
How I Succeeded in the eBay CodeSignal Assessment Without Stress
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.
