‹ Back to previous section Course home All page URLs

Data Structures and Algorithms Telephonic Interview Questions & Answers

30 questions for the telephonic interview stage — 15 easy, 14 medium, 1 hard.

About the telephonic interview round

The telephonic or screening round is a 15-30 minute call with a recruiter or engineer. It checks your basics, your CV and whether you can explain Data Structures and Algorithms concepts clearly without a screen to point at.

Tips for the telephonic interview round

Keep your CV in front of you and be ready to explain every line on it.
Answer in short, clear sentences; there is no whiteboard, so structure matters.
Take the call somewhere quiet and confirm the time in advance.
Prepare one question to ask the interviewer at the end.

Solved — telephonic interviewStart practicing

3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.

3 questions free Unlock the rest in seconds

What are prefix sums and what problems do they solve?

Arrays, Strings and HashingMedium

Show answer

A prefix sum array stores pre[i] as the sum of the first i elements, built in O(n). The sum of any range from l to r is then pre[r+1] minus pre[l] in O(1). Combined with a hash map of prefix sums, it counts subarrays with sum k in O(n). 2D prefix sums answer rectangle sum queries on grids, and difference arrays apply many range updates efficiently.

Packages with given weights must be shipped in order within D days. How do you find the minimum ship capacity?

Sorting, Searching and BacktrackingMedium

Show answer

The capacity lies between the heaviest package and the total weight, and if a capacity works, any larger one also works, so binary search the answer. For a candidate capacity, greedily load packages day by day, starting a new day when the next package does not fit, and count days. If the days are within D, try smaller; otherwise try larger. Time is O(n log of total weight).

Explain best, average and worst case complexity using quicksort.

Complexity Analysis and RecursionMedium

Show answer

Best case is the minimum work over inputs of size n, worst case the maximum and average case the expected work over typical inputs. Quicksort averages O(n log n) because random pivots split arrays reasonably evenly. Its worst case is O(n squared) when the pivot is always the smallest or largest element, such as sorted input with a first-element pivot. Random pivots or median-of-three make the worst case very unlikely.

How can you reduce the space used by a DP solution?

Dynamic ProgrammingMedium

Show answer

If each row of the table depends only on the previous row, keep two rows or even a single array, reducing O(n times m) space to O(m). Fibonacci-like problems need only the last two values, so O(1). For 0/1 knapsack in one array, iterate capacity from high to low so each item is used once; for unbounded knapsack iterate low to high. The trade-off is that reconstructing the actual solution becomes harder.

Explain directed, undirected, weighted graphs and DAGs.

Graphs and Graph AlgorithmsEasy

Show answer

In an undirected graph edges work both ways, like friendships. In a directed graph edges have direction, like follows or web links. A weighted graph attaches a cost to each edge, like distance or price, which matters for shortest path algorithms. A DAG is a directed acyclic graph with no cycles; it models dependencies such as course prerequisites or build steps and allows topological ordering and linear-time shortest paths.

What is the load factor of a hash table and why does it matter?

Arrays, Strings and HashingMedium

Show answer

Load factor is the number of stored entries divided by the number of buckets. As it rises, collisions increase and operations slow down. Java HashMap resizes when the load factor passes 0.75, doubling buckets and rehashing every entry, which costs O(n) occasionally but keeps operations O(1) amortised. If you know the final size, set the initial capacity to avoid repeated resizing in performance-sensitive code.

Compare Kruskal's and Prim's algorithms for minimum spanning trees.

Graphs and Graph AlgorithmsMedium

Show answer

Both find a minimum spanning tree, the cheapest set of edges connecting all vertices. Kruskal sorts all edges by weight and adds each edge if it joins two different components, checked with Union-Find, O(E log E); it suits sparse graphs given as edge lists. Prim grows the tree from a start vertex, always adding the cheapest edge leaving the tree using a min-heap, O(E log V), which suits dense graphs with adjacency lists.

Explain basic binary tree terminology: root, leaf, height and depth.

Trees and Binary Search TreesEasy

Show answer

The root is the top node with no parent. A leaf has no children. The depth of a node is the number of edges from the root to it, and the height of a node is the number of edges on the longest path down to a leaf; the tree's height is the root's height. In a binary tree each node has at most two children. A tree with n nodes has n minus 1 edges.

What is the difference between full, complete and perfect binary trees?

Trees and Binary Search TreesEasy

Show answer

In a full binary tree every node has zero or two children. In a complete binary tree every level except possibly the last is completely filled, and the last level is filled from the left, which is exactly the shape of a binary heap and allows array storage. A perfect binary tree has all internal nodes with two children and all leaves at the same level, containing 2 to the power h plus 1, minus 1 nodes.

What is the two pointer technique and when is it used?

Arrays, Strings and HashingEasy

Show answer

