Google CodeSignal OA Questions: Reported Problems, Format and Original Practice

If your Google invitation includes a CodeSignal OA, start by checking the assessment name, duration and permitted tools. A page of Google CodeSignal OA questions cannot tell you which problems your invitation contains. Below, you will find linked Google-tagged practice problems, additional exercises to work on, and three Python solutions you can test yourself.

The distinction matters when planning your preparation: an employer-tagged practice catalog, CodeSignal's standard GCA and your own invitation provide different kinds of information. None of the original exercises in this guide is an official Google question.

Research note: Checked November 7, 2026, using CodeSignal's documentation and the linked FastPrep catalog. This guide was edited with AI assistance. Its three Python solutions passed 37,598 small-input comparisons against independent reference implementations; that tests the exercises, not Google's assessment. We did not take a Google OA. SkillCopilotAI publishes this guide and sells an AI interview assistant. Use external assistance only where your assessment instructions explicitly allow it.

What is the Google CodeSignal OA?

Here, “Google CodeSignal OA” means an online coding assessment for a Google application whose invitation specifies CodeSignal. It should not be treated as a universal Google hiring stage. Confirm the platform with your recruiter rather than assuming every software role uses the same test.

CodeSignal's General Coding Assessment (GCA) is a standardized assessment aimed at early-career hiring. Employers can also use custom assessments. A CodeSignal link alone does not establish whether you have a GCA, a custom test or permission to share an existing score.

Format: check the assessment named in your invitation

CodeSignal publishes rules for its standard GCA. Those rules help if your invitation names that assessment, but they do not confirm Google's configuration.

CodeSignal's assessment walkthrough explains that the information page shows duration, question count and instructions. It also describes a practice area. Use that area to check the editor before opening the scored test.

For a four-question, 70-minute mock, the average budget is 17.5 minutes per question, including reading and testing. Use that as a planning estimate, then give harder problems more time. Submit a working version before switching tasks when the instructions require it.

Google-tagged problems in a public practice catalog

The following titles appear in FastPrep's Google OA catalog. They are third-party practice entries, not an official Google question list. Catalog tags and report counts do not establish which platform, role or hiring cycle your invitation uses.

Read each full statement before choosing an algorithm. A catalog label is a starting point; a constraint such as preserving order or allowing duplicate values can change the solution.

Six additional patterns to practise

Use these as supplementary training prompts. We are not presenting them as verified Google candidate reports.

The three worked exercises below give you complete specifications and executable solutions. Use them to practise implementation and edge cases rather than trying to memorize an employer's question bank.

Original practice problem 1: distinct windows

Original problem written for this guide, in the style of an easy-to-medium CodeSignal task.

Given an integer array a and a positive integer k, return how many contiguous windows of length k contain no repeated value. The array may be empty; if k > len(a), return 0. Values in a may repeat or be negative.

Example: a = [1, 2, 3, 2, 4], k = 3. The windows are [1,2,3], [2,3,2] and [3,2,4]. Two have all distinct values, so return 2.

from collections import Counter

def count_distinct_windows(a, k):
    if k > len(a):
        return 0
    counts = Counter(a[:k])
    result = 1 if len(counts) == k else 0
    for i in range(k, len(a)):
        counts[a[i]] += 1
        counts[a[i - k]] -= 1
        if counts[a[i - k]] == 0:
            del counts[a[i - k]]
        if len(counts) == k:
            result += 1
    return result

Why it works: a window has no repeats exactly when it holds k distinct keys. Sliding the window updates one count in and one out, so the run time is O(n), with O(min(n, k)) extra space. Edge cases to test: k larger than the array, all-equal values, and k = 1.

Original practice problem 2: falling blocks

Original problem written for this guide, in the style of CodeSignal matrix simulation tasks.

You get a nonempty rectangular grid of nonempty strings containing only *, # and .. * is a loose block, # is a fixed obstacle and . is empty. Every loose block falls straight down until it hits the floor, an obstacle or another block. Return the grid after everything settles.

