I Passed TikTok’s 2026 CodeSignal OA: Real Questions, Strategy, and Prep Plan

Aaron Zheng • 20 Jul 2026 • 20 min read

Quick Facts

The TikTok OA uses a four-question CodeSignal format for the dominant SWE and general track.

Category	Detail
Format	4 questions, ~70 minutes on the SWE/general track; one observed variant runs 75 minutes for the same question set
Assessment type	CodeSignal General Coding Assessment (GCA), TikTok's proctored version
Proctoring	Webcam, screen share, microphone, and photo ID required for the full session
Score range	0 to 600 points, roughly 150 points per question
Completion window	5 days from invite; missing it triggers a "TikTok's OA has expired" email
Score verification	1 to 3 days after submission
CodeSignal platform cooldown	1 retake per 180 days, then 2 per 180 days, then 3 per 180 days, capped at 2 attempts in any 30-day window
TikTok's own retake policy	Only your first score counts for the hiring season, regardless of what the platform cooldown allows

Use the guide by where you are in the process.

New to TikTok's process: read from the top.
Invite already arrived, with more than a week left: start at "What TikTok's CodeSignal Test Format Actually Looks Like."
Exam under 48 hours away: jump to "How to Prepare for the TikTok CodeSignal in 3 Days."
Just submitted: go straight to "What Happens After You Submit the OA."

I took the TikTok OA on CodeSignal and worked through its four-question assessment. I had heard enough about invisible apps being monitored that I chose the dual-device mode from interviewfox.ai for the real exam: the answer stayed on my phone, while CodeSignal only saw the test screen.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

That choice mattered once the clock started moving. Q3's station transitions and Q4's formatting state were the two places where I stalled, but the phone-side answer kept the laptop screen clean. The full sequence is below.

The Real Questions on My TikTok CodeSignal Test

I worked through these problems in this order on my TikTok CodeSignal test. Here is the exact logic I used for each one.

Question 1: Aligned Memory Allocation

The problem I got: I received a binary memory array, where 0 meant free and 1 meant occupied, plus a sequence of queries. [0, x] allocates x cells and [1, allocation_id] releases the cells owned by that successful allocation. Allocation checks starts 0, 8, 16, ... and takes the first in-bounds run of x zero cells. It returns the start or -1. A successful allocation gets the next ID, while a failed one does not consume an ID. Release returns the number of cells it frees.

My approach: I kept an occupied array for the binary state and a separate owner array for successful allocation IDs. That separation meant cells occupied in the initial input had no owner and could never be released by an allocation ID. For each allocation query, I built a prefix sum of occupied cells, scanned only 8-aligned starts, and checked each candidate range in constant time. On success, I marked the range occupied and stored its new ID in owner.

def process_memory(memory: list[int], queries: list[list[int]]) -> list[int]:
    occupied = memory[:]
    owner = [0] * len(memory)
    next_allocation_id = 1
    answers = []

    for operation, value in queries:
        if operation == 0:
            size = value
            prefix = [0] * (len(occupied) + 1)
            for i, cell in enumerate(occupied):
                prefix[i + 1] = prefix[i] + cell

            start = -1
            for candidate in range(0, len(occupied), 8):
                end = candidate + size
                if end <= len(occupied) and prefix[end] == prefix[candidate]:
                    start = candidate
                    break

            if start == -1:
                answers.append(-1)
                continue

            allocation_id = next_allocation_id
            next_allocation_id += 1
            for i in range(start, start + size):
                occupied[i] = 1
                owner[i] = allocation_id
            answers.append(start)

        elif operation == 1:
            allocation_id = value
            freed = 0
            if allocation_id > 0:
                for i in range(len(occupied)):
                    if owner[i] == allocation_id:
                        occupied[i] = 0
                        owner[i] = 0
                        freed += 1
            answers.append(freed)

        else:
            raise ValueError("query operation must be 0 or 1")

    return answers

Time complexity: O(qn) | Space complexity: O(n), where q is the number of queries and n is the memory size

Under the exam clock, I kept occupancy and ownership separate. That stopped release queries from touching cells that were occupied before any allocation.

