How I Took the TikTok HackerRank in 2026: Real Questions and a 3-Day Prep Plan

Quick Facts

I took the TikTok HackerRank assessment in 2026 for a university graduate software engineering role. The paper ran six items in 120 minutes, one attempt, and I submitted all six with question five still failing hidden cases. What follows is the whole paper, question by question, and how I prepared for it.

Question five asked for every path from (0, 0) to (n, m), moving right and up. My recursion died on the large cases and cost me 22 minutes. I used an AI interview assistant to check the recurrence, and it pointed at a bottom-up table. The rewrite took 12 more minutes, and the full version is below.

Before my test, I went through every TikTok HackerRank post from the past two years on Reddit, LeetCode Discuss, and Teamblind. What I found tracks closely with what I experienced. The rest of this names the specific traps: timing out with a correct algorithm, getting recorded by proctoring nobody mentions, and being rejected after a clean score.

The Real Questions on My TikTok HackerRank Test

I sat TikTok's university graduate assessment on HackerRank: six items, 120 minutes, one attempt. It was not a pure coding paper, and that is the part I had not prepared for.

Two of the six never asked me to write a line of code. Here is exactly what I got, in the order the test served it.

Question 1: Java Garbage Collection

The problem I got: The paper opened with a two-part multiple choice item instead of an editor. Part one asked what Java garbage collection actually does. The options were: it reclaims heap memory holding objects nothing can reach any more, it closes open files and sockets, it clears the call stack after a method returns, or it runs on a fixed interval set by JVM flags.

My approach: I read all four before picking one, because three of them describe real things that happen in a JVM, just not things the collector is responsible for. Stack frames pop on their own. File handles need an explicit close. Collection timing is deliberately not guaranteed, which rules out the interval option and leaves reachability on the heap.

Chosen answer: it reclaims heap memory used by objects that are no longer reachable.

Why:
- GC decides by reachability from live references, not by scope or by a timer.
- Stack frames are popped by the JVM when a method returns, with no collector involved.
- Files and sockets are OS resources; they need close() or try-with-resources.
- System.gc() is a request, not a command, so nothing runs on a promised schedule.

Answer: heap reclamation for unreachable objects | Time spent: about 3 minutes

I answered it fast and felt good about the start, which turned out to be the wrong signal to take from an opening question.

Question 2: HTTP Method for Collections

The problem I got: Part two of the same item switched to HTTP. It asked which method operates on a collection of resources rather than on one member inside it, and gave me GET, POST, PUT and DELETE.

My approach: GET was the tempting wrong answer, since you can obviously read /videos as a whole. The question was about which method treats the collection itself as the target it acts on. PUT and DELETE both address a member you already know the URI for, like /videos/8812. POST is the one sent to /videos so the collection can create a new member under it and hand back the new URI.

Chosen answer: POST

POST   /videos      -> acts on the collection, creates a new member
GET    /videos/8812 -> reads one member (GET also reads collections, but is not
                       collection-specific)
PUT    /videos/8812 -> replaces one known member
DELETE /videos/8812 -> removes one known member

Answer: POST | Time spent: about 2 minutes

Five minutes gone, two items down, and I still had not seen the editor. That skewed my sense of pace for the rest of the sitting.

Question 3: SQL Aggregation Query

The problem I got: The SQL item handed me two tables. creators(creator_id, region, joined_on) and videos(video_id, creator_id, views, posted_on). I had to return every creator in a given region who posted at least three videos in the last 30 days, along with their total views, ordered from highest views down, with ties broken by creator_id ascending.

My approach: The whole item turns on which filter goes where. Region and date cut individual rows, so they belong in WHERE and run before grouping. The "at least three videos" test is a property of the group, so it only works in HAVING. I counted video_id rather than * out of habit, and I wrote the tie-break exactly as stated, because HackerRank compares my output row by row against theirs.

SELECT c.creator_id,
       SUM(v.views) AS total_views
FROM creators c
JOIN videos v ON v.creator_id = c.creator_id
WHERE c.region = 'SG'
  AND v.posted_on >= DATE_SUB(CURRENT_DATE, INTERVAL 30 DAY)
GROUP BY c.creator_id
HAVING COUNT(v.video_id) >= 3
ORDER BY total_views DESC, c.creator_id ASC;

Time complexity: O(n log n) for the join and the sort | Space complexity: O(k) for the grouped rows