def drop_blocks(grid):
    rows, cols = len(grid), len(grid[0])
    out = [['.'] * cols for _ in range(rows)]
    for c in range(cols):
        write = rows - 1
        for r in range(rows - 1, -1, -1):
            if grid[r][c] == '#':
                out[r][c] = '#'
                write = r - 1
            elif grid[r][c] == '*':
                out[write][c] = '*'
                write -= 1
    return [''.join(row) for row in out]

For ["*.*", "...", "#.."] the result is ["...", "*..", "#.*"]. The block in the first column stops on the obstacle; the one in the last column falls to the floor.

Why it works: each column is independent. Scanning from the bottom with a write pointer drops blocks in one pass, and an obstacle resets the pointer to the cell above it. Time and output space are O(rows x cols). Test a single row, a single column, adjacent obstacles and a column with no empty cells.

Original practice problem 3: minimum daily capacity

An original teaching exercise for practising binary search on an answer.

You get a nonempty array loads of positive integers and an integer days >= 1. Process the loads in order over at most days days. A load cannot be split across days. Each day handles a contiguous run of loads whose total cannot exceed a fixed capacity. Return the smallest capacity that works.

def min_capacity(loads, days):
    lo, hi = max(loads), sum(loads)
    while lo < hi:
        mid = (lo + hi) // 2
        needed, current = 1, 0
        for x in loads:
            if current + x > mid:
                needed += 1
                current = 0
            current += x
        if needed <= days:
            hi = mid
        else:
            lo = mid + 1
    return lo

min_capacity([3, 2, 2, 4, 1, 4], 3) returns 6. We checked the three solutions in Python against independent reference implementations: 8,201 sliding-window cases, 21,198 gravity grids and 8,199 capacity cases. These are exhaustive small-input checks within the stated constraints, not Google hidden tests.

Why binary search works: a capacity that can process the loads remains feasible at every larger capacity. The lower bound is the largest load; the upper bound is their sum. With n = len(loads) and S = sum(loads), the search takes O(n log(S - max(loads) + 2)) time and O(1) extra space. Test one load, one day and more days than loads.

A 10-day preparation plan

This plan assumes you already know basic data structures and have roughly an hour a day. On day 9, reserve 70 minutes for the mock plus time to review it. The four-question mock is a training format; adapt it to your invitation when you have one.

During mocks, record the time to your first working submission and which edge cases you missed. If one problem consumes most of the session, practise leaving it with a working baseline and returning after the others.

Checklist before you start the OA

• Confirm the time limit and number of problems in your invitation email.
• Choose an available language you know well and check its editor settings in practice.
• Check your camera, screen sharing and browser if the test is proctored.
• Read all problems first and start with the one you can finish fastest.
• Write two edge-case tests before you submit each solution.
• Submit before time expires; check which submission your assessment retains.

How this differs from our general CodeSignal guide

Our CodeSignal OA guide covers CodeSignal assessments across many employers. This page focuses on Google-tagged practice entries, the limits of their attribution and three worked exercises. For a separate part of Google hiring, see our note on Google team matching.

FAQ

Does Google use CodeSignal for its OA?

Check your recruiter message. The practice catalog linked here contains Google-tagged problems, but that alone does not verify CodeSignal as the platform for your role, region or application cycle.

Is the Google OA the same as the CodeSignal GCA?

A CodeSignal link does not answer that question. Check the assessment name and ask recruiting whether it is a GCA, a custom test or a request to share an existing result.

How many questions are on the Google CodeSignal OA?

The standard GCA has four questions, but this does not establish the format of a Google invitation. Check the information page for your own question count and time limit.

Will I get the exact questions listed online?

Do not rely on an online list predicting your test. Practise explaining the constraints, selecting an algorithm and testing it on inputs you have not seen before.

Can I use AI tools during the Google OA?

The GCA rules prohibit AI assistance, including for syntax searches. For other assessments, follow their specific instructions and do not use outside tools without explicit permission. You can use AI beforehand to review practice code.