Question 2: Alternating-Parity Subarrays

The problem I got: I received an integer array and had to count every contiguous subarray whose adjacent values alternate between odd and even. Every single-element subarray counted because it had no adjacent pair that could break the rule.

My approach: I tracked the length of the valid alternating run ending at each index. If the current value had different parity from the previous value, I extended that run by one. Otherwise, I reset it to one. That ending length was also the number of valid subarrays ending at the current index, so I added it to a 64-bit-capable total. Python integers handle totals beyond 64 bits without a separate type.

def count_alternating_parity_subarrays(values: list[int]) -> int:
    total = 0
    ending_run = 0

    for i, value in enumerate(values):
        if i > 0 and (value & 1) != (values[i - 1] & 1):
            ending_run += 1
        else:
            ending_run = 1
        total += ending_run

    return total

Time complexity: O(n) | Space complexity: O(1)

Under the exam clock, the ending-run recurrence gave me a direct path from the subarray definition to a short implementation.

Question 3: Drone Delivery

CodeSignal OA question 3: deterministic drone delivery simulation

The problem I got: The cargo started at position 0, and I received a target position plus drone-station positions on the same line. From the cargo's current position, I had to use the nearest station at or ahead, carry the cargo to it, then let the drone move it to min(station + 10, target). If no usable station remained, I carried the cargo to the target. The return value was only the total distance that I carried the cargo on foot.

My approach: I sorted the distinct station positions and moved one pointer forward through them. The wording said "ahead," but the sample case used a station exactly at the cargo's current position, so I treated equality as usable. I skipped stations behind the cargo, added the walking gap to the next usable station, and advanced the cargo by the drone's fixed 10-unit range. If the next station was beyond the target or no station remained, I added the final walking gap and stopped.

def cargo_distance_on_foot(target: int, stations: list[int]) -> int:
    ordered_stations = sorted(set(stations))
    cargo_position = 0
    walking_distance = 0
    station_index = 0

    while cargo_position < target:
        while (
            station_index < len(ordered_stations)
            and ordered_stations[station_index] < cargo_position
        ):
            station_index += 1

        if (
            station_index == len(ordered_stations)
            or ordered_stations[station_index] > target
        ):
            walking_distance += target - cargo_position
            break

        station = ordered_stations[station_index]
        walking_distance += station - cargo_position
        cargo_position = min(station + 10, target)
        station_index += 1

    return walking_distance

Time complexity: O(n log n) | Space complexity: O(n)

This was the first point where I got stuck during the actual test. I had to slow down.

I had ruled out relying on an app marketed as invisible before reaching this point. Those tools put the answer layer on the same laptop screen CodeSignal is recording, which is exactly the surface I wanted to keep clean.

The dual-device Coding Assistant from interviewfox.ai sent the direction to my phone instead. I could check the approach without changing the laptop screen, which stayed on the CodeSignal problem panel and editor.

That separate-device design was the practical difference at the exact moment I got stuck.

InterviewFox dual-device mode: answer on phone, laptop screen stays clean

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

Question 4: LEFT/RIGHT Newspaper Formatting

CodeSignal OA question 4: LEFT and RIGHT newspaper formatting

The problem I got: I received paragraphs, an array whose items were arrays of string portions, plus one LEFT or RIGHT value per paragraph and a content width. I had to preserve every portion's order, insert one space between adjacent portions, and greedily place complete portions on each line without splitting them. Every paragraph started on a new line. LEFT padded on the right, RIGHT padded on the left, each content line had * side borders, and the top and bottom borders contained width + 2 asterisks.

My approach: I built one paragraph at a time and tracked the current line's length before adding another portion. If the next portion would exceed the width, I emitted the current line with the paragraph's alignment and started a new line with that portion. A small helper applied the padding and side borders, while the main function added the full-width border at the beginning and end.

