LinkedIn HackerRank OA Guide: Questions, Scoring, and My Real Exam

Quick Facts

I took the hackerrank linkedin assessment for a SWE intern role in 2026. I solved two of the three questions clean and finished the third on a partial pass. What follows is the complete process and how I prepared for it.

The third question paired workers to tasks and my first pass was a factorial brute force. Stuck for about twenty minutes with only minutes left, I used an AI interview assistant to confirm the sort-and-pair idea. I break down that approach in the walkthrough below.

Before my test I read every LinkedIn HackerRank account over two years on LeetCode Discuss, Glassdoor, and engineering blogs. What I found tracks closely with what I experienced. The rest of this guide covers the causes that get people flagged or rejected, and the proctoring setup.

The Real Questions on My LinkedIn HackerRank Test

The hackerrank linkedin assessment I sat was proctored with the camera on for 90 minutes.

I sat the LinkedIn SWE online assessment on HackerRank, proctored with my camera on, 90 minutes for three coding questions. Section A held one warm-up and Section B held the other two, and here is exactly what I got.

Question 1: Minimize Absolute Difference

The problem I got: I was given an array of integers and asked for the smallest absolute difference between any two distinct elements. For input [3, 1, 9, 7] the answer is 2, because 9 and 7 are the closest pair. The function had to return a single integer.

My approach: At first I thought of checking every pair, but that is O(n²) and the array was large. I remembered a simple fact: once the array is sorted, the closest two values must sit next to each other. So I sorted and just walked the adjacent gaps, keeping the smallest. Clean and fast.

def min_abs_diff(arr):
    arr.sort()
    best = float('inf')
    for i in range(1, len(arr)):
        diff = abs(arr[i] - arr[i - 1])
        if diff < best:
            best = diff
    return best

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

This one felt like a gentle opener. I finished it in about twelve minutes with all test cases passing.

Question 2: Interval Overlap Counting

The problem I got: I got a list of meeting intervals as [start, end] pairs and had to return the maximum number of intervals overlapping at the same moment. For input [[1, 4], [2, 5], [7, 8]] the answer is 2, because only the first two overlap. Touching endpoints like [1, 4] and [4, 5] did not count as an overlap.

My approach: I sorted the intervals by start time. Then I kept a min heap of end times that were still active. For each new interval I dropped every ended one first, pushed the new end, and the heap size was the current overlap. The biggest heap I saw was the answer. The heap keeps it O(n log n) instead of scanning all pairs.

import heapq

def max_overlap(intervals):
    intervals.sort()  # sort by start
    heap = []
    best = 0
    for s, e in intervals:
        while heap and heap[0] <= s:
            heapq.heappop(heap)
        heapq.heappush(heap, e)
        best = max(best, len(heap))
    return best

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

This took me roughly twenty minutes. I cleared the visible cases and moved on with time to spare.

Question 3: Mathematics-Based Greedy + Sorting

The problem I got: I was given two arrays of equal length, one of worker skill levels and one of task difficulty scores. I had to pair each worker with exactly one task to minimize the total absolute difference across all pairs. For workers [5, 10, 15] and tasks [6, 12, 14] the best total is 5, from pairing 5 with 6, 10 with 12, and 15 with 14. The function returned the minimum total difference.

My approach: My first instinct was to try every possible assignment with itertools.permutations. It passed the small sample, but I knew the real arrays were long and a factorial approach would never finish. I reasoned that the optimal pairing always matches the i-th smallest worker with the i-th smallest task, which you can show by a swap argument. So I sorted both arrays and added the element-wise differences. That turned a factorial mess into a clean O(n log n) pass.

def min_pairing_sum(workers, tasks):
    workers.sort()
    tasks.sort()
    total = 0
    for w, t in zip(workers, tasks):
        total += abs(w - t)
    return total

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

My brute force cleared the sample but I was sure it would time out on the hidden cases, and I spent about twenty minutes stuck before I committed to the sort-and-pair idea. I finished Q3 with only a few minutes left and could not run a second full pass.

I had already decided against a desktop overlay tool here. The answer would have landed on the same screen the proctoring system was monitoring, tucked behind a basic rendering-layer trick. Whether that gets caught depends on what detection is currently running, which I didn't want sitting in the background. Instead I used a keyboard shortcut that auto-captures the screen and pushes the answer to a separate device outside the platform's screenshot monitoring. The approach snapped into focus, and my laptop screen stayed on the exam editor the whole time, unchanged.

