Tip 1 : Have your Concepts of Core Subjects Cleared.
Tip 2 : Keep atleast 1 good Project Ready (MERN is Preffered) with complete understanding.
Tip 3 :Solve Atleast 200 DSA questions(200 because by solving 200 questions you are more than capable to crack Company).
Tip 1: Have atleast 1 Good Project.
Tip 2:Mention about your previous Internships and Certifications.
It was in the Afternoon from 2.30PM to 5.00 PM. It comprised of MCQs and 2 Coding Questions. The first question was Medium level (Stack & Queues, Hashmap) and the Second one was Hard Level (Trees).



Symbol Value
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
3 is written as III in Roman numeral, just three ones added together. 13 is written as XIII, which is simply X + III. The number 25 is written as XXV, which is XX + V
A number in Roman Numerals is a string of these symbols written in descending order(e.g. M's first, followed by D's, etc.)




You need to return the head to the doubly linked list.
The doubly linked list would be: 1 2 3 4 5 and can be represented as:

The idea is to do in-order traversal of the binary tree. While doing inorder traversal, keep track of the previously visited node in a variable, say prev. For every visited node, make it next to the prev and set previous of this node as prev.
It was in afternoon. The interviewer asked me to introduce myself and then jump directly to the questions. Interviewer asked me about my preferred language I said Java. He asked OOPs Concepts and OS. Then Interviewer asked me to solve basic questions of Linked list such as Reverse of Linked List, Find Loops in Linked List etc. Interviewer asked me different approaches and asked me to optimize them.



The given linked list is 1 -> 2 -> 3 -> 4-> NULL. Then the reverse linked list is 4 -> 3 -> 2 -> 1 -> NULL and the head of the reversed linked list will be 4.
Can you solve this problem in O(N) time and O(1) space complexity?
The idea is to reverse the link between nodes to reverse the list. This is done by changing the connections directions in reverse order. We just need to change the direction of the links using three pointers curr, prev, and next.
Initialize three pointers prev as NULL, curr as head and next as NULL.
Iterate through the linked list. In loop, do following.
Before changing next of current, store next node
next = curr->next
Now change next of current, This is where actual reversing happens
curr->next = prev
Move prev and curr one step forward
prev = curr
curr = next



In the given linked list, there is a cycle, hence we return true.

This algorithm is used to find a loop in a linked list. It uses two pointers one moving twice as fast as the other one. The faster one is called the faster pointer and the other one is called the slow pointer.
Traverse linked list using two pointers.
Move one pointer(slow_p) by one and another pointer(fast_p) by two.
If these pointers meet at the same node then there is a loop. If pointers do not meet then the linked list doesn’t have a loop.
The Interviewer ansked me to Introduce myself and then he directly jumped to Questions. The round was all about Problem Solving Skills.



Initialize the variables max_so_far = arr[0](stores the maximum sum of contiguous subarray found so far) and max_ending_here = 0(that stores the maximum sum contiguous subarray ending at current index)
Run a for loop from 0 to N-1 and for each index i:
Add the arr[i] to max_ending_here.
If max_so_far is less than max_ending_here then update max_so_far to max_ending_here.
If max_ending_here < 0 then update max_ending_here = 0
Return max_so_far



The Linked Lists, where a1, a2, c1, c2, c3 is the first linked list and b1, b2, b3, c1, c2, c3 is the second linked list, merging at node c1.

1. Traverse the first linked list(count the elements) and make a circular linked list. (Remember the last node so that we can break the circle later on).
2. Now view the problem as finding the loop in the second linked list. So the problem is solved.
3. Since we already know the length of the loop(size of the first linked list) we can traverse those many numbers of nodes in the second list, and then start another pointer from the beginning of the second list. we have to traverse until they are equal, and that is the required intersection point.
4. remove the circle from the linked list.
This was the Final round and it was with the Cheif Technical Officer. It Comprised mainly of Project Discussion which I had mentioned in my resume.
Introduce yourself
Explain your projects.
What technologies you used in your projects

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
Which keyword is used for inheritance?