If you are hunting for an SDE role in North America, CodeSignal's GCA (General Coding Assessment) is nearly impossible to avoid. It is not an ordinary practice site. It is a data-driven, standardized ability assessment, and companies like Databricks, Uber, Robinhood, Asana, and Brex use the GCA score directly to decide whether you advance to the next round. A lot of people walk away confused: "I passed every test case, so why is my score lower than my classmate's?"
The answer lives in the scoring model. The GCA is out of roughly 850, but it looks at far more than your pass rate. This article breaks down the GCA scoring logic in detail: how correctness, speed, code cleanliness, and stability combine into your final score, and how to systematically improve on each dimension. A sibling article, the "CodeSignal GCA First-Round Filter Survival Guide," covers the overall flow and cutoffs. This one is a deep dive into the scoring model.
CodeSignal GCA Quick Reference
| Dimension | Details |
|---|---|
| Platform | CodeSignal (GCA general assessment / company-specific OA) |
| Common users | Databricks, Uber, Robinhood, Asana, Brex |
| Max score | About 850 |
| Questions / time | 4 questions, about 70 minutes, increasing difficulty |
| Scoring dimensions | Correctness + speed + cleanliness + stability |
| Languages | Python / Java / JS / Go and more |
| Retakes | Usually one-shot; score is reusable across companies |
1. Why "All Tests Pass" Can Still Differ
First, let's kill the most common misconception: the GCA is not "test cases passed / total cases x 850." If it were, everyone who got an AC would score the same. In reality, the GCA evaluates your entire problem-solving process, and it weighs four dimensions:
- Correctness: how many test cases you pass, including hidden ones. This is your baseline score.
- Speed: how fast you submit a correct solution. Earlier correct submissions score higher, because the metric captures ability density, not just whether you eventually get there.
- Cleanliness: whether your code is concise, readable, and idiomatic. Redundant, repetitive, or roundabout implementations lose points.
- Stability: whether the solution holds across all cases, including edge cases and large-input performance cases. A solution that passes the samples but times out or crashes on extreme input loses stability points.
So two people who both "pass every test" can look very different: one submits a clean O(n) solution at minute 20, the other grinds until minute 65 and turns in a working but verbose solution. The former earns clearly higher speed and cleanliness points, so the totals pull apart. On top of that, Q4 offers partial credit: even without a full AC, the cases you do pass still count.
2. Scoring Breakdown Table
| Dimension | Effect on score | How to improve |
|---|---|---|
| Correctness | Baseline; sets your floor | Enumerate edge cases up front (empty input, single element, duplicates, out of range); self-test with extreme input before submitting |
| Speed | At equal correctness, earlier submission scores higher | Practice under a timer; drill high-frequency patterns into muscle memory so you recognize the approach on sight |
| Cleanliness | Redundant/roundabout code caps your ceiling | Use idiomatic constructs (Counter, two pointers, slicing); one function does one thing, avoid deep nesting |
| Stability | Edge/performance cases decide whether you max out | Nail the optimal complexity before coding; avoid O(n) traps like list.pop(0), use a deque |
Key insight: these four dimensions are not independent bonus points; they are interlocked. Code that is clean is usually fast to write, and a solution whose complexity you thought through is usually stable. So the core of prep is not "grind more problems," it is drilling common patterns until they come out fast, clean, and stable.
3. GCA vs Custom OA
CodeSignal hosts two kinds of assessment, and their scoring emphasis and problem types differ. Sort out which one you are facing before you prep:
| Comparison | GCA (general assessment) | Custom OA (company-specific) |
|---|---|---|
| Representative companies | Databricks, Uber, Robinhood, Asana, Brex | Ramp, Two Sigma, Opendoor, Cruise, Square |
| Problem types | Standard algorithms: arrays, strings, graphs, DP | Complex JSON parsing, heavy string processing, business modeling, DP |
| Score reuse | One score works for many companies | Usually valid only for that company |
| Difficulty curve | Q1 to Q4 steadily increases | Larger single problems, longer prompts |
| Prep focus | High-frequency patterns + speed + stability | Reading and modeling ability + edge coverage |
In short: the GCA is about doing standard problems fast and stably; the custom OA is about accurately modeling a complex prompt. Both reward cleanliness and stability, but the custom OA leans harder on reading long prompts and decomposing requirements.
4. High-Frequency Patterns
Whether GCA or custom OA, the following show up again and again and are worth drilling into muscle memory:
| Pattern | Typical focus | Suggested LeetCode |
|---|---|---|
| Sliding window | Array/string range statistics | 3, 76, 209 |
| String splitting/processing | split, parsing, frequency counting | 49, 819, 271 |
| Graph | BFS/DFS, connected components | 200, 133, 994 |
| Permutation/simulation | State advancement, rule execution | 46, 289, 54 |
| Dynamic programming | Counting, optimal substructure | 70, 322, 300 |
5. A Representative Problem: A Clean, Fast Sliding Window
Problem Background
Given an integer array nums and a window size k, return the number of distinct elements in each contiguous window of length k. This is a classic GCA combination of sliding window plus hash counting, and it shows best how "cleanliness" and "stability" move your score.
Approach
- Keep a hash map of the count of each value in the current window;
len(count)is the number of distinct elements. - As the window slides right: increment the new element's count, decrement the element sliding out, and delete it from the map once its count hits zero.
- This is O(n) throughout, with no repeated scanning, which is exactly how you earn the speed and stability points.
Python Solution
from collections import defaultdict
from typing import List
def distinct_in_windows(nums: List[int], k: int) -> List[int]:
"""Return the number of distinct elements in each window of length k."""
# Edge case: empty array or invalid k returns empty, keeps it stable
if k <= 0 or k > len(nums):
return []
count = defaultdict(int)
result = []
for i, x in enumerate(nums):
count[x] += 1 # new element enters the window
if i >= k: # window is full, drop the leftmost
left = nums[i - k]
count[left] -= 1
if count[left] == 0: # delete at zero so len stays accurate
del count[left]
if i >= k - 1: # only record once k elements are in
result.append(len(count))
return result
if __name__ == "__main__":
print(distinct_in_windows([1, 2, 1, 3, 4, 2, 3], 3)) # [2, 3, 3, 3, 3]
print(distinct_in_windows([1, 1, 1], 2)) # [1, 1]
print(distinct_in_windows([], 3)) # []
Time complexity: O(n), each element enters and leaves the window once. Space complexity: O(k)
Why this version scores higher: compare it to the brute-force "recompute
len(set(nums[i:i+k]))for every window." That is O(n·k). It passes the samples, but the performance cases time out, and you lose the stability points outright. The sliding-window version is O(n) so it clears large inputs, the code is shorter and its intent is clearer (cleanliness points), and once you have drilled it you can submit in 5 minutes (speed points). Same problem, same full AC, and those three differences are enough to pull the totals apart.
6. Prep Strategy
Translate the scoring model into executable training actions:
| Target dimension | Training method |
|---|---|
| Correctness | Hand-write 3-4 edge cases before the main logic; anticipate hidden cases early |
| Speed | Two 70-minute, 4-question timed mocks per week; recognize the pattern on read |
| Cleanliness | After solving, revisit and rewrite anything that Counter/two pointers/slicing can simplify |
| Stability | Ask "what is the worst input?" for every problem; fix the complexity before coding |
Our OA assist / OA live support service is built exactly around this scoring model as end-to-end coaching: scoring-model walkthroughs (making clear how the 850 is computed), problem-type prediction (high-frequency patterns per company for the current cycle), complete solutions plus complexity analysis (the fast, clean, optimal write-up for each problem), and mocks plus real-time collaborative coaching, so you perform stably on the real assessment and max out every dimension.
FAQ
Q1: What is the maximum GCA score? About 850. It is not a simple "pass rate x 850." It is a composite of four dimensions: correctness, speed, code cleanliness, and stability. You get 4 questions in roughly 70 minutes with increasing difficulty.
Q2: I passed every test case, so why is my score different? Because the GCA also looks at how fast you submit, whether your code is concise, and whether your solution stays stable on extreme and performance cases. Two people both AC, but one submits a clean O(n) solution at minute 20 and the other a verbose one at minute 65, and the speed and cleanliness points pull the totals apart.
Q3: How do I raise my GCA score? Train four directions at once: cover edge cases to raise correctness, do timed mocks for speed, use idiomatic constructs to stay clean, and fix the complexity up front to avoid timeouts and stay stable. The core is drilling high-frequency patterns until they come out fast, clean, and stable, not just piling on problem volume.
Q4: What is the difference between the GCA and a custom OA? The GCA is a general standardized assessment with standard-algorithm problems, and one score can go to many companies. A custom OA (like Ramp, Two Sigma, Cruise) has longer prompts, leans toward complex JSON parsing and business modeling, and is usually valid only for that company. Both value cleanliness and stability.
Q5: Do I still get points if I don't finish Q4? Yes. Q4 supports partial credit, so every case you pass counts. The strategy is to lock in full marks on the first three questions, and on Q4, even if you cannot finish, pass as many cases and cover as many edges as you can to bank every available point.
Preparing for the CodeSignal GCA?
If you are worried your speed is not enough, your Q4 AC is incomplete, or you cannot figure out which dimension is holding down your "all-pass-but-low-score," let's talk through a full OA assist / OA live support plan, from scoring-model walkthroughs to problem-type prediction, timed mocks, and real-time coaching, so you walk in prepared and score stably.
Add WeChat Coding0201 now to get real problems and a prep plan.
Contact
- WeChat: Coding0201
- Email: [email protected]
- Telegram: @OAVOProxy