252 questions from 25 interviews · updated from reports 2014-2023
About
Info Edge is an Indian internet company that runs online platforms such as Naukri.com, 99acres, Jeevansathi, and Shiksha. In India, it hires technical candidates for roles such as Software Engineer, SDE-1, Software Developer, backend engineer, and frontend engineer.
The roles that come up most are Software Engineer, SDE-1 and Software Developer. This covers 25 candidate interviews reported from 2014 to 2023. Most sat it at entry level (24 of 25 that recorded a level). Among the 22 that recorded either route, arrivals split between campus drives (18, 82%) and off-campus applications (4, 18%). Most questions fall under CS fundamentals and DSA.
Ans. ACID properties are the guarantees that make database transactions reliable: Atomicity, Consistency, Isolation and Durability. Atomicity means all or nothing, Consistency keeps valid rules, Isolation prevents concurrent transactions interfering, and Durability ensures committed changes survive crashes. They are essential for correctness in systems handling critical data.
Ans. An operating system manages hardware resources and provides services for programs. It controls CPU scheduling, memory management, file systems, device I/O, security and process isolation. The key idea is abstraction: applications do not talk directly to hardware, but use OS interfaces such as system calls to run safely and efficiently.
Ans. Sort the array, then fix each element in turn and use two pointers on the remaining suffix to find the other two values. If the current sum is too small, move the left pointer right; if too large, move the right pointer left. This uses no extra data structure and runs in O(n²) time.
Ans. Find a topological ordering of the DAG, then do dynamic programming over that order to relax outgoing edges and store the best distance to each vertex. Initialise distances to 0, or to negative infinity except chosen sources if using a fixed start. The maximum stored value is the answer. Time complexity is O(V + E).
Ans. Build a hash set from the second array, then scan the first array and output each element that is not in that set. This gives average O(n + m) time and O(m) extra space, where n and m are the array sizes. If duplicates should be removed, store results in another set.
Ans. Search engines work by crawling web pages, indexing their content, and ranking matching pages when a user searches. Crawlers follow links to discover pages, then build an inverted index mapping terms to documents. At query time, results are ranked using relevance, authority, freshness, location, and user intent signals.
Ans. Use a min heap to always connect the two shortest ropes first, add their sum to the total cost, then push the combined rope back into the heap. Repeat until one rope remains. This greedy choice minimises repeated large costs. Time complexity is O(n log n), with O(n) extra space.
Ans. Use Floyd’s slow and fast pointers to detect the loop, then find the loop start and set the last node in the loop to null. After detection, move one pointer to the head and advance both one step until they meet. Then traverse the loop to find its previous node. Time is O(n), space is O(1).
Ans. Strings are immutable in Java to make them safe, efficient, and predictable. Immutability lets string literals be shared in the string pool without risk of one reference changing another’s value. It also makes strings safe as keys in hash-based collections, because their hash code and contents cannot change after creation.
Ans. Two axis-aligned rectangles overlap if they are not separated horizontally or vertically. For rectangles with bottom-left and top-right corners, they do not overlap when one is completely left of the other, or completely above the other. So check these four separation cases and negate the result. This takes constant time and space.
Ans. LRU, or Least Recently Used, replaces the page that has not been accessed for the longest time when a page fault occurs and memory is full. It assumes recently used pages are likely to be used again soon. It is commonly implemented with a hash map and linked list for constant-time updates.
Ans. ResNets are neural networks with skip connections that add a layer’s input to its output, helping very deep models train by improving gradient flow. Adam is an optimiser that adapts each parameter’s learning rate using moving averages of gradients and squared gradients. The key detail is that both address training stability and convergence.
Ans. Use a postorder DFS to compute the maximum path sum, keeping a global best answer. For each node, take the larger non-negative gain from its left or right child, add the node value, and return that upward. Update the global best with left gain plus node value plus right gain. Time is O(n), space is O(h).
Ans. A DBMS handles concurrency by running operations as isolated transactions and controlling how they read and write shared data. It uses mechanisms such as locks, timestamps, or MVCC to prevent lost updates, dirty reads, and inconsistent reads. The key goal is to make concurrent execution behave like some correct serial order.
Ans. Insert each key one by one by searching for its correct leaf position, placing it in sorted order, and splitting any node that overflows. When a node has too many keys, promote its median key to the parent and split the remaining keys into two nodes. Each insertion costs O(log n).
Ans. Use an adjacency list and a min priority queue to repeatedly choose the unvisited node with the smallest known distance, then relax all outgoing edges. Initialise distances to infinity except the source as zero. Push improved distances into the heap and ignore stale entries. Time complexity is O((V + E) log V) with a binary heap.
Ans. Build it as separate services for discovery, shows, seat inventory, booking, payments and notifications, backed by a relational database for bookings and a search index for movies and venues. The key detail is seat locking: place a short TTL hold on selected seats, confirm only after payment, and release holds on timeout or failure.
Ans. Check it by recursively ensuring every node value lies within a valid lower and upper bound. Start with unbounded limits, then for the left child update the upper bound to the current value, and for the right child update the lower bound. If any node violates its range, it is not a BST. Time is O(n), space is O(h).
Ans. Use Floyd’s slow and fast pointer method to detect the loop, then count its length by keeping one pointer fixed at the meeting node and moving another around the cycle until it returns. Increment a counter on each move. This uses constant extra space and runs in O(n) time.
Ans. Compute the total sum, then scan once maintaining a prefix sum. A valid split exists when the prefix sum equals total sum divided by two, at an index before the last element. The key detail is that the two parts must be contiguous. This uses no extra data structure, O(n) time and O(1) space.
Ans. Strictly with O(1) extra space, it is not possible to clone a stack while preserving s1 and keeping the same order in s2. The usual solution uses recursion: pop each item, recursively clone the rest, then push the item back to s1 and also to s2. Time is O(n), recursion space is O(n).
Ans. Use two stacks: one for numbers and one for operators. Scan the expression left to right, push operands, and push operators based on precedence. When an operator with lower or equal precedence is found, apply the top operator to the top two operands. Parentheses are handled by evaluating until the matching bracket. Time complexity is O(n).
Ans. Gmail maintains login state mainly using secure cookies that store session or authentication tokens in the browser. After login, the server issues a token, and the browser sends it with later requests. Gmail validates it server side, refreshes it when needed, and protects it using HTTPS, expiry, and secure cookie flags.
Ans. Use two stacks, an input stack and an output stack. Enqueue pushes onto the input stack. Dequeue and peek use the output stack; if it is empty, move all items from input to output, reversing order. This gives FIFO behaviour with O(1) amortised enqueue, dequeue and peek, and O(n) space.
Ans. Use the patience sorting approach with a tails array, where tails[i] stores the smallest possible ending value of an increasing subsequence of length i + 1. For each number, binary search its position in tails and replace or append it. The length of tails is the answer. Time complexity is O(n log n), space O(n).
Ans. The browser resolves the domain to an IP address, opens a connection to the server, sends an HTTP request, receives a response, and renders the page. The key detail is DNS lookup first, followed by TCP and usually TLS for HTTPS, then HTML parsing, fetching CSS, JavaScript and images, and building the visual page.
Ans. Data structures are ways to organise data so operations like access, search, insertion and deletion are efficient. The key fundamentals are arrays, linked lists, stacks, queues, hash tables, trees, heaps and graphs. The most important detail is choosing based on operation cost, usually expressed with time and space complexity.
Ans. A HashMap stores key value pairs in an internal array of buckets, using the key’s hashCode to choose a bucket index. If multiple keys land in the same bucket, it compares keys with equals and stores collisions in a linked list or, after enough collisions, a tree. Resizing happens when the load factor threshold is crossed.
Ans. Use worst case minimisation. With two eggs and 100 floors, start at floor 14, then move up 13, 12, 11 and so on. If an egg breaks, search linearly below with the second egg. The decreasing gaps balance both cases, because 14 + 13 + ... + 1 covers 105 floors, so 14 drops suffice.
Ans. Sort the array, then fix each element in turn and use two pointers on the remaining suffix to find pairs whose sum completes the target. Move the left or right pointer based on the current sum and print matches. This uses the sorted array as the main structure, runs in O(n²) time, and O(1) extra space.
Ans. The browser resolves the domain with DNS, opens a connection to the server, sends an HTTP request, receives a response, and renders the page. For HTTPS, it first performs a TLS handshake after the TCP connection. The browser then parses HTML, fetches linked CSS, JavaScript, and images, builds render structures, and paints the page.
Ans. Create a function that returns another function, with two closed-over variables holding the previous and current Fibonacci numbers. Each call returns the next value, then updates those two variables. The data structure is just constant state in the closure. Each next value takes constant time and constant space.
Ans. Pointers store memory addresses and are used for indirection, dynamic allocation, arrays, and passing data by reference. In C, input and output commonly use scanf and printf, while C++ uses cin and cout. The key detail is to manage pointer lifetime carefully, avoiding dangling pointers, null dereferences, and memory leaks.
Ans. Use Floyd’s slow and fast pointer method: first detect a cycle, then reset one pointer to the head and move both one step at a time; where they meet is the loop start. This works because the meeting point inside the cycle has a fixed distance relationship to the cycle entry. Time is O(n), space is O(1).
Ans. Use level order traversal with a queue and print the first node of each level for the left view and the last node of each level for the right view. Process the tree level by level using the current queue size. This takes O(n) time and O(w) space, where w is maximum width.
Ans. A feedback mechanism in an RNN is the loop that feeds information from a previous time step back into the network for the next time step. Most importantly, the hidden state carries context, allowing the model to use earlier inputs when processing later elements in a sequence.
Ans. The browser resolves the domain to an IP address, opens a connection, sends an HTTP request, receives a response, and renders the page. Typically it checks cache first, uses DNS if needed, creates a TCP connection with TLS for HTTPS, downloads HTML, then fetches linked CSS, JavaScript, images, and other resources.
Ans. CNNs are used to learn spatial patterns efficiently, especially in images, by applying shared filters over local regions. This captures features such as edges, shapes and textures with fewer parameters than fully connected networks. RNNs process sequences step by step and keep state over time, so they suit text, speech and time series.
Ans. Use dynamic programming to build the longest common subsequence length for every pair of prefixes of the two strings. Store results in a two-dimensional table where a character match adds one from the diagonal, otherwise take the maximum of left and top. Backtrack through the table to reconstruct the subsequence. Time is O(nm), space is O(nm).
Ans. Group words by a canonical key and print each group. Use a hash map where the key is either the sorted letters of the word or a fixed-size character frequency vector, and the value is the list of matching words. With sorted keys, time is O(n k log k) and space is O(n k).
Ans. Use an edge list and a distance array initialised to infinity, with the source set to zero. Relax every edge V minus 1 times, updating dist[v] if dist[u] plus weight is smaller. Then scan edges once more to detect negative cycles. Time complexity is O(VE), space is O(V).
Ans. Java is considered more robust and secure because it runs managed code on the JVM rather than giving direct control over memory like C++. The key detail is that Java removes pointer arithmetic and manual memory management, using bytecode verification, runtime checks, exception handling and garbage collection to reduce crashes, memory corruption and common security bugs.
Ans. Use two pointers to find the middle, reverse the second half of the list, then compare it node by node with the first half. If all values match, it is a palindrome. The key detail is reversing only the second half, giving O(n) time and O(1) extra space.
Ans. Topological sorting is a linear ordering of vertices in a directed acyclic graph where every node appears before the nodes that depend on it. It is used for dependency ordering, such as course prerequisites, build systems, or task scheduling. Common methods are DFS or Kahn’s algorithm, both running in O(V + E).
Ans. Each ant has two choices: move clockwise or anticlockwise. With three ants, there are 2 × 2 × 2 = 8 possible direction choices. They avoid collision only if all move clockwise or all move anticlockwise, which gives 2 safe cases. So the probability of no collision is 2/8 = 1/4, and collision is 3/4.
Ans. Expand around every possible centre and keep the longest palindrome seen. For each index, check both odd length and even length centres, moving left and right while characters match. This uses constant extra space and runs in O(n²) time, which is usually acceptable unless Manacher’s O(n) algorithm is specifically required.
Ans. Closures are functions that remember variables from the scope where they were created, even after that outer function has finished running. We need them to keep state private, build function factories, and support callbacks or event handlers that still need access to earlier data.
Ans. Convert the numbers to strings and sort them with a custom comparator: for two strings x and y, put x before y if xy is larger than yx. Then concatenate the sorted strings. Use an array or list of strings. Sorting dominates the cost, taking O(n log n) comparisons, with extra string comparison cost. Return 0 if all values are zero.
Ans. A DBMS is software that stores, organises, retrieves, and manages data while controlling access and consistency. The key fundamentals are schemas, tables, keys, relationships, SQL, transactions, indexing, normalisation, and concurrency control. The most important detail is ACID transactions, which ensure database changes are reliable even during failures or simultaneous access.
Ans. Use expand around centres: for each index, expand once for an odd-length palindrome and once between indices for an even-length palindrome, tracking the best start and length. The key detail is handling both centre types. This uses only a few variables, runs in O(n squared) time, and uses O(1) extra space.
Ans. Use relational tables for users, addresses, sellers, products, categories, inventory, carts, orders, order_items, payments, shipments, returns, reviews and coupons. Products link to categories and sellers, inventory tracks stock per SKU and warehouse, and orders store immutable snapshots of price, tax and address so later product or user changes do not corrupt history.
Ans. Use a modified binary search. Keep low and high pointers, find mid, and first check if mid is the target. One half of the array is always sorted. If the target lies within that sorted half, search there; otherwise search the other half. This gives O(log n) time and O(1) space.
Ans. The necessary conditions for a deadlock are mutual exclusion, hold and wait, no preemption, and circular wait. A resource must be non-shareable, processes must hold resources while waiting for others, resources cannot be forcibly taken, and a cycle of processes must each wait for the next. All four must hold simultaneously.
Ans. Use a relational core for users, posts, comments, reactions, friendships and privacy settings, with clear foreign keys, unique constraints and indexes on user_id, post_id and created_at. Store media in object storage and reference it. The key design choice is the feed: precompute fan-out for normal users, but generate on read for celebrities.
Ans. Use formulas and convert each problem into rates, ratios, or counts. For work, pipes, and speed, find per-unit rates and combine them. For profit and loss, use cost price, selling price, and percentage change. For probability, count favourable over total outcomes. For permutations and combinations, decide whether order matters, then apply the correct formula.
Ans. Identify the exact rule linking the given facts, symbols, numbers, or statements before choosing an answer. Break the problem into small parts, translate words into simple conditions, and eliminate options that break any condition. For sequences, find the pattern; for arrangements, draw positions; for syllogisms, test validity, not truth.
Ans. Use the basic relation distance equals speed multiplied by time. Convert all units first, such as km/h to m/s by multiplying by 5/18. For average speed, use total distance divided by total time, not the simple average. For relative speed, add speeds in opposite directions and subtract in the same direction.
Ans. Pick a situation where you helped a team perform better, not just one where you supervised people. Emphasise clear goals, trust, communication, accountability, and adapting your style to individuals. Interviewers listen for evidence that you support others, handle conflict early, give feedback well, and balance people’s needs with delivery.
Ans. Choose a work situation where you stayed professional under pressure, not one where you lost control. Emphasise pausing, listening, separating facts from feelings, and addressing the issue calmly. Interviewers listen for self-awareness, emotional regulation, respect for others, and whether you can resolve conflict without blame or escalation.
Ans. Pick a real example where adoption was low and you influenced without blame. Emphasise understanding why colleagues avoided the system, fixing gaps in documentation or components, showing benefits, and creating lightweight governance. Interviewers listen for collaboration, pragmatism, user empathy, and an ability to improve consistency without becoming a design system police officer.
No question matches those filters. Reset filters.
Showing 60 of 252 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 CS fundamentals (45%) and DSA (40%).
Candidate interviews show an average of 4.4 rounds per experience, with a typical sequence of Online test → Technical → Technical → Technical → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 39%, medium 55%, hard 6%.