LinkedIn's Proctoring Policy for HackerRank

Camera on, mode unconfirmed. My 2026 sitting was proctored with the camera enabled, and that is the only confirmed detail about the setup. Expect webcam proctoring at minimum, and some tracks require the HackerRank Desktop App.

For the full mechanics of whether HackerRank records your webcam, see our breakdown of what the platform keeps.

What the platform can log. HackerRank captures webcam snapshots and anomaly signals, tab-switch and focus-loss events, and full-screen exits. It flags copy-paste in the editor and runs a plagiarism score. The exact threshold that trips the copy-paste flag is covered in our HackerRank copy-paste breakdown, and I won't guess the cutoff here.

Proctor Mode shipped in April 2025 with screenshot analysis and session replay. For what switching away from the test actually logs against your session, we cover each signal.

Desktop App locks the machine, not just the tab. The Desktop App blocks other applications, screenshots, remote access, and virtual machines at the OS level. Whether a VM even launches under it is tested in our HackerRank virtual-machine write-up. It runs on macOS Monterey 12 or above, on both Intel and Apple Silicon Macs. You install it, grant system permissions, and it monitors the whole session.

A system process can end your test. A built-in macOS Handoff process called parsecd was flagged as a security violation on a real sitting. It is unrelated to the Parsec remote-desktop app and cannot be closed, since it is a protected system component.

The candidate missed the deadline despite warning support in advance. Before you start, quit Handoff, Continuity, and any remote-desktop tool, then check the webcam and the room.

8 Other Confirmed LinkedIn HackerRank Questions

These eight problems come from four other real sittings, none of them mine. The clearest public trail is a LinkedIn online assessment write-up on LeetCode Discuss that lists the exact question shapes several candidates reported. A fourth sitting, posted by Priyanka Yadav on 4 November 2020, reported three medium LeetCode-level questions but published no statements, so it stays as corroboration only.

Some candidates claim the same questions repeat across sittings, but that rests on two anonymous comments and is unverified. I list each problem with its source and a working solution where the shape allows one.

Question 1: Fourth Least Significant Digit

A GeeksforGeeks SWE Summer Internship OA on 14 December 2020 published this as a full statement. The task was to return the fourth least significant digit of a number, meaning the digit in the thousands place (10^3). For 1234567 the answer is 4. A direct integer computation solves it.