def format_newspaper(
    paragraphs: list[list[str]], aligns: list[str], width: int
) -> list[str]:
    border = "*" * (width + 2)
    output = [border]

    def emit(text: str, alignment: str) -> None:
        if len(text) > width:
            raise ValueError("a portion cannot fit without being split")
        if alignment == "LEFT":
            padded = text.ljust(width)
        elif alignment == "RIGHT":
            padded = text.rjust(width)
        else:
            raise ValueError("alignment must be LEFT or RIGHT")
        output.append("*" + padded + "*")

    for paragraph_index, portions in enumerate(paragraphs):
        alignment = aligns[paragraph_index]
        current_line = []
        current_length = 0

        for portion in portions:
            if len(portion) > width:
                raise ValueError("a portion cannot fit without being split")

            added_length = len(portion) if not current_line else len(portion) + 1
            if current_line and current_length + added_length > width:
                emit(" ".join(current_line), alignment)
                current_line = [portion]
                current_length = len(portion)
            else:
                current_line.append(portion)
                current_length += added_length

        emit(" ".join(current_line), alignment)

    output.append(border)
    return output

Time complexity: O(c + lw) | Space complexity: O(lw), where c is the total input character count, l is the number of output content lines, and w is width

I got stuck again on this question. I had to slow down.

TikTok's Proctoring Policy for CodeSignal

TikTok runs the CodeSignal online assessment under full proctoring. What's monitored. The test requires a webcam, shared screen, active microphone, and photo ID. Recording continues through the full 70-minute window.

Syntax lookups are allowed. I confirmed that language syntax and reference documentation remain available during the recorded session. That is a real exception to the usual assumption that every outside lookup violates proctoring rules.

A real glitch. In one proctored TikTok session, the screen zoomed in without warning. A page refresh kept the session alive. The proctoring software can glitch even when the test taker does nothing wrong.

10 Other Confirmed TikTok CodeSignal Questions

My own four questions are one data point. These 10 come from other dated candidate sessions. Together, they show that the 2026 TikTok CodeSignal pool goes well beyond any single test.

Question 1: Sum of Local Peaks

In one Aug 31, 2025, candidate session, the prompt used a sequence of 3s and 5s. Values strictly greater than both neighbors count as local peaks, and the answer is their sum. The shape is clear enough to solve directly.

def sum_local_peaks(nums: list[int]) -> int:
    total = 0
    for i in range(1, len(nums) - 1):
        if nums[i] in (3, 5) and nums[i] > nums[i - 1] and nums[i] > nums[i + 1]:
            total += nums[i]
    return total

Time complexity: O(n) | Space complexity: O(1)

Question 2: Calendar-to-Season Mapping

Another Aug 31, 2025, session involved converting a solar date into its lunar season. Exact date ranges and mapping rules are missing. There is not enough detail for working code, so I will not invent the rule set.

Question 3: Four-Battery Charging Simulation

Another Aug 31, 2025, prompt involved a capacity array such as [2, 2, 1, 5] and a recharge mechanic. The decay and recharge rules are incomplete. This remains a named topic rather than a solved problem.

Question 4: Attraction Path Reconstruction

A fourth Aug 31, 2025, prompt used an edge list such as [[1,5],[5,3],[3,2],[2,4]]. The task was to reconstruct a valid path through every connected point. The shape matches a standard method: start at the endpoint with one connection, then walk the edges.

from collections import defaultdict

def reconstruct_path(edges: list[list[int]]) -> list[int]:
    adjacency = defaultdict(list)
    degree = defaultdict(int)
    for a, b in edges:
        adjacency[a].append(b)
        adjacency[b].append(a)
        degree[a] += 1
        degree[b] += 1

    start = next(node for node, d in degree.items() if d == 1)
    path = [start]
    visited_edges = set()
    current = start
    while len(path) <= len(edges):
        moved = False
        for neighbor in adjacency[current]:
            edge = tuple(sorted((current, neighbor)))
            if edge not in visited_edges:
                visited_edges.add(edge)
                path.append(neighbor)
                current = neighbor
                moved = True
                break
        if not moved:
            break
    return path

Time complexity: O(n) | Space complexity: O(n). The available example only shows a single clean chain, so branching or disconnected inputs are outside what the prompt demonstrates.

