When people hear "Susquehanna (SIG) OA," the first thing that comes to mind is PSA probability questions and 90-second mental math. But if you applied to the SDE / Software Developer track, the real bottleneck is a CodeSignal coding OA with a completely different interface, scoring logic, and question style than PSA.
Many candidates show up armed with a "probability question bank" and then discover three pure algorithm coding problems with a brutal time limit. This article focuses on the SIG CodeSignal coding track: three high-frequency question skeletons, full Python solutions, a 70-minute time budget, and the traps that cost the most points.
1. SIG CodeSignal Coding OA Overview
| Dimension | Details |
|---|---|
| Platform | CodeSignal (General Coding Assessment style) |
| Questions | Usually 3-4, increasing difficulty |
| Duration | Around 70 minutes (some batches 60-90 min) |
| Language | Python / C++ / Java; Python saves the most time |
| Scoring | Proportional to test cases passed; partial credit counts |
| Topics | Array/string simulation, greedy intervals, graph traversal, stack/hash |
The key insight: CodeSignal awards partial credit per test case. So even if you cannot finish the third problem, passing every edge case on the first two beats writing a half-baked brute force on the third. Secure the score first, then chase the hard problem.
2. Question Type 1: Order Matching (Array + Hash)
Problem Statement
Given a buy-order array buys and a sell-order array sells, where each order is (price, qty). A buy matches a sell when buy price ≥ sell price, and the matched volume is the smaller of the two remaining quantities. Match in priority order "buy price high-to-low, sell price low-to-high" and return total matched volume.
Approach
This is a classic "dual-priority sort + two pointers" problem. Higher buy prices want to trade most, lower sell prices want to trade most, so sort buys descending, sells ascending, then advance two pointers.
Python Solution
def total_matched_volume(buys, sells):
# Buy price high-to-low, sell price low-to-high
buys = sorted(buys, key=lambda x: -x[0])
sells = sorted(sells, key=lambda x: x[0])
i = j = 0
total = 0
# Remaining quantity of current buy/sell order
buy_left = buys[0][1] if buys else 0
sell_left = sells[0][1] if sells else 0
while i < len(buys) and j < len(sells):
bp, _ = buys[i]
sp, _ = sells[j]
if bp < sp:
# Even the highest buy is below the lowest sell: no more matches
break
deal = min(buy_left, sell_left)
total += deal
buy_left -= deal
sell_left -= deal
if buy_left == 0:
i += 1
buy_left = buys[i][1] if i < len(buys) else 0
if sell_left == 0:
j += 1
sell_left = sells[j][1] if j < len(sells) else 0
return total
Time complexity: O(n log n + m log m), dominated by sorting Space complexity: O(1) extra (excluding sort)
Common Traps
❌ Forgetting to break when prices do not match, which fabricates trades that cannot happen
✅ Advance a pointer only when its remaining quantity hits zero, or you skip same-price multi-orders
3. Question Type 2: Order-Book Interval Merge (Greedy + Intervals)
Problem Statement
A market system receives a batch of resting-order price intervals [lo, hi], meaning the order can fill anywhere in that band. Merge all overlapping intervals and return the total length of price points covered by at least one order.
Approach
Classic interval merge: sort by left endpoint, scan linearly, maintain the current merged segment [cur_lo, cur_hi], extend on overlap, settle and open a new segment otherwise.
Python Solution
def covered_length(intervals):
if not intervals:
return 0
intervals.sort(key=lambda x: x[0])
total = 0
cur_lo, cur_hi = intervals[0]
for lo, hi in intervals[1:]:
if lo <= cur_hi:
# Overlap: extend the right endpoint
cur_hi = max(cur_hi, hi)
else:
# Settle previous segment, open a new one
total += cur_hi - cur_lo
cur_lo, cur_hi = lo, hi
total += cur_hi - cur_lo
return total
Time complexity: O(n log n) Space complexity: O(1) extra
Common Traps
❌ Writing lo < cur_hi (strict) splits adjacent intervals like [1,3] [3,5] incorrectly
✅ Do not forget to settle the final segment cur_hi - cur_lo after the loop
4. Question Type 3: Market-Routing Graph Traversal (BFS / Shortest Path)
Problem Statement
A market-distribution network has n nodes; edges[i] = (u, v, latency) is a bidirectional link delay. Starting from exchange node 0, return the sum of minimum delays to reach all nodes; return -1 if any node is unreachable.
Approach
Single-source shortest path on a weighted graph: heap-optimized Dijkstra. Sum all node distances at the end and return -1 on any unreachable node.
Python Solution
import heapq
from collections import defaultdict
def total_min_latency(n, edges):
graph = defaultdict(list)
for u, v, w in edges:
graph[u].append((v, w))
graph[v].append((u, w))
dist = [float('inf')] * n
dist[0] = 0
pq = [(0, 0)] # (accumulated latency, node)
while pq:
d, node = heapq.heappop(pq)
if d > dist[node]:
continue
for nxt, w in graph[node]:
nd = d + w
if nd < dist[nxt]:
dist[nxt] = nd
heapq.heappush(pq, (nd, nxt))
if any(x == float('inf') for x in dist):
return -1
return sum(dist)
Time complexity: O((V + E) log V) Space complexity: O(V + E)
Common Traps
❌ Using plain BFS as shortest path: on a weighted graph BFS gives fewest edges, not least latency
✅ Keep the if d > dist[node]: continue line, or stale heap entries slow you down or cause errors
5. Suggested 70-Minute Time Budget
| Phase | Time | Goal |
|---|---|---|
| Read all three | 0-5 min | Rank difficulty, easiest first |
| Q1 (array/hash) | 5-20 min | Full pass + edge cases |
| Q2 (interval greedy) | 20-40 min | Full pass, test adjacency edges |
| Q3 (graph/shortest path) | 40-63 min | Brute force first for partial credit, then optimize |
| Review | 63-70 min | Run custom cases, check empty/single element |
Core mindset: CodeSignal gives partial credit, so "80% on each of three" beats "two perfect, one zero." If you are stuck past 8 minutes, switch problems immediately to protect your score.
FAQ
Q1: Is the SIG CodeSignal OA the same sitting as the PSA probability test? No. PSA is the Problem Solving Assessment (probability/logic/mental math); the CodeSignal coding OA is an SDE-track pure-algorithm coding test. The platform, scoring, and question types are entirely separate. SDE applicants usually face the latter.
Q2: What LeetCode level does the CodeSignal OA map to? The first two questions are around LeetCode Medium; the third (graph/shortest path/DP) is Medium-Hard. The challenge is not exotic problems but passing all three at a high rate within 70 minutes; time pressure is the real gate.
Q3: Can I use Python? Will it get TLE for being slow? Yes, and Python saves the most coding time. SIG's input sizes usually do not punish Python; as long as your complexity is right (do not use O(V²) on the graph problem), you will not hit TLE.
Q4: Can I still advance if I do not finish all three? Yes. CodeSignal scores proportionally to test cases passed, so full passes on the first two plus partial credit on the third is usually enough to reach the phone screen. Do not sacrifice the first two's edge cases chasing a perfect third.
Q5: What comes after the SIG coding OA? Coding OA → phone technical screen (1-2 rounds of algorithms + behavioral) → onsite (coding + systems/brain teasers + culture fit). The OA is just the first filter; once you pass, prepare immediately for live coding in the phone screen.
Final Thoughts
SIG's CodeSignal coding OA is not won with obscure problems; it is won by passing three medium problems cleanly within 70 minutes. Drill the three skeletons (order matching with two pointers, interval merge with greedy, market routing with Dijkstra) into muscle memory, pair that with a "secure the score before chasing the hard one" rhythm, and your pass rate changes qualitatively.
If you are preparing for SIG's SDE track and want batch-specific OA question reconstructions, timed mocks, or OA assistance / OA proxy pacing support, reach out on WeChat Coding0201. Send a screenshot of the job description, and we will first determine your track (SDE coding vs Quant probability), then build a practice plan.
Need real interview questions? Contact WeChat Coding0201 now to get real questions.
Contact
- WeChat: Coding0201
- Email: [email protected]
- Telegram: @OAVOProxy