Capital One OA: CodeSignal Questions, Scores & Prep Guide

The Capital One OA is an online assessment stage in the hiring process. If your invitation names the CodeSignal General Coding Assessment (GCA), the standard format is four coding questions in 70 minutes, with all questions available from the start. Prepare to turn unfamiliar rules into working code, check edge cases, and choose problems you can finish. Your invitation controls the actual assessment and time allowance. CodeSignal's GCA overview explains the standard format.

This guide is for software engineering and technology internship applicants. Start with the assessment name before choosing a study plan: Capital One also uses other assessments, and a Virtual Job Tryout is a different preparation task.

Research note: Sources were checked on September 15, 2026. The four exercises below are original teaching examples with locally tested Python solutions, not Capital One questions or a reconstruction of a candidate's exam. SkillCopilotAI publishes this guide and offers an AI interview assistant; the preparation advice does not depend on using our product.

Which Capital One assessment do you have?

Capital One's student and graduate application guidance lists the Technology Development Program and Internship among programs requiring an online assessment. It does not establish that every role receives the same test or invitation sequence.

Capital One's candidate FAQ describes the VJT as individualized: its modules depend on the role and what you have already completed. Treat an early online exercise and a later job-fit interview as separate events unless your recruiter says otherwise.

Applying for the 2027 technology internship

PracHub's Summer 2027 guide collects candidate reports of a role-fit exercise, a CodeSignal stage, and missing invitation links. Those reports help identify questions to ask; they do not establish a universal sequence. Record the assessment name and completion status for each task assigned to your application. Completing one task is not evidence that another has been completed automatically.

Capital One OA questions: four skills to practice

Use the following set to find gaps in implementation, counting, indexing, and repeated work. It is a diagnostic set, not a calibrated mock GCA: the exercises do not predict the difficulty or order of your four exam questions.

Before opening a solution, write down the input, the required output, and one small case you can calculate by hand. All functions assume inputs satisfy the stated constraints. If you need broader platform context, read our CodeSignal OA preparation guide.

Exercise 1: longest successful run

Original practice problem. You receive a list of event statuses, each either "ok" or "fail". Return the length of the longest consecutive run of "ok" events. An empty list returns 0. There can be up to 100,000 events.

Example: ['ok', 'ok', 'fail', 'ok', 'ok', 'ok'] returns 3.

The important distinction is consecutive versus total. The example contains five successful events, but its longest uninterrupted run contains three.

def longest_ok_run(statuses):
    current = 0
    best = 0
    for status in statuses:
        if status == 'ok':
            current += 1
            best = max(best, current)
        else:
            current = 0
    return best

After each event, current is the successful run ending at that event; best is the longest run seen anywhere so far. Updating best inside the loop also handles a longest run that ends at the final item.

Complexity: O(n) time and O(1) extra space.

Check yourself: [] → 0, ['fail'] → 0, and ['ok', 'ok'] → 2. If you update best only when a failure appears, the final case exposes the bug.

Exercise 2: count all matching index pairs

Original practice problem. Given a list of integers and a target, count pairs of indices (i, j) where i < j and the two values sum to the target. An index may participate in several different pairs; the two indices within each pair must be different. Equal values at different indices count separately. Negative numbers and duplicates are allowed. The list may be empty and contains at most 100,000 values, each between negative one billion and one billion; the target is in the same range.

Example: values = [2, 2, 3, -1, 6], target = 5 returns 3. Either 2 can pair with 3, and -1 pairs with 6.

Checking every pair is a useful small-input reference, but it repeats work. Instead, count how many matching values have already appeared.

def count_target_pairs(values, target):
    seen = {}
    pairs = 0
    for value in values:
        pairs += seen.get(target - value, 0)
        seen[value] = seen.get(value, 0) + 1
    return pairs

The lookup happens before inserting the current value. That ensures the current index cannot pair with itself. Storing counts rather than membership preserves duplicate pairs.

Complexity: expected O(n) time using a hash map; O(n) extra space in the worst case. In a language with fixed-width integers, use a sufficiently wide type for the pair count: a long list can have more than two billion pairs.

Check yourself: [3], 6 → 0; [3, 3, 3], 6 → 3; [-2, 0, 2], 0 → 1. The single-item case catches insertion in the wrong order.