Question 5: Bus Departure Lookup

In one Aug 26, 2025, session, the prompt used a sorted departure_times array. The task was to return minutes since the latest departure, or -1 if none had left. This is a direct binary-search lookup.

import bisect

def minutes_since_last_departure(departure_times: list[int], current_time: int) -> int:
    idx = bisect.bisect_right(departure_times, current_time) - 1
    if idx < 0:
        return -1
    return current_time - departure_times[idx]

Time complexity: O(log n) | Space complexity: O(1)

Question 6: Sequential Battery Recharge Scheduling

Another Aug 26, 2025, prompt used a different battery-charging variant. Batteries recharge strictly in index order, and no other battery can charge while one blocks the charger. Missing decay rates and rules prevent a complete solution.

Question 7: Minimum Height Difference With Gap

A third Aug 26, 2025, prompt minimized |heights[a] - heights[b]| with indices at least gap apart. The attempted sort-and-scan method degraded on sorted input. That genuine stuck point is worth preserving.

import bisect

def min_height_diff_with_gap(heights: list[int], gap: int) -> int:
    n = len(heights)
    best = float('inf')
    window = []  # sorted heights for indices already gap-eligible

    for i in range(n):
        eligible_index = i - gap
        if eligible_index >= 0:
            bisect.insort(window, heights[eligible_index])

        if window:
            pos = bisect.bisect_left(window, heights[i])
            if pos < len(window):
                best = min(best, abs(window[pos] - heights[i]))
            if pos > 0:
                best = min(best, abs(window[pos - 1] - heights[i]))

    return best if best != float('inf') else -1

Time complexity: O(n^2) worst case from the list insert step, though a balanced-tree-backed structure would bring it to O(n log n) | Space complexity: O(n)

Question 8: Multi-Source BFS Routing

A TikTok LIVE Sydney assessment listed this as its third question. Only the topic is available. Without the graph structure or starting-node rules, there is not enough detail for working code.

Question 9: Offline Query Dictionary Preprocessing

The same Sydney LIVE assessment listed this as its fourth question. Only the topic is available, without an input shape or query format. I am leaving it as a named topic rather than guessing.

Question 10: Bubble-Popping Matrix Simulation

One internship assessment used a 2D matrix where adjacent same-color cells explode and the rest fall under gravity. A second test taker received the identical question the next day, a strong recurrence signal. The mechanic matches a standard "match and clear" simulation.

def pop_bubbles(grid: list[list[int]]) -> list[list[int]]:
    rows, cols = len(grid), len(grid[0])
    to_clear = set()

    for r in range(rows):
        for c in range(cols):
            if grid[r][c] == 0:
                continue
            if c <= cols - 3 and grid[r][c] == grid[r][c + 1] == grid[r][c + 2]:
                to_clear.update({(r, c), (r, c + 1), (r, c + 2)})
            if r <= rows - 3 and grid[r][c] == grid[r + 1][c] == grid[r + 2][c]:
                to_clear.update({(r, c), (r + 1, c), (r + 2, c)})

    for r, c in to_clear:
        grid[r][c] = 0

    for c in range(cols):
        write_row = rows - 1
        for r in range(rows - 1, -1, -1):
            if grid[r][c] != 0:
                grid[write_row][c] = grid[r][c]
                write_row -= 1
        for r in range(write_row, -1, -1):
            grid[r][c] = 0

    return grid

Time complexity: O(rows × cols) | Space complexity: O(rows × cols). This covers a single clear-and-drop pass; the available detail does not show whether repeated cascading passes are required, so treat this as the core mechanic rather than the full spec.

What TikTok's CodeSignal Test Format Actually Looks Like

TikTok's dominant 2026 online assessment format is 4 questions in 70 minutes. The evidence covers seven independent sessions across several tracks. One session ran for 75 minutes with the same question count, a real variance rather than a typo.

The claim of "3 questions, 70 to 90 minutes" has no primary support in this research. The chart shows 4 questions across most roles, while the format shifts by track.