This took about 11 minutes, most of it spent re-reading the ordering requirement rather than writing the query. It was the last item I finished without stress.

Question 4: Minimum Sum, Unique Digits

The problem I got: I was given an array of integers and had to make every value in it distinct. The only move allowed was incrementing a value by one, as many times as needed, and I had to return the smallest sum the finished array could have. For [1, 2, 2] the answer is 6, because the duplicate has to climb to 3.

My approach: My first instinct was a hash set: walk the array, and when a value is already taken, bump it until it lands somewhere free. I sketched two lines of that and stopped, because on an array full of repeats the inner loop keeps rechecking the same crowded values. Sorting removes the problem entirely. Once the array is in order, each value only has to clear the one before it, so the new value is max(nums[i], prev + 1) and the sum stays minimal by construction.

import java.util.Arrays;
import java.util.Scanner;

public class MinUniqueSum {

    static long minUniqueSum(int[] nums) {
        if (nums.length == 0) return 0;
        Arrays.sort(nums);
        long sum = nums[0];
        int prev = nums[0];
        for (int i = 1; i < nums.length; i++) {
            int value = Math.max(nums[i], prev + 1);
            sum += value;
            prev = value;
        }
        return sum;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] nums = new int[n];
        for (int i = 0; i < n; i++) {
            nums[i] = sc.nextInt();
        }
        System.out.println(minUniqueSum(nums));
    }
}

Time complexity: O(n log n) | Space complexity: O(1) beyond the input array

I used the long return type after noticing how large the sample values were, which saved me an overflow I would not have caught. Fifteen minutes, all visible cases green, and I went into the fifth item thinking I was ahead of the clock.

Question 5: Grid Paths, Right and Up

The problem I got: Count every path from (0, 0) to (n, m) on a grid where each step moves right or up. Both n and m arrived on a single input line, and the expected output was one number.

My approach: I read "up" and stalled, because every version of this I had practised moves right and down from the top left corner. I worked a 2 by 2 case by hand and confirmed the recurrence does not change, since right and up each raise one coordinate by exactly one. Then I wrote the obvious recursion, paths(n, m) = paths(n - 1, m) + paths(n, m - 1), and watched it die on the larger cases. The bottom-up table computes each cell once and reuses it.

import java.util.Scanner;

public class GridPaths {

