96 questions from 16 interviews · updated from reports 2014-2024
About
LinkedIn is a professional networking platform owned by Microsoft, used for job search, recruiting, learning, and sharing work-related content. In India, it is known for hiring software engineers and software engineering interns for product, backend, data, and platform teams.
The roles that come up most are Software Engineer, Software Engineer Intern and Software Engineering Intern. This covers 16 candidate interviews reported from 2014 to 2024. The largest group sat it at internship level (7 of 15 that recorded a level). Among the 11 that recorded either route, arrivals split between campus drives (5, 45%) and off-campus applications (6, 55%). Most questions fall under DSA and CS fundamentals.
Ans. Use DFS and track the parent of each visited node; if you reach an already visited neighbour that is not the parent, a cycle exists. Store the graph as an adjacency list and maintain a visited set or array. Run DFS from every unvisited node to cover disconnected graphs. Time is O(V + E), space is O(V).
Ans. Serialize the tree using preorder traversal and record null children with a sentinel, then deserialize by reading the values back in the same order. Use a list or stream of tokens and a recursive index or queue. Each node and null marker is processed once, so time is O(n) and space is O(n).
Ans. Use backtracking to build factor lists whose product equals the number, trying factors from a minimum start value to avoid duplicate orders. Store the current combination in a list and add a copy when a valid factor pair is found. Search only up to sqrt(remaining). Time is output-sensitive, mainly proportional to generated combinations.
Ans. Modern web architecture is a layered, distributed model where browsers or mobile clients talk to backend services through APIs, usually behind CDNs, load balancers and gateways. The key detail is separation of concerns: frontend, services, data stores, caching, messaging, observability and deployment pipelines are designed to scale, fail and change independently.
Ans. Build a suffix automaton and count unique substrings as the sum, over every state except the initial state, of maxLength[state] minus maxLength[suffixLink[state]]. Each state represents a group of substrings with shared end positions. This gives the number of distinct substrings in O(n) time and O(n) space.
Ans. Use a layered architecture with DNS, CDN, load balancers, stateless application services, cache, database, message queues, and observability. The most important detail is separating read, write, and asynchronous paths so each can scale independently. Use autoscaling services, replicated databases, Redis for hot data, queues for background work, and metrics-driven capacity planning.
Ans. Use joins, grouping, filtering, subqueries, and window functions to express the required result set clearly. Start from the tables and relationships, join only needed rows, aggregate with group by, filter groups with having, and rank or compare rows with window functions. Indexes on join, filter, and sort columns matter most for performance.
Ans. Use dynamic programming where dp[i][j] stores the length of the longest palindromic subsequence inside s[i..j]. If s[i] equals s[j], set it to 2 plus dp[i+1][j-1], otherwise take the maximum of excluding either end. Fill by increasing substring length. Time is O(n²), space is O(n²).
Ans. Sort the array, then fix each element one by one and use two pointers on the remaining part to find whether the other two numbers sum to target minus the fixed value. Move the left or right pointer based on the current sum. This takes O(n²) time and O(1) extra space.
Ans. Use dynamic programming on intervals to find the longest palindromic subsequence. Let dp[i][j] be the answer length for S[i..j]. If S[i] equals S[j], dp[i][j] = 2 + dp[i+1][j-1]; otherwise take max of excluding either end. Fill by increasing length. Time is O(n²), space is O(n²).
Ans. Use stateless file service nodes behind load balancers, storing file bytes in distributed object storage and metadata in a replicated, sharded database. Scale uploads with chunking and resumable writes, downloads with CDN and edge caching, and background queues for virus scans, thumbnails and replication. Use consistent IDs, access control, checksums, versioning and monitoring.
Ans. Rolling hash computes a hash for each fixed length substring by updating the previous hash in constant time as the window moves. Usually it uses a polynomial hash with modular arithmetic. It powers Rabin-Karp pattern matching, fast substring comparison, duplicate substring search, and plagiarism detection. The key issue is handling collisions, often by verification or double hashing.
Ans. Do a depth first traversal and whenever a leaf is found, append it to the tail of a doubly linked list using its left and right pointers as previous and next. Use postorder if the leaves must be removed from the tree, returning null to the parent. Time is O(n), extra stack space is O(h).
Ans. Sort one array in ascending order and the other in descending order, then multiply corresponding elements and add the products. This gives the minimum possible sum by pairing small values with large values. The main data structure is the arrays themselves after sorting. Time complexity is O(n log n), dominated by sorting.
Ans. Use a stack and scan the tokens from left to right. Push numbers onto the stack; when you see an operator, pop the right operand first, then the left operand, apply the operator, and push the result back. The final stack value is the answer. Time complexity is O(n), space complexity is O(n).
Ans. XSS injects malicious script into pages viewed by users, while SQL injection injects SQL into database queries. Prevent XSS by escaping output, sanitising trusted HTML, using CSP, and avoiding unsafe DOM APIs. Prevent SQL injection by using parameterised queries or prepared statements, not string concatenation, plus least privilege and careful input validation.
Ans. Use Morris inorder traversal and verify that values appear in strictly increasing order. Keep only the previous visited value or node, so extra space is O(1). Temporarily create and later remove threads from each node’s inorder predecessor to avoid recursion or a stack. The traversal takes O(n) time and restores the tree.
Ans. Use a monotonic decreasing stack to keep indices of days with prices greater than the current price. For each price, pop while the stack top price is less than or equal to it, then the span is the distance to the remaining top index, or i + 1 if empty. This runs in O(n) time.
Ans. Scan the matrix and start a DFS or BFS whenever you find an unvisited 1, counting one new component each time. Mark all reachable 1s as visited using four-directional neighbours, unless diagonal connectivity is specified. The time complexity is O(rows × columns), with O(rows × columns) worst-case extra space.
Ans. Start by identifying the core pattern, such as two pointers, sliding window, BFS, DFS, heap, or dynamic programming. State the invariant, choose the supporting data structure, then describe each step in order. Finish with time and space complexity, for example linear time and linear space for a hash map based solution.
Ans. Please provide the specific networking question you want answered. Networking for system design can cover latency, DNS, TCP versus UDP, HTTP, load balancing, TLS, retries, timeouts, proxies, CDNs, NAT, ports, and failure handling, and each needs a different concise interview-style answer.
Ans. Use SQL when data is structured, relationships matter, and you need strong consistency, transactions, and complex queries. Use NoSQL when the data is flexible, high-volume, distributed, or needs very fast reads and writes at scale. The key trade-off is usually strict relational integrity versus horizontal scalability and schema flexibility.
Ans. Create a canonical pattern for each word using a map from character to the order in which it first appears, then compare or group words by that pattern. For example, “paper” and “title” both map to the same pattern. Reset the map per word. The total time is O(total characters).
Ans. Sort the array, then use the triangle rule: for sorted values a <= b <= c, a triplet is valid if a + b > c. Fix each element as the largest side and use two pointers on the left. This finds all valid triplets in O(n² + T) time, where T is the number output.
Ans. Use dynamic programming on intervals, where dp[i][j] stores the maximum score the current player can secure from values i to j. The key recurrence is choosing left or right, then assuming the opponent also plays optimally. Fill smaller intervals first. This uses a 2D table and takes O(n²) time and O(n²) space.
Ans. Fisher-Yates shuffles an array by scanning from the last position to the first, swapping each position with a randomly chosen position from the unshuffled part, including itself. At step i there are i plus 1 equally likely choices, so each element is fixed once with equal chance, giving every permutation probability 1 divided by n factorial.
Ans. Use a stack and a lower bound to check it in one pass. Traverse the preorder values; if any value is less than the current lower bound, it is invalid. While the value is greater than the stack top, pop and update the lower bound. Push the value. This takes O(n) time and O(n) space.
Ans. Use backtracking to build each sum, choosing the next positive integer from the previous chosen value up to the remaining total. This keeps combinations in nondecreasing order, so duplicates like 1+2 and 2+1 are avoided. Store the current combination in a list. Time is proportional to the number of partitions printed.
Ans. Break the monolith along clear business capabilities, not technical layers, so each component owns a coherent domain, data, and interface. Start by identifying bounded contexts, dependencies, data ownership, and change frequency. The most important detail is to migrate incrementally, using stable APIs and observability to reduce risk while avoiding distributed monoliths.
Ans. Use dynamic programming, where dp[i] is the number of ways to decode the prefix ending at position i. Add dp[i - 1] if the current digit is 1 to 9, and add dp[i - 2] if the previous two digits form 10 to 26. Handle 0 only as part of 10 or 20. Time is O(n).
Ans. Use breadth first search with a queue, processing nodes level by level and printing '$' after each level finishes. The cleanest method is to store the current queue size, process exactly that many nodes, enqueue their children, then print '$'. Time complexity is O(n), and space complexity is O(w), where w is tree width.
Ans. Use a sliding window with two frequency maps: one for the pattern and one for the current window. Expand the right pointer until all required characters are covered, then move the left pointer to shrink while still valid. Track the shortest valid window. This runs in O(n) time with O(k) space.
Ans. Sort the characters, remove duplicates, then use backtracking to generate combinations of length k in increasing index order. Keep a current character buffer and, at each step, choose the next character only from positions after the previous one. This prints each valid string once. Time complexity is O(C(n, k) · k).
Ans. Use breadth first search from the starting square, and the first time you reach the target square is the minimum number of knight moves. Treat each board square as a graph node with up to eight knight edges. Store positions and distance in a queue, mark visited squares, and run in O(rows × columns) time and space.
Ans. Sort all start times and end times separately, then sweep through them to find the maximum number of simultaneous tasks. If the next task starts before the earliest current task ends, need one more machine; otherwise free one. The maximum active count is the answer. Time complexity is O(n log n).
Ans. Scan the string once, extract each valid number token, convert it to a numeric type, and add it to a running sum. Use a small buffer or indices to capture optional minus signs, digits, and one decimal point. This uses constant extra space apart from the token and runs in O(n) time.
Ans. Use depth first search from the root, carrying the maximum value seen so far on the current path, and count a node if its value is greater than or equal to that maximum. Then update the maximum before visiting its children. This visits each node once, uses recursion or a stack, and runs in O(n) time.
Ans. Use a products table for product details, a reviews table for individual customer ratings, and a product_rating_summary table storing total reviews, rating sum, average rating, and counts for 1 to 5 stars. Update the summary when a review is created, changed, or deleted, ideally transactionally or via reliable event processing.
Ans. Parse the integers into a hash set, then find the longest consecutive run by only starting from numbers whose predecessor is absent. For each start, count upwards while values exist, track the best start and length, then print that range in increasing order. This is O(n) time and O(n) space.
Ans. Scan the matrix row by row and count a streak only for days where every employee is present. For each day, check all columns; if all values show present, increment current streak, otherwise reset it to zero. Track the maximum streak seen. Time complexity is O(days × employees), with O(1) extra space.
Ans. Use a max heap of ticket counts and always sell from the window with the most remaining tickets. Add that value to revenue, decrement it, and push it back if still positive. This greedy choice is optimal because the current highest price should never be delayed. Time complexity is O(m log n).
Ans. Find the repeating and missing number by comparing the array with the expected numbers from 1 to n. A hash set or frequency array gives O(n) time and O(n) space. Sorting gives O(n log n) time and O(1) extra space. Sum and sum of squares, or XOR, gives O(n) time and O(1) space.
Ans. Use a WebSocket based session service: users join a presentation room, and the presenter’s next or previous action updates the current slide number in the backend and broadcasts it to all sockets in that room. Store slides in object storage/CDN, keep session state in Redis or a database, and use pub/sub for scaling.
Ans. Find the lowest common ancestor of the two nodes, then return distance from the ancestor to val1 plus distance from the ancestor to val2. If one node lies on the path to the other, the ancestor is that node, so one distance is zero. Use DFS, with O(n) time and O(h) stack space.
Ans. Simulate passes from friend 1, but detect the first repeated friend to avoid doing all k steps. Store each visited friend in order and its first time. When a repeat appears, the path has entered a cycle, so reduce the remaining seconds modulo the cycle length. This is O(n) time and O(n) space.
Ans. Use a min-heap and always merge the two smallest elements first. Each time, extract the two minimum values, add their sum to the total cost, and insert the sum back into the heap. This greedy choice minimises repeated contribution of large values. The time complexity is O(n log n), with O(n) space.
Ans. A grouping is valid if, for every size s, the number of users whose count is s is divisible by s. Store user IDs in a hash map keyed by count, in ascending order, then split each list into blocks of size s. Each block’s first ID is its minimal user ID. Time is O(n).
Ans. Use dynamic programming where dp[j] stores the number of ways to reach the current row’s cell in column j. If a cell is blocked, set dp[j] to 0; otherwise add paths from the top and left modulo 1e9+7. Initialise only if start is passable. Time is O(MN), space is O(N).
Ans. Use a greedy approach: always sell the next ticket from the window with the most tickets remaining. Store all ai values in a max heap, repeatedly pop the largest value, add it to revenue, decrement it, and push it back if still positive. This gives maximum revenue in O(m log n) time.
Ans. Use a max heap of ticket counts and always sell from the window with the most remaining tickets. For each of the m sales, pop the maximum count, add it to revenue, decrement it, and push it back if still positive. Time complexity is O((n + m) log n), space O(n).
Ans. Design it as a multi-tenant calendar service with event, attendee, availability, notification and sharing APIs backed by a strongly consistent store for event ownership and invitations. The most important detail is conflict-free scheduling: store events with time ranges and time zones, index by user and time, and use transactions for create, update and RSVP changes.
Ans. A traffic enforcement camera system needs roadside capture, local offence detection, secure evidence handling and central review. The camera timestamps and geotags images, uses radar or loop sensors plus ANPR, signs evidence cryptographically, and uploads it over a secure link. The key detail is evidential integrity: calibration, audit logs and tamper-proof storage must be defensible.
Ans. I would handle it with a phased migration plan that protects service continuity and data integrity. First, map systems, ownership, dependencies, SLAs and data flows, then define the target architecture and integration contracts. The key detail is reducing risk through incremental cutovers, validation, monitoring, rollback paths and clear ownership for each service.
Ans. Use a suffix automaton and count distinct non-empty substrings as the sum over all states of length[state] minus length[suffix_link[state]]. Build the automaton in linear time while scanning the string. Each state represents an equivalence class of substrings, so this formula counts each distinct substring exactly once. Time is O(n), space is O(n).
Ans. Use Tarjan’s algorithm to find bridges in an undirected graph with one DFS. Store discovery time and low-link value for each node; after visiting a child, update the parent’s low value. If low[child] is greater than disc[parent], that edge is a bridge. Use adjacency lists. Time is O(V + E).
Ans. Use a palindromic tree, also called an Eertree, to count distinct palindromic substrings in O(n) time. Insert characters one by one, maintaining suffix links to the longest palindromic suffix. Each new node represents one new distinct palindrome, so the answer is the number of nodes excluding the two roots.
Ans. I choose based on the product goal, current bottleneck, and cost of being wrong. Quality is the baseline for correctness, security, and maintainability. Performance matters when users feel latency or cost rises. Scalability matters when growth is likely or failure impact is high. I prefer measured trade-offs over speculative optimisation.
Ans. Choose a real peer conflict where the stakes mattered but emotions stayed manageable. Emphasise listening first, separating facts from assumptions, agreeing shared goals, and finding a practical compromise or escalation path. Interviewers listen for maturity, accountability, respect, clear communication, and evidence that the relationship and work both improved.
Ans. A strong answer says yes, code reviews cost time, attention, and context switching, but reduce defects, improve maintainability, and share knowledge. Pick a real example where review depth matched risk. Emphasise small changes, clear standards, timely feedback, automation for style, and trust. Interviewers listen for pragmatism, not review theatre.
Ans. Pick a real example showing fair, structured people management across hiring, development, performance issues, and exits. Emphasise clear expectations, evidence-based decisions, coaching, documentation, legal or HR process, and respect for the individual. Interviewers listen for judgement, consistency, accountability, lack of ego, and willingness to make hard decisions humanely.
No question matches those filters. Reset filters.
Showing 60 of 96 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover DSA (57%) and CS fundamentals (26%).
Candidate interviews show an average of 3.9 rounds per experience, with a typical sequence of Online test. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 32%, medium 56%, hard 12%.
