ZipRecruiter's 2026 SDE Intern / NG OA follows the standard CodeSignal General Coding Assessment template — 4 problems in 70 minutes with an L1-to-L4 difficulty curve. Problems aren't hard on their own, but ZipRecruiter leans heavily on string manipulation and recruiting-domain graph problems, and candidates who haven't seen the style often time out on the last problem. This recap walks the real questions, pacing, solutions, and the traps.
Platform and Pacing
| Item | Detail |
|---|---|
| Platform | CodeSignal GCA |
| Problems | 4 coding |
| Time | 70 minutes |
| Difficulty | L1 easy → L4 hard |
| Scoring | 0–600, weighted by difficulty |
| Pass threshold | Typically ≥ 480 to advance |
| Proctoring | CodeSignal webcam + screen monitoring |
CodeSignal's signature is that the first three problems sum to ~360 and the fourth problem alone is worth ~240, so the strategy is to AC the first three and grab partial credit on the fourth.
Spring 2026 Real Questions (4 problems)
Q1 (L1): Counting in Arrays — finish in 10 minutes
Given a string array
words, return the count of strings whose length equals k.
def count_length_k(words, k):
return sum(1 for w in words if len(w) == k)
Time O(n)
Q2 (L2): String Normalization — Job Title Cleanup
Given a job title string (mixed case, hyphens, extra spaces), return the normalized form: each word capitalized, single spaces between words, trimmed.
def normalize_title(s):
return " ".join(part.capitalize() for part in s.split())
Hyphen-preserving variant:
def normalize_with_hyphen(s):
def cap_token(tok):
return "-".join(p.capitalize() for p in tok.split("-"))
return " ".join(cap_token(t) for t in s.split())
Time O(n)
Q3 (L3): Job-Skill Matching Score
Given a candidate's skill list and a set of jobs with required skills, output the top-k jobs by Jaccard similarity descending.
def top_k_jobs(candidate_skills, jobs, k):
cs = set(candidate_skills)
scored = []
for job_id, required in jobs:
rs = set(required)
union = cs | rs
inter = cs & rs
score = len(inter) / len(union) if union else 0.0
scored.append((score, job_id))
scored.sort(key=lambda x: (-x[0], x[1]))
return [job_id for _, job_id in scored[:k]]
Time O(m · (s + r) + m log m), m = number of jobs
Q4 (L4): Skill Graph Critical Path
Given a skill graph where each skill has prerequisites, find how many additional skills a candidate must learn — given a known set S — to unlock a target skill t. Return -1 if impossible.
Key moves:
- Build reverse-dependency traversal: to unlock t you must unlock its prereqs
- DFS/BFS from t along prereq edges, counting unknown nodes
- Cycle check (problem may guarantee DAG, but defensive code is safer)
from collections import defaultdict
def min_skills_to_unlock(graph, known, target):
"""
graph: dict[skill] -> list[prereq skills]
known: set of skills the candidate already has
target: target skill
"""
if target in known:
return 0
visited = set()
stack = [target]
needed = 0
while stack:
cur = stack.pop()
if cur in visited:
continue
visited.add(cur)
if cur in known:
continue
needed += 1
for prereq in graph.get(cur, []):
if prereq not in visited:
stack.append(prereq)
return needed
Time O(V + E)
Variant: the problem may ask for the actual learning order — switch to topological sort + level BFS.
70-Minute Pacing Plan
0–10 min Full AC on Q1 (including sample case)
10–25 min Full AC on Q2 + edge cases
25–45 min Full AC on Q3 (watch Jaccard denominator = 0)
45–68 min Squeeze partial credit on Q4, minimum: sample passes
68–70 min Re-read all submissions, no syntax errors
Key: CodeSignal does not show historical scores per submission, so for every problem you must run sample + 2 edge cases yourself before submitting.
Four ZipRecruiter-Specific Details
- Strings dominate — most problems pull from recruiting (job titles, resumes, skills)
- Small inputs — n ≤ 10⁴, but O(n²) still fails hidden cases
- Generous samples, strict hidden cases
- Q4 frequently times out because candidates start coding before reading the full prompt
Common Traps
- Q2 using
s.title()— turns "iOS" into "Ios", wrong answer - Q3 dividing by zero when the union is empty
- Q4 not handling target already in
known(should return 0) printdebug statements left in (CodeSignal docks code quality)- Last-minute edits leaving an unsubmittable error
CodeSignal's Code-Quality Score
GCA also assigns a code quality grade (A–F):
| Dimension | Penalty |
|---|---|
| Variable naming | tmp/x/y consistently penalized |
| Function decomposition | 80-line single function loses points |
| Comments | No comments fine; wrong comments penalized |
| Print debugs | Leaving them in costs points |
Dropping from A to C can cost ~50 total score.
What a Top Run Looks Like
Among our students who hit 600 on ZipRecruiter CodeSignal, the pattern is consistent: 1–2 minute sanity check on Q1–Q3, then any partial on Q4. Our OA assistance runs a CodeSignal code-quality audit against the specific rubric.
For pricing and slots, ping WeChat Coding0201.
FAQ
How hard is the ZipRecruiter CodeSignal?
L1–L3 are LC easy/medium territory; L4 is LC medium-hard. Overall a tier below Meta CodeSignal.
Does 600 guarantee an onsite?
Community recalls say ≥ 480 advances to phone screen, ≥ 540 usually means onsite. 600 is a differentiator.
Can I use ChatGPT?
No. CodeSignal monitors webcam, screen, and tab switching — violations can lead to a blacklist.
Will Python TLE?
L1–L3 are fine. L4 can be tight — Python 3 with concise implementations and no unnecessary deepcopy.
Preparing for ZipRecruiter, Indeed, Glassdoor, or LinkedIn OAs?
oavoservice tracks recruiting-platform and CodeSignal GCA real questions. Mentors are front-line SWEs and offer string-problem specials, skill-graph drilling, and CodeSignal code-quality audits as OA assistance.
👉 Add WeChat: Coding0201 — Get the ZipRecruiter CodeSignal OA prep package.
Contact
Email: [email protected]
Telegram: @OAVOProxy