The invite gives candidates 5 days to complete the assessment. Missing that window produces a "TikTok's OA has expired" email from CodeSignal. This failure mode appears more than once in the evidence.

SWE-Track Format Runs 4 Questions in 70 Minutes

This is the format behind every score and outcome in this guide. It is also the format most TikTok software engineer candidates should expect.

Data Science Intern Format Uses a Jupyter Notebook

The Data Science Intern track uses 4 questions in a Jupyter notebook. It combines basic pandas work with a final model-building question.

External syntax lookup is unavailable on this track, so pandas and modeling syntax must come from memory. Proctoring matches the SWE track.

QA Engineer OA Focuses on Testing

QA Engineer assessments focus on testing, not general algorithms. The Toronto QA account does not list individual questions, but it establishes that this track differs from SWE.

Data Engineer Intern Matches the Standard 4-Question Format

Privacy and Security's Data Engineer Intern track also uses 4 questions. Its count matches the standard SWE format despite the different role.

How TikTok's CodeSignal Scoring Works

TikTok's CodeSignal general coding assessment score runs from 0 to 600. A high score does not guarantee an interview. The chart compiles nine dated outcomes that include both a score and a result.

Perfect Scores Still Get Rejected

At least three dated TikTok cases ended in rejection after a perfect score. The Sydney LIVE case scored 600 out of 600 and finished with time remaining, yet still received a rejection email.

Two more perfect-score cases ended without an interview, including one account that reported a 600/600 score followed by rejection. The score alone is not the full gate.

Score Verification Takes 1 to 3 Days

Score verification usually takes 1 to 3 days after submission. That timing appears independently across several cases.

One unconfirmed estimate puts TikTok's cutoff near 500 out of 600. It remains a single impression, not a published or confirmed threshold.

Cooldown Rules Cap You at 3 Attempts in 180 Days

CodeSignal applies a tiered platform cooldown. It starts at one retake per 180 days, then rises to two and three. Every tier also has a cap of two attempts within any rolling 30 days.

TikTok cases match the three-attempts-per-180-days tier. In one case, that cap blocked another attempt until January 16, 2026.

TikTok CodeSignal Exam-Day Strategy

Two contrasting cases show what happens once the clock starts. Finishing with margin to spare. The TikTok LIVE Sydney session finished all four questions with 16 of 70 minutes remaining. Its score was 600 out of 600.

When one question gets sacrificed. A separate December 2025 session took a different path. Q1 and Q2 took about 20 minutes. The test taker then banked Q4 before returning to Q3.

That separate session ended with no passing test case on Q3. Together, the two accounts show how one hard problem can control the clock.

Why Candidates Fail the TikTok CodeSignal Assessment

A 434/600 Score Breaks Down Into One Hard Zero

One complete score breakdown had clean passes on Q1 and Q2. Q3 scored zero with no tests passing, while a brute-force Q4 earned 12 out of 20. The hard zero pulled the total down more than the partial score.

Solving 3 of 4 Questions Still Isn't Enough Time

Multiple candidates solved three of four questions and lost the last one to the clock. The recurring cause was time pressure on Q3 or Q4, not a knowledge gap.

Cooldown Lockouts Block Other Companies Too

One candidate had active OA invites from TikTok and Capital One but could take neither. Earlier attempts for another company had already triggered the platform's three-attempt cooldown.

Each OA stays tied to its application email and ID, so it cannot move to another account. The "share results" option can also be unavailable when a candidate needs it.

TikTok's documented recruiting policy states: "If you've already completed the assessment for 2026 hiring season, feel free to disregard the new invitation as we will only use your first score. Do not retake the online assessment as we will not consider your new score(s)."

The test is also described as TikTok-specific, not a GCA. Other cases discuss sharing TikTok GCA scores with companies. The conflict remains unresolved.

An Invisible App Case Ended With a Cancelled Score

One candidate whose experience was shared with me used an Invisible App during a CodeSignal assessment. After the assessment, the candidate's score was cancelled.