Exercise 3: update a grid simultaneously

Original practice problem. A nonempty rectangular grid contains 0 or 1. Produce a new grid in which a cell is 1 when at least two of its orthogonal neighbors were 1 in the original grid; otherwise it is 0. Orthogonal means up, down, left, and right. The cell itself does not count. Missing neighbors contribute nothing. Do not modify the input. Each dimension is between 1 and 300.

Example:

Input                 Output
1 1 0                 1 0 0
1 0 0                 0 1 0

The top-left cell has two active neighbors. So does the bottom-middle cell. The top-middle cell has only one; diagonal cells do not count.

def next_grid(grid):
    rows, cols = len(grid), len(grid[0])
    result = [[0] * cols for _ in range(rows)]
    directions = ((-1, 0), (1, 0), (0, -1), (0, 1))
    for row in range(rows):
        for col in range(cols):
            active = 0
            for dr, dc in directions:
                nr, nc = row + dr, col + dc
                if 0 <= nr < rows and 0 <= nc < cols:
                    active += grid[nr][nc]
            result[row][col] = int(active >= 2)
    return result

Read from grid and write to result. An in-place update can make later cells read a mixture of old and new values. That produces a different process even when the neighbor arithmetic is correct.

Complexity: O(rows × cols) time and O(rows × cols) space for the output. Each cell checks at most four neighbors.

Check yourself: [[1]] → [[0]]; [[1, 0, 1]] → [[0, 1, 0]]. Also test a grid with more rows than columns to catch swapped dimension limits.

Exercise 4: answer many interval-total queries

Original practice problem. Given an integer list values and queries (left, right), return the sum of each inclusive interval. Indices are zero-based. The list contains 1–100,000 values between negative one billion and one billion. There can be 0–100,000 queries, each satisfying 0 <= left <= right < len(values).

Example: values = [4, -2, 7, 1], queries = [(0, 0), (1, 3), (0, 3)] returns [4, 6, 10].

Summing each slice separately can take O(n × q) time. Precompute a running total once, then answer each query with two array lookups.

def interval_totals(values, queries):
    prefix = [0]
    for value in values:
        prefix.append(prefix[-1] + value)
    return [prefix[right + 1] - prefix[left]
            for left, right in queries]

prefix[k] means the sum of the first k items. To include values[right], use prefix[right + 1]. Subtracting prefix[left] removes everything before the interval.

For the example, prefix is [0, 4, 2, 9, 10]. Query (1, 3) becomes 10 - 4 = 6. Negative values do not change the method.

Complexity: O(n + q) time; O(n) auxiliary space plus O(q) for returned answers. Use wide integer sums in fixed-width languages.

Check yourself: a single-item interval, the full array, all-negative values, and no queries. If (0, 0) returns zero, inspect the inclusive right boundary.

My hands-on practice test: LeetCode Two Sum

I tested SkillCopilotAI with LeetCode's Two Sum on a MacBook Air, using C++. The three screen photographs below document my practice setup, the assistant's answer, and the accepted submission. This was a practice exercise, not a Capital One assessment or a timed GCA attempt. I am Emma, SkillCopilotAI's article editor and operations manager, and I performed this test myself.

1. The practice task

Two Sum asks for two distinct indices whose values add to a target. Unlike Exercise 2 above, it returns one pair rather than counting every matching pair. My setup photograph shows the task beside a C++ function stub. The page already displays a “Solved” marker, so this is not evidence of a first-attempt result.

My Two Sum practice setup on a MacBook Air. Photo by Emma; open it to inspect at full size.

2. The assistant's visible response

SkillCopilotAI recommended a hash map and supplied C++ code that checks for the complement before storing the current index. That order prevents the current element from being paired with itself. For duplicate values such as [3, 3] with target 6, the first index is stored and the second finds it.

SkillCopilotAI's answer during my practice test. Photo by Emma. The exact prompt, input method, model, app version, and number of attempts are not visible in these photographs.

3. The submitted result