Two pointers move through an array or string, often from both ends or at different speeds, to avoid nested loops. On a sorted array you can find a pair with a given sum in O(n) by moving left or right depending on the current sum. It is also used for reversing, removing duplicates in place, merging sorted arrays, palindrome checks and partitioning. It usually needs sorted data or a monotonic condition.

Implement fast exponentiation to compute x to the power n in O(log n).

Complexity Analysis and RecursionMedium

Show answer

def power(x, n): if n < 0: x, n = 1 / x, -n result = 1 while n > 0: if n & 1: # odd bit set: multiply current base in result *= x x *= x # square the base n >>= 1 # move to next bit return result # power(2, 10) == 1024; use % mod after each multiply for modular power

What is a dummy or sentinel node and why is it useful in linked list problems?

Linked Lists, Stacks and QueuesMedium

Show answer

A dummy node is an extra node placed before the real head. It removes special cases for operations that may change the head, such as deleting the first element, merging lists or inserting at the start. You build the result after dummy and return dummy.next at the end. This leads to shorter, less error-prone code, which matters a lot when writing linked list solutions under interview pressure.

A problem has n up to 100000. Which time complexities are acceptable for a 1-second limit?

Complexity Analysis and RecursionMedium

Show answer

A common rule is that judges run about 10 to the power 8 simple operations per second. With n equal to 10 to the power 5, O(n log n) is about 1.7 million operations and O(n) is trivial, both fine. O(n squared) is 10 to the power 10 operations, far too slow. So I would look for sorting, hashing, two pointers, binary search or prefix sums rather than nested loops over all pairs.

What is the difference between a linked list and an array?

Linked Lists, Stacks and QueuesEasy

Show answer

An array stores elements contiguously, giving O(1) index access and good cache performance, but inserting or deleting in the middle costs O(n) because elements shift. A linked list stores nodes with pointers to the next node, so insertion and deletion at a known node are O(1), but finding the i-th element takes O(n) and each node has pointer overhead. Arrays suit read-heavy work, lists suit frequent splicing.

What is the Dutch National Flag algorithm?

Arrays, Strings and HashingMedium

Show answer

It sorts an array of three distinct values, such as 0, 1 and 2, in one pass with O(1) space. It keeps three pointers: low, mid and high. If arr[mid] is 0, swap it with arr[low] and advance both; if 1, advance mid; if 2, swap it with arr[high] and decrease high without advancing mid. It runs in O(n) and is the basis of three-way partitioning in quicksort.

A bug appeared somewhere in the last 1000 commits. How would you find the commit that introduced it quickly?

Sorting, Searching and BacktrackingEasy

Show answer

Commits form an ordered sequence where everything after the bad commit fails and everything before passes, which is a monotonic condition, so binary search applies. Test the middle commit; if it fails, search the earlier half, otherwise the later half. About 10 tests find the culprit among 1000 commits. git bisect automates this, and git bisect run can execute a test script at each step.

What does binary search on the answer mean?

Sorting, Searching and BacktrackingHard

Show answer

Instead of searching an array, you binary search over possible answers when there is a monotonic feasibility check: if capacity X works, any larger capacity also works. Examples include minimum ship capacity to deliver within D days, minimum eating speed, or the largest minimum distance between placed items. Each check is often O(n) greedy, so total time is O(n log of the answer range), which is very efficient.

A metro app must find the route with the fewest stations between two stops. Which algorithm would you use?

Graphs and Graph AlgorithmsEasy

Show answer

If every hop counts equally, the network is an unweighted graph and BFS from the source gives the minimum number of stations in O(V plus E). I would store a parent for each visited station to reconstruct the path. If the goal changes to minimum travel time with different segment durations or interchange penalties, I would switch to Dijkstra with those weights, adding interchange cost as edges between line nodes.

What is the diameter of a binary tree and how do you compute it efficiently?

Trees and Binary Search TreesMedium

Show answer

The diameter is the number of edges on the longest path between any two nodes, which may not pass through the root. Compute it in one postorder traversal: for each node, get the heights of the left and right subtrees, update a global best with left plus right, and return 1 plus the larger height to the parent. This visits each node once, giving O(n) time instead of O(n squared) from recomputing heights.

List common complexity classes from fastest to slowest with examples.

Complexity Analysis and RecursionEasy

Show answer

O(1): array index access or a hash lookup on average. O(log n): binary search. O(n): linear scan. O(n log n): merge sort and heap sort. O(n squared): nested loops over pairs, as in bubble sort. O(2 to the power n): generating all subsets. O(n factorial): generating all permutations. For n around one lakh, anything up to O(n log n) is comfortable, while O(n squared) usually times out.

How does merge sort work and what are its properties?

Sorting, Searching and BacktrackingMedium

Show answer

Merge sort splits the array into halves, recursively sorts each half and merges the two sorted halves in linear time. The recurrence T(n) = 2T(n/2) + n gives O(n log n) in every case. It is stable and works well for linked lists and external sorting of large files, but needs O(n) extra space for arrays. It also adapts to counting inversions during the merge step.