However, the candidate asked to remain anonymous, so I am not naming the person, company, role, or test date. This is a real private account, but it is not a TikTok-specific case and does not establish the exact reason the score was cancelled.

As a result, I rejected the idea that an app is safe simply because it is marketed as invisible.

interviewfox.ai

Land offer with Safer AI Interview Assistant

Skip the risky invisible apps. Our dual-device mode keeps it simple and undetectable. You crush the interview, we handle the answers.

Get started. It's free Loved by 100,000+ candidates

Instead, interviewfox.ai sends the response to a separate phone. That separate-device workflow was the practical difference that made me choose interviewfox.ai over an Invisible App.

The case does not prove that every Invisible App user will lose a score. It does show that the word “invisible” is not a safety guarantee.

How to Prepare for the TikTok CodeSignal in 3 Days

The invite provides a 5-day completion window. Three focused prep days leave a 2-day buffer before the link expires. The plan below uses the confirmed format and recurring question categories, not generic study advice.

I also used the Prep Agent from interviewfox.ai over WhatsApp. I sent it the confirmed patterns for all four question types. It returned a personalized drill plan for memory simulation, alternating parity, station simulation, and LEFT/RIGHT formatting.

Day 1 Locks Down Format, Proctoring, and Environment

On day one, I confirmed logistics rather than solving problems. The checks covered the webcam, screen share, microphone, and photo ID. I also confirmed the syntax and reference lookup rules, so I would not second-guess them during the test.

Day 2 Drills the Recurring Problem Categories

On day two, I used the confirmed question pool instead of random problems. My core drills covered memory simulation, alternating-parity counting, station simulation, and text formatting. The wider pool added graph routing, binary search, and gap-constrained optimization.

Day 3 Runs a Timed Mock With Margin

For day three, I ran one full mock at the real 70-minute limit. My target margin was 16 minutes, with time still on the clock at the finish.

What Happens After You Submit the OA

After submission, verification timing and interview routing can vary. As the scoring section shows, even a strong score is not a guarantee.

Score Verification Takes 1 to 3 Days

As covered in the scoring section, verification usually takes 1 to 3 days. Here, it is the first post-submission checkpoint.

Some Candidates Skip the OA and Go Straight to a Phone Screen

Process routing is not uniform across every team or role. One applicant skipped the OA and went directly to a phone screen. Applicants should not assume every process starts with the assessment.

TikTok Only Uses Your First CodeSignal Score

The email TikTok sends. TikTok uses identical recruiting language in two dated cases: "If you've already completed the assessment for 2026 hiring season, feel free to disregard the new invitation as we will only use your first score. Do not retake the online assessment as we will not consider your new score(s)."

The independent match makes this a documented policy, not a single candidate's interpretation.

This rule differs from CodeSignal's platform cooldown. The cooldown blocks retakes until a set window passes, but it allows valid scores to be shared with another company.

TikTok adds a stricter company rule. Even when CodeSignal permits another attempt, TikTok only considers the first score from that hiring season. A better second score does not replace it.

The platform cooldown and company policy form two separate layers. Their interaction explains why candidates remain confused about whether a retake has any value.

FAQ

What are the TikTok CodeSignal questions in 2026?

The confirmed 2026 pool includes at least 14 distinct questions across multiple accounts. My four-question session covers memory simulation, alternating parity, drone routing, and text formatting. The 10 additional questions extend that pool into graph routing, binary search, matrix simulation, and scheduling.

What's a good TikTok CodeSignal general coding assessment score?

There is no official published cutoff. One unconfirmed estimate puts the bar near 500 out of 600. At least three perfect scores still ended without an interview, so a high number is not a reliable predictor.

What is TikTok's CodeSignal pass rate?

TikTok doesn't publish a pass rate for its CodeSignal assessment. The available data points to a real gap between passing the exam and advancing afterward, since multiple perfect-score candidates were still rejected post-OA.

How long is the TikTok CodeSignal retake cooldown?

CodeSignal's cooldown has tiers of one, two, then three retakes per 180 days. Every tier is capped at two attempts within any rolling 30 days.