    static long countPaths(int n, int m) {
        long[][] dp = new long[n + 1][m + 1];
        for (int i = 0; i <= n; i++) {
            dp[i][0] = 1;
        }
        for (int j = 0; j <= m; j++) {
            dp[0][j] = 1;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[n][m];
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        System.out.println(countPaths(n, m));
    }
}

Time complexity: O(n × m) | Space complexity: O(n × m), and I noticed a single rolling row would bring it to O(m) but left it alone

I lost 22 minutes to the recursive version before I accepted it was never going to clear the time limit. The rewrite cost 12 more, and the submission still failed several hidden cases. I moved to the last question with almost a third of the exam spent on one problem and no full pass to show for it.

Somewhere in that 22-minute stretch I checked the recurrence rather than keep guessing at it. I had already ruled out a desktop overlay, because the answer would have been drawn on the same screen the assessment was monitoring behind a basic rendering trick, and I did not want that uncertainty on a one-attempt paper. What I used instead was a dual device AI interview assistant: a keyboard shortcut auto-captured the question off my laptop and pushed the answer to my phone, a separate device outside the platform's screenshot monitoring. The recurrence came back confirmed with the bottom-up table as the fix, and the laptop screen stayed on the HackerRank editor the whole time, unchanged.

Question 6: Largest Follower Network

The problem I got: The final item was a social graph, and the input came in raw. First line: how many datasets. Then for each dataset, a line with the connection count, then that many lines of two names, like Adam Becka and Becka Chris. For every dataset I had to print the size of the largest connected network of people.

My approach: There was no function signature to fill in, so parsing the dataset header was on me before any graph work started. On the modelling question I made a decision quickly: a follow reads like an arrow, but "network" here means everyone linked together, so I treated every edge as undirected. Union-find with union by size gives me the largest component for free, because I can read the root's size right after each merge instead of doing a second sweep at the end.

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class LargestNetwork {

    static Map<String, String> parent = new HashMap<>();
    static Map<String, Integer> size = new HashMap<>();

    static String find(String x) {
        parent.putIfAbsent(x, x);
        size.putIfAbsent(x, 1);
        String root = x;
        while (!root.equals(parent.get(root))) {
            root = parent.get(root);
        }
        while (!x.equals(root)) {
            String next = parent.get(x);
            parent.put(x, root);
            x = next;
        }
        return root;
    }

    static int union(String a, String b) {
        String rootA = find(a);
        String rootB = find(b);
        if (rootA.equals(rootB)) {
            return size.get(rootA);
        }
        if (size.get(rootA) < size.get(rootB)) {
            String swap = rootA;
            rootA = rootB;
            rootB = swap;
        }
        parent.put(rootB, rootA);
        size.put(rootA, size.get(rootA) + size.get(rootB));
        return size.get(rootA);
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int datasets = sc.nextInt();
        StringBuilder out = new StringBuilder();
        for (int d = 0; d < datasets; d++) {
            parent = new HashMap<>();
            size = new HashMap<>();
            int connections = sc.nextInt();
            int largest = 0;
            for (int i = 0; i < connections; i++) {
                String a = sc.next();
                String b = sc.next();
                largest = Math.max(largest, union(a, b));
            }
            out.append(largest).append('\n');
        }
        System.out.print(out);
    }
}

Time complexity: O(E α(N)) per dataset, effectively linear | Space complexity: O(N) for the two maps

Reading the dataset header correctly cost me about six minutes before I wrote any graph code, which is time no LeetCode session had ever charged me. I submitted with just under six minutes left, hands shaking, with no way to see how many hidden cases I had cleared.

That was an October paper, and TikTok rotates its sets, so the exact six will not be the six you get. The composition is what holds: two fundamentals MCQs, one SQL query, two LeetCode-level problems, and one hard graph or DP item sitting at the end where you have the least time for it.

TikTok's Proctoring Policy for HackerRank

Parts of my sitting were recorded no matter what TikTok chose to turn on. That splits the answer three ways. There is what the platform always records, what TikTok adds on top, and what nobody outside TikTok can confirm.

Recorded by default. Since HackerRank's October 2025 release, copy-paste tracking and tab-switch detection run on every test with no setup by the employer. Pasted content lands in the candidate's own test report, and the recruiter view carries a Copy-Paste Frequency column beside Out of Window Duration and Number of Window Exits. I have not mapped the full recording scope here, but I broke it down separately in HackerRank's screen recording during the OA.

That default flip is the part most guides still get wrong. They describe tab proctoring as an option a company switches on, which stopped being true in October 2025.

One webcam report. A candidate on the Summer 2024 cycle had to turn the webcam on before starting. That is the only first-hand webcam account on the HackerRank track, and it is two cycles old. I would not treat it as settled 2026 policy.

Candidates were still asking each other a year later whether the test is camera-proctored at all. That disagreement is exactly what a per-requisition setup looks like from the outside.

Three modes above that. Secure Mode forces fullscreen, blocks copy-paste and second monitors, and alerts on a tab switch. Proctor Mode adds AI screenshot analysis, plagiarism detection and webcam anomaly detection. Desktop App Mode watches at the operating system level. Reading HackerRank's copy-paste detection shows what actually trips a flag, which matters because TikTok inherits HackerRank's full default monitoring set.

Proctor Mode has to be enabled at both the company level and the test level. It locks once candidates start. The January 2026 release added automatic flagging of phones and tablets in the webcam feed.

Nobody can confirm more. Nothing I found describes fullscreen lockdown on a TikTok test. I saw no mention of a blocked second monitor or a desktop app either. So read that ladder as what the platform sells, not as what TikTok bought.

What a flag does. Integrity signals go to the employer as material for a human to review. No automatic rejection exists in the documentation. What TikTok then does with a flagged report is written down nowhere, by TikTok or by any candidate. I am not going to guess at it.

What TikTok's HackerRank Test Format Actually Looks Like

The TikTok HackerRank questions are not all coding questions. That single fact explains most of the contradictory format numbers in the search results. Once the HackerRank reports are separated from the CodeSignal ones they cluster tightly, as the chart below shows.

Two exams, one company. TikTok has not migrated off HackerRank. A current TikTok graduate requisition still states that candidates who pass resume evaluation take the technical online assessment in HackerRank.

CodeSignal covers a different slice, mostly US campus and general-hire new grad software engineering. The split is not cleanly regional either: an APAC graduate backend role got CodeSignal while neighbouring APAC requisitions name HackerRank. The Online Assessment clause in the posting itself is the only reliable predictor.

The mixed paper. MCQ plus SQL plus DSA in one sitting is the sharpest difference between the two tracks. The same composition shows up in three independent places. It is operating-system and Java fundamentals as multiple choice, one SQL query, then the coding problems.

That matters for pacing more than for difficulty. A candidate who budgets the full window for algorithms meets the SQL and MCQ blocks late. By then there is no time left to be careful.

Three to five days. The invite link runs 3 to 5 days, not the 7 that most companies give. The freshest report of it is a 3-day window. There is one attempt, so there is no version of this where a bad sitting gets retaken.

The invite also carries a named assessment category. One new grad's invite said Basic Problem Solving, which is HackerRank's own difficulty label rather than a TikTok phrase.

A window, not a link. Two candidates had a test that opened on a set date, not when they clicked. Question sets rotated weekly. Both accounts are thin and one is phrased as a question. The pattern may hand a candidate a choice of sitting. But I treat it as unconfirmed for 2026, not as settled behaviour.

The STDIN tax. Input can arrive as a raw stream rather than a function signature. My sixth question opened with a dataset count, then a connection count, then the edge lines. Parsing that header cost about six minutes before I wrote any graph code.

No LeetCode session had ever charged me for that. It is pure plumbing with zero algorithmic value, and it comes out of the same 120 minutes as the algorithms.

How TikTok's HackerRank Scoring Works

There is no score to aim at on this exam. That is a finding rather than a gap in my notes. The passed-case counts I collected do not predict the outcome in either direction.

Hidden cases decide it. Some test cases are hidden, so the visible ones going green means very little. My grid-paths rewrite cleared everything I could see and still failed hidden cases on submission.

The pattern repeats across the track. One candidate described the coding questions as doable. That same candidate called the test cases tricky enough that everything had to be optimized. Another tried five different approaches on one item and failed the same hidden cases every time.

Passed cases, not points. This track reports raw counts. Candidates cite 7 of 12, 3 of 5, or half the cases on the last question. The 0 to 600 scale belongs to TikTok's CodeSignal exam and does not apply here. A number in that range means the candidate sat a different test.

No cutoff exists. TikTok has never published a pass mark for the HackerRank track. No candidate has ever reported one. The percentages that circulate for this question come from pages that label their own figures as anecdotal.

The checker has slipped. An output checker defect marked 101 as wrong when the expected answer was 101.0. It happened once in 2021 and again in 2023. I have no evidence it is still live. I mention it only because matching the stated output format exactly costs nothing.

Why Candidates Fail the TikTok HackerRank Assessment

I went into the TikTok HackerRank Reddit history looking for people who failed. The same six causes kept coming back. Only one of them is about not knowing the algorithm.

Timing out while correct. The cleanest example runs across two questions on one paper. A correctly shaped grid-paths solution passed 7 of 12 cases. The equally correct graph solution passed 3 of 5. Both timed out rather than returning wrong answers.

That is the dominant failure mode on this exam. Practising to "solved" instead of "solved at scale" trains the wrong finish line. The hidden cases are sized to punish the slow version of a right idea.

Modelling it wrong. On the same paper, a candidate modelled a follow-relationship problem as a directed graph. It needed an undirected one. The solution passed 3 of 5 cases, and the candidate worked out why afterwards. Nothing about the code was broken. The model of the problem was.

Minutes lost to parsing. That final question arrived as raw STDIN. It had to be decoded by hand with a scanner before any graph work started. Anyone whose practice is entirely LeetCode has never parsed a dataset header and pays for it in exam minutes.

Six items, one clock. The New Grad 2024 paper ran roughly 120 minutes. It held two operating-system questions, one SQL item, two LeetCode-level problems and one hard problem. One frontend intern finished five of six and got half the cases on the last one. That is what running out of clock looks like on a mixed paper.

Passing and still rejected. One candidate passed every test case and was rejected. Another passed all of them with relevant experience on the resume and was rejected too. In the other direction, one candidate cleared under half the cases on question one and none on the rest. That candidate got an interview.

The OA is a filter inside a wider funnel, not the decision itself. A clean score buys a place in the next pile and nothing more.

AI tools inside the recording. HackerRank tested an invisible AI assistant on its own platform in March 2025. That controlled run flagged it on all three questions, at a confidence above 0.99. The same run scored 25 percent overall. It solved only the basic problem-solving item and failed the intermediate coding question and the SQL question outright.

Two details from that run matter more than the headline. Scoring well raises the flag risk rather than lowering it. Questions scored zero are exempt from flagging in the first place. And the overlay was not invisible on macOS at all.

No TikTok candidate has publicly described being flagged for AI-tool use. I am not going to pretend a named case exists. The exposure is structural instead of anecdotal.

Copy-paste and tab-switch have been recorded by default since October 2025. Code playback can pinpoint the moment an external solution was referenced. The detection side ships a release every few months, and HackerRank markets that detection at 93 percent accuracy, which is a vendor number and reads like one.

The structural part is worth stating plainly. A desktop overlay or invisible-app tool renders the AI's answer onto your own computer screen. That is the same screen the proctoring software is watching. The hiding is an OS-layer rendering trick.

It keeps the window out of visible view while the window is still on-screen. That is not a claim it gets caught on any given sitting. It only says the answer sits inside the monitored surface. The concealment is basic, and the monitoring side keeps adding capabilities. So the risk is not a fixed quantity you can price once.

InterviewFox is built the other way around. The answer goes to the phone. That is a physically separate device, one no screenshot or session recording can reach by design. That is why the exposure question does not apply to it in the same form.

How to Prepare for the TikTok HackerRank in 3 Days

My invite gave me three days. The window runs 3 to 5 days depending on the requisition, and I planned for the short end. A reader who plans for five and gets three has no recovery path. The reverse just leaves slack.

Only the last of those days went to algorithms, as the chart below shows. That is deliberate, and it comes from what actually sinks people on this paper.

Day 1, TikTok's Own Practice Set and the STDIN Harness

TikTok ships its own HackerRank practice set with the invite, and it is harder than the word "practice" suggests. I worked it end to end inside the HackerRank editor before touching anything else, because it is the only material that shares the platform, the input harness and the question style with the real paper.

Then I spent the rest of day 1 on the harness itself. My sixth question arrived as a raw stream, a dataset count, then a connection count, then the edges, and reading that header correctly took about six minutes of live exam time.

So I solved two problems that read a multi-line dataset header from stdin and print to stdout in the exact expected format. Nothing algorithmic, purely the plumbing that LeetCode's function signatures hide.

Day 1 was done when every problem in the supplied set was submitted with the visible cases passing, no local IDE open at any point, and a dataset header parsed correctly on the first submission.

I skipped broad LeetCode tag grinding and system design completely. The confirmed paper is 4 to 6 items of MCQ, SQL and DSA in 90 to 120 minutes, and no HackerRank-tagged TikTok report has ever contained a system design component.

I also skipped CodeSignal preparation and the 0 to 600 score model. That is a different TikTok exam, and this track reports raw passed cases with no published cutoff, so scoring strategy built for the other test buys nothing here.

Day 2, The OS, HTTP and SQL Half of the Paper

Half of a six-item paper can be non-coding. The New Grad 2024 configuration was two operating-system questions and one SQL item against three coding problems, and my own paper opened with Java garbage collection and an HTTP method question before the editor appeared at all.

So day 2 went entirely to that half. Memory management, garbage collection, processes and threads on the OS side, and HTTP verb semantics against resource collections on the API side.

For SQL I wrote joins, aggregations and window functions inside HackerRank's own SQL environment rather than a local client. The editor behaves differently, and output is compared row by row against theirs.

There is a second reason not to leave this half until last. In HackerRank's own controlled test, an AI assistant failed the SQL question outright, which makes the non-DSA half the least outsourceable part of the exam.

Day 2 was done when I could answer an OS question and an HTTP method question with no lookup, and get a multi-table aggregation query running on the first submission.

Day 3, Optimize for Hidden Cases, Then One 120-Minute Run

This exam does not fail people for wrong approaches, it fails them for slow ones. My own grid-paths recurrence was correct on paper and still burned 22 minutes as a recursion that was never going to clear the limit.

So day 3 was not new problems. I re-ran the recurring shapes at large input sizes and fixed complexity instead of logic: grid paths moving right and up, connected components in an undirected graph, digit manipulation under an increment-only rule, interval merging, parenthesis validity, and a Plus One style digit problem.

Those shapes come from TikTok HackerRank papers dated October 2022 and December 2020. I drilled them as shapes and never as a question list, because TikTok rotates its sets and the exact problems do not survive.

Working out the order to drill them in took less time than I expected, because I sent the confirmed TikTok question patterns to the Prep Agent from InterviewFox over WhatsApp and got back a drill plan and a pacing strategy built around them. It ran alongside the practice set and the timed simulation rather than replacing either, and SMS works the same way if WhatsApp is not an option.

The last block of the day was one uninterrupted 120-minute sitting covering MCQ, SQL and DSA in a single run, webcam on, one monitor, no tab switching. There is one attempt at the real thing, so the simulation is the only rehearsal that exists.

Day 3 was done when I stated the complexity of each solution before submitting and passed the largest available case. The simulation only counted if I finished inside 120 minutes with the SQL and MCQ items answered rather than left to the end.

What Happens After You Submit the OA

The wait after submitting has no reliable length, and every specific number in circulation is somebody's guess.

No reliable wait. One candidate was still waiting more than a month after sitting the test, with no response of any kind. Candidates keep asking each other how long it takes and nobody produces a consistent answer, while another applicant from the same cycle had already moved on to the next round.

Another HackerRank link. The round after the OA runs on the same platform. One manager loop was a 45-minute HackerRank session in October 2025, and a software engineering track was told the next step is a one-hour HackerRank interview with an SDE.

That session is live coding with someone watching, not a timed batch of items. The platform is the only thing the two rounds have in common.

Clean scores get rejected. One candidate scored 600 out of 600 and was rejected without an interview, on TikTok's CodeSignal track rather than this one. It is evidence about the funnel and not about this exam, and it points the same way the HackerRank score data does.

One attempt, no cooldown. There is one attempt at the assessment. How long a rejected applicant has to wait before reapplying is not documented by TikTok anywhere I could find, and the six-month figure that circulates has no source attached.

FAQ

Is TikTok HackerRank proctored in 2026?

Partly, and the automatic part matters most. Copy-paste tracking and tab-switch detection run by default on every HackerRank test created since October 2025. One candidate also had to turn the webcam on, though that account comes from the Summer 2024 cycle. Which integrity mode TikTok selects is not verifiable from outside, and no source documents what a flag then does to an application.

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

Desktop overlay and invisible-app tools put the AI answer on your own computer screen, concealed by a basic OS-layer trick. The answer stays inside the surface the proctoring watches, the hiding is thin, and HackerRank keeps shipping new detection capabilities, which means the risk is not fixed.

InterviewFox works differently: it pushes the answer to your phone, a physically separate device that no screenshot, session recording, or screen monitoring can reach by design. The laptop screen stays on the exam editor, unchanged. If you use AI assistance during the OA, that dual-device architecture is what removes the answer from your screen entirely.

Are the TikTok HackerRank questions 2025 threads still accurate for 2026?

The structure is accurate, the question list is not. Every named question tied to a HackerRank-tagged TikTok paper dates from 2020 to 2022, and TikTok rotates its sets. What holds is the composition: fundamentals as multiple choice, one SQL item, then the coding problems. TikTok's own 2026 graduate postings still route candidates to HackerRank, so the platform has not changed either.

Are the HackerRank TikTok questions the same as the CodeSignal ones?

No. These are two different TikTok exams with different formats and different scoring. HackerRank's paper mixes MCQ, SQL and DSA across 4 to 6 items and reports raw passed test cases. CodeSignal's is 4 coding problems in 70 minutes on a 0 to 600 scale. The Online Assessment clause in the job posting names which one arrives.

Are the HackerRank TikTok interview questions after the OA different?

Yes, though the platform stays the same. The round after the OA is another HackerRank link, reported at 45 minutes on one manager loop and an hour with an SDE on a software engineering track. That session is live coding with an interviewer present, not a batch of items against a clock. Preparing for it with the OA question set is the wrong drill.

What is the pass rate for the TikTok HackerRank test?

Nobody knows, and no circulating number is sourced. TikTok has never published a cutoff for this track and no candidate has reported one. The score-to-outcome pairs that do exist run both ways: full marks followed by a rejection, and roughly ten percent correct followed by an onsite. Any percentage offered as the pass rate is invented.

How long does it take to hear back after the TikTok HackerRank OA?

There is no reliable number. One candidate had heard nothing more than a month after sitting it. Another applicant from the same cycle had already moved to the next round. The honest answer is days to over a month, with no visible pattern to plan around.