Tip 1 : Prepare System Design.
Tip 2 : Practice DSA Questions properly.
Tip 3 : Practice OOPS and DBMS Concepts.
Tip 1 : At least 4 projects on Resume
Tip 2 : Do not write false things. You always get caught. Be genuine.
First an introduction took place between both of us, then interviewer asked me about my internship experience and then asked 2 DSA questions.



In the below histogram where array/list elements are {2, 1, 5, 6, 2, 3}.
The area of largest rectangle possible in the given histogram is 10.
For any bar i the maximum rectangle is of width r - l - 1 where r - is the last coordinate of the bar to the right with height h[r] >= h[i] and l - is the last coordinate of the bar to the left with height h[l] >= h[i].
So, if for any i co-ordinate we know his utmost higher (or of the same height) neighbors to the right and to the left, we can easily find the largest rectangle.




For the above-linked list, if k=2, then the value at the kth i.e second node from the end is ‘12’.
1.You don’t need to take any input. It has already been taken care of. Just implement the given function and return a pointer pointing to the k-th element from the last of the linked list.
2.It is guaranteed that k<=size of the linked list.
Take two nodes, slowPtr and fastPtr, such that both point to the head. Take one node to store the head; initially, it is a dummy node (start), and the next of this node will point to the head. The dummy node is used to handle the edge case where B = N (the size of the LinkedList). Start traversing until the fast pointer reaches the nth node. Then, traverse one step at a time with both pointers until the fast pointer reaches the end. When the traversal is complete, delete the next node of slowPtr. Return the next of start.
This round was conducted on Google Meet. A lot of questions about Java were asked, as I mentioned it as my skill, and the team for which I was interviewing worked on microservices in Java, Spring Boot, and 2 DSA questions were asked as well.



1. If you encounter a situation when 'B[i]' is greater than the number of remaining nodes in the list, then simply reverse the remaining nodes as a block and ignore all the block sizes from 'B[i]'.
2. All block sizes are contiguous i.e. suppose that block 'B[i]' ends at a node cur, then the block 'B[i+1]' starts from the node just after the node cur.
Linked list: 1->2->3->4->5
Array B: 3 3 5
Output: 3->2->1->5->4
We reverse the first block of size 3 and then move to block 2. Now, since the number of nodes remaining in the list (2) is less than the block size (3), we reverse the remaining nodes (4 and 5) as a block and ignore all the block sizes that follow.
The first part of this problem, reverse(), can be done using the [Easy] Reverse Linked List algorithm. However, instead of reversing the entire list, this time we are only interested in a length of K, so use reverse(head, length).
The second part of this problem involves iterating (to ensure that K groups can be formed) and attaching the reversed parts.



• Integers in each row are sorted in ascending order from left to right.
• Integers in each column are sorted in ascending order from top to bottom.
The code implements a solution class that takes a board of characters and a list of words as input. It then performs a depth-first search to determine if the words are present on the board. If a word is found, it is added to the output along with its position on the board. The code uses a visited array to keep track of the cells that have been visited during the search. Finally, the function returns a vector of strings, where each string consists of a word followed by its position on the board.
Managerial round with basic HR Questions.
Tell me about yourself.
What are your strengths and weaknesses?
Why do you want to work at our company?

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