The result photograph displays Accepted — 65 / 65 test cases passed. The C++ code visible in the editor follows the same lookup-before-insert logic as the assistant's displayed answer. The submission timestamp reads September 17, 2026, at 01:23; the display does not specify a time zone. The photographs do not provide an uninterrupted record of any edits between the answer and submission.

My LeetCode submission result. Photo by Emma. LeetCode's displayed 0 ms runtime is a code-execution metric, not the assistant's response time or a repeatable speed guarantee.

What to take from this example: use generated guidance to understand the invariant, then verify the code and explain the approach independently. My submission was accepted, but this single practice result does not establish performance on harder problems, a Capital One pass rate, or permission to use assistance during an assessment.

Why can the OA feel harder than your practice?

In the Capital One OA Too Hard discussion, one candidate reported passing only some tests on the later questions and struggling with unusual edge cases. That is one account, not a difficulty distribution. It does describe a preparation gap you can address: translating the entire specification, including boundaries, into code under time pressure.

Use failed tests to narrow the problem:

Do not randomly change several conditions at once. Construct the smallest failing input, calculate the expected result manually, change one cause, then rerun previous cases. In practice, compare an optimized solution against a slower independent implementation on many small inputs. That is how the solutions in this article were checked.

How to use a 70-minute practice window

Try this allocation in a fresh practice set, then adjust it using your own results. It is an editorial training plan, not a claim about the optimal order for every GCA.

Switch when you cannot describe the next implementation step and another question offers a clearer route. A fixed 1 → 2 → 4 → 3 order can be worth trying in practice, but question numbers alone do not tell you which task you can finish fastest.

Save by submitting. CodeSignal's GCA rules and setup instructions say to submit before leaving a task so your work is saved. You may submit repeatedly; the system keeps the highest-scoring submission for that question. The timer begins after setup, and an employer may configure a different duration. Verify the displayed rules before starting.

What score do you need for Capital One?

CodeSignal's current certified assessments use an Assessment Score from 200 to 600. Its scoring explanation describes base points and module-completion bonuses. Raw task points or the percentage of tests passed are not a simple conversion into that final score.

We did not find a universal Capital One passing score in the official materials reviewed for this guide. A community report pairing a score with an outcome does not establish a cutoff for another role or hiring cycle. Ask your recruiter about the requirements attached to your invitation; do not treat a claimed threshold as a guarantee of an interview.

Older discussions may use a scale ending at 850. CodeSignal's historical threshold guidance explicitly says its tables are not for converting individual candidates' scores. Use the result shown in your current report.

For preparation, record which skills break down: parsing, implementation, edge cases, or runtime. A score alone does not tell you which one to fix.

Can Capital One reuse your existing CodeSignal result?

An eligible result may be shared for a new invitation. It is not safe to assume that an old result has already been accepted. CodeSignal's result-sharing instructions distinguish sharing an eligible existing result from retaking when outside the applicable cooldown period.

Use your current invitation to make the decision:

The Assessment Hub documentation explains where to see invitations, expiry information, results, and available actions. Do not select Decline to refresh a broken invitation: CodeSignal says that action removes the invitation and cannot be undone.

There is a real tradeoff in retaking. Under CodeSignal's sharing policy, the requesting company receives the newly validated result even if it is lower. If the same company already received an earlier result for that assessment, it may retain access to that result too. This differs from submitting a single question multiple times during one assessment.

We have not verified a single Capital One result-age limit that applies to every role. Follow the current invitation rather than assuming all scores remain eligible for six months.

Missing your Capital One OA link?

A Workday status or missing email does not, by itself, tell you whether you passed, failed, or reused a score. Start with Capital One's official assessment-access instructions: candidates receive a Workday email and a Workday task containing a PDF with an assessment link.

1. Check the application email and spam folder. Search for messages from Capital One, Workday, and CodeSignal, if CodeSignal is the named platform.
2. Open the task in your Workday profile. Look for the PDF and its link, not only an email button.
3. Compare the assessment names. Confirm whether the task is a VJT, a coding assessment, or another required step.
4. Check the corresponding CodeSignal invitation. Record the visible state and deadline. An empty Hub is not proof of rejection.
5. Contact support before the deadline. Capital One directs Workday email issues to [email protected]. Include the job or requisition number and the specific mismatch. Remove unrelated personal information from screenshots.