Solve house robber: maximise money robbed from houses in a row without robbing two adjacent houses.

Dynamic ProgrammingEasy

Show answer

def rob(nums): take, skip = 0, 0 # best if the previous house is taken or skipped for x in nums: take, skip = skip + x, max(take, skip) return max(take, skip) # rob([2, 7, 9, 3, 1]) -> 12 (2 + 9 + 1) # dp[i] = max(dp[i-1], dp[i-2] + nums[i]); O(n) time, O(1) space

How can you implement a queue using two stacks, and what is its complexity?

Linked Lists, Stacks and QueuesMedium

Show answer

Use an in-stack for enqueue and an out-stack for dequeue. Enqueue pushes onto the in-stack in O(1). For dequeue, if the out-stack is empty, pop everything from the in-stack and push it onto the out-stack, which reverses the order, then pop from the out-stack. Each element moves at most once between stacks, so dequeue is O(1) amortised even though a single transfer can be O(n).

Tell me about a time you worked with people from other teams to solve a complex problem.

Graphs and Graph AlgorithmsMedium

Show answer

Situation: delivery route suggestions in our app were slow and the data team blamed the backend while we blamed the data. Task: find the real issue. Action: I set up a joint session, we traced one slow request end to end and found the graph was rebuilt from raw tables on every call. I proposed caching the adjacency lists, and the data team added change notifications. Result: response time dropped from 3 seconds to 200 milliseconds.

What is backtracking?

Sorting, Searching and BacktrackingEasy

Show answer

Backtracking builds a solution step by step and abandons a partial solution as soon as it cannot lead to a valid answer, then undoes the last choice and tries the next. It is a DFS over the space of choices. It solves permutations, combinations, subsets, N-Queens, Sudoku and word search. The worst case is often exponential, so good pruning, such as checking constraints early, is what makes it practical.

What is a heap and how is it stored in an array?

Heaps, Priority Queues and GreedyEasy

Show answer

A binary heap is a complete binary tree where every parent is smaller than its children in a min-heap or larger in a max-heap, so the root is the minimum or maximum. Because the tree is complete, it is stored in an array without pointers: for index i, children are at 2i plus 1 and 2i plus 2 and the parent at (i minus 1) divided by 2. This layout is compact and cache friendly.

What is the difference between a subarray, a subsequence and a substring?

Arrays, Strings and HashingEasy

Show answer

A subarray is a contiguous part of an array, and an array of n elements has n times n plus 1 over 2 of them. A substring is the same idea for strings. A subsequence keeps the original order but may skip elements, so there are 2 to the power n of them. This matters for choosing techniques: sliding window and prefix sums suit subarrays, while subsequence problems often need dynamic programming.

How does binary search work and what does it require?

Sorting, Searching and BacktrackingEasy

Show answer

Binary search works on sorted data or any monotonic condition. Compare the middle element with the target; if equal, return it, if the target is smaller search the left half, otherwise the right half. Each step halves the search space, giving O(log n) time, so a million elements need about 20 comparisons. It requires random access, so it suits arrays but not linked lists.

What is the difference between memoisation and tabulation?

Dynamic ProgrammingEasy

Show answer

Memoisation is top-down: write the natural recursion and cache results in a map or array, so only needed states are computed, but recursion depth can be a problem. Tabulation is bottom-up: fill a table iteratively from base cases in an order where dependencies are ready, avoiding recursion overhead and making space optimisation easier. Both usually have the same time complexity; choose whichever is clearer for the problem.

Compare singly, doubly and circular linked lists.

Linked Lists, Stacks and QueuesEasy

Show answer

A singly linked list node points only to the next node, using less memory but allowing traversal in one direction. A doubly linked list node also points to the previous node, enabling backward traversal and O(1) deletion of a given node, which LRU caches need. A circular list connects the last node back to the first, useful for round-robin scheduling and buffers. Each extra pointer adds memory and update complexity.

Frequently asked questions

What happens in the Data Structures and Algorithms telephonic interview round?

How do I clear the telephonic interview round?

Keep your CV in front of you and be ready to explain every line on it. Answer in short, clear sentences; there is no whiteboard, so structure matters. Take the call somewhere quiet and confirm the time in advance.

Which round comes next?

A typical order is online assessment, telephonic screening, one or two technical rounds, a managerial round and HR. Use the other round pages to practise each stage.

Practise every interview round

Online Assessment questions Technical Round questions Managerial Round questions Rapid-Fire questions HR & behavioural questions Full mock interview

More ways to practise

Company-wise Data Structures and Algorithms questions Experience-wise Data Structures and Algorithms questions Role-wise Data Structures and Algorithms questions City-wise Data Structures and Algorithms questions Most asked Data Structures and Algorithms questions Scenario-based questions Practical / hands-on questions HR & behavioural questions Data Structures and Algorithms mock interview Online assessment questions Technical round questions Managerial round questions Data Structures and Algorithms topic sheets