Tip 1: Practice data structure questions as much as you can. Also, be confident in your solution during the interview. For practice, you can refer to Coding Ninjas and CodeStudio.
Tip 2: Read about previously asked questions by the company.
Tip 1: Keep it concise. Mention the academic and professional projects you have completed. Include your educational details accurately, along with the percentage or CGPA obtained.
Tip 2: Include only the information in your resume that you are confident about and keep practicing.
This round was held after the project assessment round. The interviewer asked for a quick introduction and then moved on to DSA questions.



1. Each node is associated with a unique integer value.
2. The node for which the successor is to be found is guaranteed to be part of the tree.
An inorder traversal of a BST produces a sorted sequence. Therefore, we perform an inorder traversal. The first encountered node with a value greater than the node is the inorder successor.



For the given 5 intervals - [1, 4], [3, 5], [6, 8], [10, 12], [8, 9].
Since intervals [1, 4] and [3, 5] overlap with each other, we will merge them into a single interval as [1, 5].
Similarly, [6, 8] and [8, 9] overlap, merge them into [6,9].
Interval [10, 12] does not overlap with any interval.
Final List after merging overlapping intervals: [1, 5], [6, 9], [10, 12].
Sort all intervals in increasing order of start time.
Traverse the sorted intervals starting from the first interval.
Do the following for each interval:
If the current interval is not the first interval and it overlaps with the previous interval,
merge it with the previous interval. Keep merging while the interval overlaps with the previous one.
Otherwise, add the current interval to the output list of intervals.
In this round, the interviewer asked about the assignment conducted in the preliminary round and the projects I have worked on. After that, he asked me some questions about computer subjects and gave me two DSA questions.


Consider the array ARR = [ 1, 4, 2, 6 ] having 4 elements.
The array containing the Least Greater Elements for the above array will be [ 2, 6, 6, -1 ].
First, we take an array of pairs, namely temp, and store each element along with its index in this array, i.e., temp[i] will store {arr[i], i}.
Next, sort the array based on the array elements.
Then, determine the next greater index for each index in the temp array using the Next Greater Element approach with a stack, and store these indices in another array called index.
Now, index[i] will store the index of the next least greater element for the element temp[i].first. If index[i] is -1, it indicates that there is no least greater element for the element temp[i].second to its right.
Finally, create a result array where result[i] will be equal to arr[index[temp[i].second]] if index[i] is not -1. Otherwise, result[i] will be equal to -1.



Input: Linked List: 1 <-> 2 <-> 2 <-> 2 <-> 3
Output: Modified Linked List: 1 <-> 2 <-> 3
Explanation: We will delete the duplicate values ‘2’ present in the linked list.
Traverse the list starting from the head (or start) node. While traversing, compare each node with its next node. If the data of the next node is the same as that of the current node, delete the next node. Before deleting a node, store the next pointer of the node.

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
What is the purpose of the return keyword?