def fourth_lsd(n):
    # 1st LSD = units (10^0); 4th LSD = thousands (10^3)
    return (abs(n) // 1000) % 10

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

Question 2: Unique Pairs Summing to a Target

The same GeeksforGeeks sitting asked for the number of unique pairs in an array whose values sum to a given target. Distinct value pairs count once even when indices repeat. Sort, then use a two-pointer sweep that skips duplicates on both ends when a match lands.

def unique_pairs(arr, target):
    arr.sort()
    left, right = 0, len(arr) - 1
    count = 0
    while left < right:
        s = arr[left] + arr[right]
        if s == target:
            while left < right and arr[left] == arr[left + 1]:
                left += 1
            while left < right and arr[right] == arr[right - 1]:
                right -= 1
            count += 1
            left += 1
            right -= 1
        elif s < target:
            left += 1
        else:
            right -= 1
    return count

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

Question 3: Minimum Umbrellas for N People

Also from the GeeksforGeeks sitting: given umbrella capacities and exactly n people to cover, return the fewest umbrellas that sum to n. This is unbounded coin change toward an exact total. Dynamic programming over the capacities gives the minimum count, or negative one if impossible.

def min_umbrellas(capacities, n):
    INF = float('inf')
    dp = [0] + [INF] * n
    for i in range(1, n + 1):
        for c in capacities:
            if c <= i:
                dp[i] = min(dp[i], dp[i - c] + 1)
    return dp[n] if dp[n] != INF else -1

Time complexity: O(n * k) | Space complexity: O(n)

Question 4: Edges on Any Shortest Path

The fourth GeeksforGeeks problem gave a weighted graph and asked, for each edge, whether it lies on any shortest path between node 1 and node N. Run Dijkstra from node 1 and from node N. An edge (u, v, w) qualifies when dist1[u] + w + distN[v] equals the shortest distance.

import heapq

def dijkstra(graph, src):
    dist = {src: 0}
    pq = [(0, src)]
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist.get(u, float('inf')):
            continue
        for v, w in graph[u]:
            if d + w < dist.get(v, float('inf')):
                dist[v] = d + w
                heapq.heappush(pq, (dist[v], v))
    return dist

def edges_on_shortest_path(graph, node1, nodeN):
    A = dijkstra(graph, node1)
    B = dijkstra(graph, nodeN)
    minD = A[nodeN]
    result = []
    for u in graph:
        for v, w in graph[u]:
            if A.get(u, float('inf')) + w + B.get(v, float('inf')) == minD:
                result.append((u, v))
    return result

Time complexity: O((V + E) log V) | Space complexity: O(V)

Question 5: Beautiful Towers Maximum Heights

A LeetCode Discuss thread from 27 January 2024 described a maximum sum of tower heights problem. A commenter mapped it to LeetCode 2865 and 2866, the Beautiful Towers problems. The greedy shape limits each tower's height by its neighbors and a cap, solved with two monotonic-stack passes.

def max_sum_of_tower_heights(heights, limit):
    n = len(heights)
    left = [0] * n
    right = [0] * n
    stack = []
    for i in range(n):
        while stack and heights[stack[-1]] <= heights[i]:
            stack.pop()
        left[i] = 0 if not stack else min(heights[i] - heights[stack[-1]], limit)
        stack.append(i)
    stack = []
    for i in range(n - 1, -1, -1):
        while stack and heights[stack[-1]] <= heights[i]:
            stack.pop()
        right[i] = 0 if not stack else min(heights[i] - heights[stack[-1]], limit)
        stack.append(i)
    return sum(left[i] + right[i] + heights[i] for i in range(n))

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

Question 6: Encrypted Files Sliding Window

A comment on that same LeetCode Discuss thread, dated 18 May 2026, named an "Encrypted Files" problem solved with a sliding window. The sketch keeps a boolean isDecrypted array over a window of size k. The source gives only the shape, so I solve the natural form: count windows of size k where every file is decrypted.

def fully_decrypted_windows(is_decrypted, k):
    n = len(is_decrypted)
    if k > n:
        return 0
    decrypted = 0
    for i in range(k):
        decrypted += is_decrypted[i]
    count = 1 if decrypted == k else 0
    for i in range(k, n):
        decrypted += is_decrypted[i] - is_decrypted[i - k]
        if decrypted == k:
            count += 1
    return count

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

Question 7: 3Sum Smaller Than K

A Glassdoor LinkedIn Intern SWE snippet posted on 9 July 2023 listed "3 sum less than k" and noted that the most optimized version was required. Sort the array, fix the smallest element, then use a two-pointer scan on the rest to count triples under k.

def three_sum_smaller(nums, k):
    nums.sort()
    count = 0
    n = len(nums)
    for i in range(n - 2):
        left, right = i + 1, n - 1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if s < k:
                count += right - left
                left += 1
            else:
                right -= 1
    return count

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

Question 8: Unnamed Dynamic Programming Problem

The same Glassdoor snippet from 9 July 2023 named a second question as dynamic programming but said the candidate did not remember it. I will not invent a statement for an unrecoverable problem. Treat it as a confirmed but unnamed DP question, and drill classic DP shapes (knapsack, interval, subsequence) alongside the seven above.

What LinkedIn's HackerRank Test Format Actually Looks Like

The hackerrank linkedin test has run 90 minutes across every first-person sitting from 2020 to 2026. Only the question count has moved, between three and four, so plan for the higher number. The chart below shows each sitting and the 2026 expectation row.

Hidden test cases decide the score. The 2026 candidate warned that an optimized solution is needed to avoid the time limit exceeded error on hidden test cases. Those hidden cases are what separate a partial from a full solve, and they set up the scoring and strategy sections below.

Coding only on the SWE track. There were no essay or descriptive questions on the SWE OA, despite common rumors, only coding problems. Do not study written answers for this track.

Language list unconfirmed. No primary source names the SWE OA's allowed languages. The 24-language list on record comes from the SRE sitting, not SWE. Pick a mainstream language (Python, Java, or C plus plus) and confirm the list in your invite.

Different track, different test. The SRE track ran 105 minutes with 26 MCQs and 2 SQL, and the Data Engineer track ran 2 coding, 2 SQL, and 1 statistics MCQ. If your invite names SRE or DE, this SWE guide no longer fits your test.

How LinkedIn's HackerRank Scoring Works

HackerRank scores each question as full, partial, or none. A partial is real credit, not a consolation, but it rarely clears the bar alone. The chart below shows what advanced and what did not across the reported sittings.

Three outcomes per question. You get a full solve when every test case passes. A partial is when some pass. A none is when nothing passed. The 2026 candidate's "15 of 15 test cases" wording implies roughly 15 hidden tests per question.

The bar is depth, not breadth. Two complete solves beat three shaky ones, which inverts the instinct to touch every problem. The stated 2026 bar is two full solves (15 of 15) plus one partial to move ahead.

Recruiters Receive Your Code and Test-Case Metadata

After you submit, LinkedIn sees more than a score. Employers receive the source you wrote for each question, plus which test cases passed or failed, the runtime, the memory, the language, the timestamps, and the environment logs. No competitor guide explains what LinkedIn actually receives, and it is why a clean, readable solution matters, not just a passing one.

LinkedIn HackerRank Exam-Day Strategy

Lock two full solves before polishing the third. The reported bar is two complete solves plus one partial, so I attacked the questions in score order, not in the given order.

The 2026 coaching-program candidate reported that people who move ahead usually fully solve two questions (15 of 15 test cases) and partially solve one. I banked my two clean solves before spending a minute on the third.

Brute force passes samples and fails hidden tests. My third question started as a factorial brute force that cleared the visible sample. The same candidate warned that an optimized solution is needed to avoid the time limit exceeded error on hidden test cases, and her own named failure cause was lack of optimization. I rewrote the approach before trusting it.

Time sunk on one problem costs the whole test. Two dated datapoints on the same 90-minute exam show the swing. One candidate wasted a lot of time on Q2 and never reached Q4. Another finished all four questions in 75 minutes with every test case passing. I set a hard stop on any single problem and moved on.

Why Candidates Fail the LinkedIn HackerRank Assessment

Unoptimized code fails on hidden test cases. The only 2026 candidate account in the pool names this as her own cause. She partially solved two questions and wrote that her main issue was lack of optimization. She heard nothing for more than 20 days. A brute force that clears the sample still dies on the hidden cases.

Two partial solves fall below the bar. Partial credit is real, but it is not enough against a two-full-plus-one-partial line. One anonymous comment said a candidate solved questions one, three, and four and still got a rejection. That comment is uncorroborated, but it points the same way: breadth without a full solve does not advance.

A macOS system process can trigger a violation. HackerRank proctoring flagged parsecd, a protected Apple Handoff process, as a security violation on a real sitting. It is unrelated to the Parsec remote-desktop app and cannot be closed. The candidate missed the deadline despite warning support in advance. I quit Handoff and Continuity before starting.

AI assistant use is a proctoring violation here. LinkedIn's OA is camera-on and coding-only, so an AI assistant is a proctoring violation by definition.

The confusion comes from a different round. LinkedIn added an AI-enabled coding round to its onsite loop in 2026, and that round runs on CoderPad, not on the HackerRank OA. Do not mix the two.

On the OA, the exposure is structural. The Desktop App blocks other applications and virtual machines at the OS level, so a second-screen tool cannot run unnoticed. Proctor Mode adds plagiarism detection, screenshot analysis, and session replay. How HackerRank pieces those signals into a cheating verdict is broken down in our detection guide. The hiding mechanism is basic, and detection keeps improving.

Desktop overlay tools render the AI's answer on the same screen the proctoring system is monitoring; the hiding is a basic OS-layer rendering trick, not a real separation. Whether a given build of that monitoring catches it is not something I can verify, and proctoring keeps adding capabilities, so the risk isn't fixed.

InterviewFox works differently: the answer goes to my phone, a physically separate device that no screenshot or session recording can reach by design.

One vendor claims its assistant is undetectable and that it passed a HackerRank check. That claim sits on a page selling the assistant, so it is marketing, not evidence. A second figure, a 93 percent plagiarism accuracy rate, has no primary source behind it. Neither ships as fact.

How to Prepare for the LinkedIn HackerRank in 7 Days

I planned seven days because no confirmed link-expiry window exists in the pool. The only sourced timing fact is that the OA email arrives about 15 days after applying, which is invite lag, not a deadline. The plan below is evidence-led, not a generic template, and it skips what the SWE OA never tests.

In the days before the OA I ran the Prep Agent from InterviewFox over WhatsApp or SMS, sending it the confirmed question patterns for this company and getting a personalized drill plan and strategy back.

Days 1-3: Greedy, Sorting, and Interval Overlap Patterns

The newest 2026 sitting drew entirely on four named patterns: minimize absolute difference, interval overlap counting, and mathematics-based greedy plus sorting. My first three days drilled those shapes until I could name the pattern before writing the approach. I pulled the 16 LinkedIn-tagged LeetCode problems from interviewsolver as extra practice, but I labelled them as tagged, not confirmed.

Success check: I named the pattern within two minutes on ten consecutive unseen problems.

I skipped system-design preparation. The confirmed SWE OA is coding-only, with no essay or descriptive questions, only coding problems.

System design first appears in the onsite loop, weeks later. I also skipped MCQ and SQL banks, because those formats belong to other tracks: SRE ran 26 MCQs and 2 SQL, and Data Engineer ran 2 SQL and 1 statistics MCQ. Neither appears on a confirmed SWE sitting.

Days 4-5: Rewrite Brute Force Before Hidden Tests Run

The named 2026 failure cause was lack of optimization, and HackerRank scores full, partial, or none, so a brute force that clears samples still scores only partial. My middle two days re-solved the seven confirmed archive questions to a stated complexity target, writing the naive version first and replacing it on purpose.

Success check: all seven passed at the target complexity without reopening an editorial.

Days 6-7: 90-Minute Mock and Desktop App Room Check

The 90-minute window and 3 to 4 question count are fixed across sittings, and the parsecd incident shows an environment slip can cost the whole test. My last two days ran one unbroken 90-minute set of three unseen mediums scored against the two-full-plus-one-partial bar, then a full environment pass.

Success check: two full solves plus one partial inside the timer, and a Desktop App session that launched with no flagged process.

What Happens After You Submit the OA

LinkedIn's OA is one node in a sequence whose only published waits come from candidates. The chart below lays out the application to offer path, with the recruiter call as the moment that breaks the silence.

The OA invite arrives about 15 days after you apply. Candidates in 2026 reported the OA mail usually lands within about 15 days of the application. Expect 90 minutes of three or four coding questions with the camera on.

Silence past three weeks usually means no advance. One account reports recruiter contact in about a week when moving forward, another reports more than 20 days of nothing when not. The retake policy is unknown, so I will not guess at it. The submit-to-response wait has no stated SLA from LinkedIn.

The Result Comes From a LinkedIn Recruiter

Every first-person account shows a LinkedIn recruiter making contact after the OA. None reports a HackerRank pass or fail email. HackerRank never sends the decision, the recruiter does, which is why candidates watch their inbox, not the platform.

Silence Past Three Weeks Usually Means No Advance

The pattern across accounts is clear: about a week of silence means a move forward, and more than 20 days means no advance. LinkedIn does not appear to send a formal OA rejection. The retake and cooling-off policy is unknown, so treat a long silence as the answer rather than waiting for one.

FAQ

What questions are on the LinkedIn HackerRank OA?

The 2026 sitting had three coding questions on greedy and sorting patterns. Older sittings reported four. This guide also lists eight more confirmed problems from past years.

Are there LinkedIn HackerRank threads on Reddit?

Reddit exists as a community, but our research drew on LeetCode Discuss, Glassdoor, and blogs. What matters is the confirmed question and format data, not the platform it came from. The eight problems above are sourced from named sittings.

How long is the LinkedIn HackerRank test?

Every first-person sitting from 2020 to 2026 ran 90 minutes. Plan for three or four coding questions. The newest 2026 sitting had exactly three.

Is the LinkedIn HackerRank OA hard?

The problems are LeetCode medium to hard with a new appearance. The real difficulty is the hidden test cases, which punish a slow brute force. Two clean solves plus one partial is the bar.

What is the LinkedIn HackerRank test in short?

It is a 90-minute, camera-on HackerRank coding test for LinkedIn SWE roles. Expect three or four problems and no essays or MCQs. The recruiter, not HackerRank, sends the result.

Can I use AI during the LinkedIn HackerRank OA?

Desktop overlay tools put the AI's answer on your own computer screen, rendered as a hidden layer with a basic OS-layer trick. The answer stays on-screen, the hiding is basic, and proctoring software keeps adding detection capabilities as AI tools become more common, so the risk is not fixed.

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