TikTok cases match the three-retake tier. Separately, TikTok only counts the first score for the hiring season, regardless of CodeSignal eligibility.

What happens if you failed or got rejected after the TikTok CodeSignal?

A failed or low score typically ends the process without an interview. A passing or perfect score does not guarantee one either. Several perfect-score cases still ended in rejection.

Is the TikTok online assessment in 2026 still on CodeSignal?

Yes. Dated evidence through March 2026 confirms that TikTok still runs this assessment through CodeSignal's General Coding Assessment platform.

Can I use an AI tool or invisible app during the TikTok CodeSignal OA?

One anonymous candidate used an Invisible App during a CodeSignal assessment and later had the score cancelled. The private account does not identify the company or explain the exact reason the score was cancelled.

interviewfox.ai sends the response to a separate phone. That separate-device workflow is why I chose it over an Invisible App for preparation.

The case is not TikTok-specific, so I would not treat it as proof of TikTok's detection process.

Quick Facts

The Real Questions on My TikTok CodeSignal Test

Question 1: Aligned Memory Allocation

Question 2: Alternating-Parity Subarrays

Question 3: Drone Delivery

Question 4: LEFT/RIGHT Newspaper Formatting

TikTok's Proctoring Policy for CodeSignal

10 Other Confirmed TikTok CodeSignal Questions

Question 1: Sum of Local Peaks

Question 2: Calendar-to-Season Mapping

Question 3: Four-Battery Charging Simulation

Question 4: Attraction Path Reconstruction

Question 5: Bus Departure Lookup

Question 6: Sequential Battery Recharge Scheduling

Question 7: Minimum Height Difference With Gap

Question 8: Multi-Source BFS Routing

Question 9: Offline Query Dictionary Preprocessing

Question 10: Bubble-Popping Matrix Simulation

What TikTok's CodeSignal Test Format Actually Looks Like

SWE-Track Format Runs 4 Questions in 70 Minutes

Data Science Intern Format Uses a Jupyter Notebook

QA Engineer OA Focuses on Testing

Data Engineer Intern Matches the Standard 4-Question Format

How TikTok's CodeSignal Scoring Works

Perfect Scores Still Get Rejected

Score Verification Takes 1 to 3 Days

Cooldown Rules Cap You at 3 Attempts in 180 Days

TikTok CodeSignal Exam-Day Strategy

Why Candidates Fail the TikTok CodeSignal Assessment

A 434/600 Score Breaks Down Into One Hard Zero

Solving 3 of 4 Questions Still Isn't Enough Time

Cooldown Lockouts Block Other Companies Too

TikTok's Score-Sharing Policy Is Genuinely Unclear

An Invisible App Case Ended With a Cancelled Score

How to Prepare for the TikTok CodeSignal in 3 Days

Day 1 Locks Down Format, Proctoring, and Environment

Day 2 Drills the Recurring Problem Categories

Day 3 Runs a Timed Mock With Margin

What Happens After You Submit the OA

Score Verification Takes 1 to 3 Days

Some Candidates Skip the OA and Go Straight to a Phone Screen

TikTok Only Uses Your First CodeSignal Score

FAQ

What are the TikTok CodeSignal questions in 2026?

What's a good TikTok CodeSignal general coding assessment score?

What is TikTok's CodeSignal pass rate?

How long is the TikTok CodeSignal retake cooldown?

What happens if you failed or got rejected after the TikTok CodeSignal?

Is the TikTok online assessment in 2026 still on CodeSignal?

Can I use an AI tool or invisible app during the TikTok CodeSignal OA?

Sources

The Real Questions on My TikTok CodeSignal Test

TikTok's Proctoring Policy for CodeSignal

10 Other Confirmed TikTok CodeSignal Questions

What TikTok's CodeSignal Test Format Actually Looks Like

How TikTok's CodeSignal Scoring Works

TikTok CodeSignal Exam-Day Strategy

Why Candidates Fail the TikTok CodeSignal Assessment

How to Prepare for the TikTok CodeSignal in 3 Days

What Happens After You Submit the OA

TikTok Only Uses Your First CodeSignal Score