You can adapt this message:

Subject: Assessment link unavailable — [job title / requisition number]

Hello, I applied for [role] using [application email]. Workday currently shows [exact status], but [the PDF link is unavailable / the link returns this error / no matching CodeSignal invitation is visible]. I checked my spam folder and Workday tasks at [date, time, time zone]. The stated deadline is [deadline, if provided]. Could you confirm which assessment I need to complete and help me access the correct invitation? If a previous CodeSignal result is being considered, please confirm whether any action is still required from me. Thank you.

A seven-day preparation plan

Use the time you actually have. If the deadline is closer, prioritize the diagnostic, your largest gap, and a fresh timed set; this plan is not a reason to delay submission.

Use CodeSignal's practice entry in the Assessment Hub to learn its editor and submission controls before a scored invitation. Our Roblox OA guide illustrates why employer-specific stages need separate preparation even when coding platforms overlap.

FAQ

Does everyone who applies receive a Capital One OA?

The official student guidance describes a process that varies by program and includes recruiter review. It does not establish that every applicant automatically receives the same OA. Use the task assigned to your application; do not infer your status from another candidate's invitation.

Can I use AI, a second device, or an external editor during the GCA?

CodeSignal's current GCA rules prohibit AI assistance, including AI syntax searches. The GCA overview also says to code inside the assessment rather than an external IDE. Follow the displayed resource and workspace rules; using a separate device does not make outside assistance permissible. The official rules distinguish permitted basic syntax references from help with solution logic.

Should I switch to Python right before the assessment?

Choose an allowed language you can debug reliably. The examples here use Python for readability. Changing languages shortly before a deadline can introduce unfamiliar collection behavior, indexing mistakes, and syntax delays. Test your choice on a fresh practice problem first.

How long after the OA will I hear back?

We did not verify a universal OA-to-response deadline. A timeline for a final hiring decision is not the same as a timeline after a coding assessment. Follow any date your recruiter supplies; if none is provided, a concise request for the expected next step is more useful than interpreting silence as a score result.

Continue preparing for the next stage

Capital One's student guidance lists behavioral, case, and technical interviews for the Technology Development Program and Internship. After the OA, prepare one clear project explanation, examples of your own decisions and teamwork, and a case response that connects evidence to a recommendation. Your recruiter can confirm the rounds for your role.

Practice your explanation with SkillCopilotAI

After solving an exercise, rehearse explaining why your approach works. SkillCopilotAI's AI interview assistant describes support for coding explanations and technical interview guidance. This is our own product. My Two Sum test above documents one practice example; the workflow below is a separate suggested exercise, not another completed product test.

1. Save your independent attempt. Keep the code, elapsed time, and one case you found difficult.
2. Rehearse one focused question. For Exercise 2, try: “Why must I look up the complement before adding the current value to the frequency map? Explain what could go wrong with a one-element input.”
3. Check the guidance. Compare it with the worked solution above. Run any suggested counterexample; a confident explanation can still be wrong.
4. Try again without assistance. Explain the update order aloud, then solve a fresh variant from a blank file. Record which step you can now explain independently.

Download SkillCopilotAI for your practice session

Choose the installer and check current system requirements on the download page. Use this workflow before an assessment: CodeSignal's GCA rules prohibit AI assistance during the test. Our guide to AI interview practice tools offers further criteria for choosing a preparation tool.

About the author and this guide

Emma handles article editing and operations management for SkillCopilotAI. This byline identifies an editorial role, not employment at Capital One, recruiting authority, or personal participation in its assessment.

This research-based guide was produced with AI-assisted research and drafting. It draws on the official sources linked beside the relevant claims and identifies candidate reports separately. A coding agent ran the four published Python solutions locally against explicit examples, edge cases, and independent reference implementations. These checks support the teaching examples; they do not measure hiring outcomes, demonstrate a human timed attempt, or certify an employer's question bank. No independent human technical review is claimed.

Sources were checked on September 15, 2026. Emma's hands-on practice test and photographs were added on September 17, 2026, with their evidence limits stated above. If an invitation differs from this guide, use its instructions and ask the recruiting or platform support team to resolve the difference. You can report a source or example that needs correction through SkillCopilotAI's contact page.