Tip 1: The number of questions solved doesn't matter; your thinking ability does. For some people, 150 questions are enough, while for others, even 1000 may not be enough. Just focus on improving your problem-solving skills. If you solve an average of 250 questions, it is enough.
Tip 2: CGPA matters. Keep your CGPA above 9 to at least get shortlisted in most companies. I have seen people with a CGPA of 8.8 struggle because of their CGPA.
Tip 3: Do at least two projects. Add at least one problem that you genuinely solved in your project; even an easy one will work. Keep those projects in mind.
Tip 1: You should have at least two good projects on your resume in which you have solved at least one real-world problem. If you are adding GitHub links to the projects, make sure you have worked with Git, and there should be commits. This shows that you have truly worked on your project independently and have knowledge of how SDLC works.
Tip 2: Do not put random skills or false information on your resume. Only include things you are confident enough to answer at least basic questions about.
It was a proper setting on campus to conduct the OA, with invigilators from both the campus and the company.


1. If the list is empty, the function immediately returns None because there is no middle node to find.
2. If the list has only one node, then the only node in the list is trivially the middle node, and the function returns that node.
Step 1: Traverse the linked list using a slow pointer (slow_ptr) and a fast pointer (fast_ptr).
Step 2: Move the slow pointer to the next node (one node forward) and the fast pointer to the next of the next node (two nodes forward). When the fast pointer reaches the last node or becomes NULL, the slow pointer will reach the middle of the linked list.
In the case of an odd number of nodes in the linked list, slow_ptr will reach the middle node when fast_ptr reaches the last node. In the case of an even number of nodes, slow_ptr will reach the middle node when fast_ptr becomes NULL.



If N = 5 and arr[ ] = {1, 2, 3, 4, 5} then output will be 5 1 2 3 4.
If N = 8 and arr[ ] = {9, 8, 7, 6, 4, 2, 1, 3} then output will be 3 9 8 7 6 4 2 1.
Step 1: Reverse the array twice.
Step 2: First, reverse the first n−1 elements (n being the size of the array).
Step 3: Finally, obtain the rotated array by reversing the entire array.



Here, sorted paths mean that the expected output should be in alphabetical order.
Given a square matrix of size 4*4 (i.e. here 'N' = 4):
1 0 0 0
1 1 0 0
1 1 0 0
0 1 1 1
Expected Output:
DDRDRR DRDDRR
i.e. Path-1: DDRDRR and Path-2: DRDDRR
The rat can reach the destination at (3, 3) from (0, 0) by two paths, i.e. DRDDRR and DDRDRR when printed in sorted order, we get DDRDRR DRDDRR.
We use a backtracking algorithm to explore all possible paths. While exploring the paths, we keep track of the directions we have moved so far, and when we reach the bottom-right cell, we record the path in a vector of strings.



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.
1. Check if the list has fewer than nodes or only one node; if so, return the list as is.
2. Create a dummyNode with dummyNode.next = head to simplify reconnections.
3. Traverse the list in chunks of nodes: Use pointers to mark the start of each -group, Count nodes to ensure there’s a complete group for reversal.
4. For each -group, use a helper reverse function to reverse the group.
5. Link the reversed group back to the main list using the dummyNode.
6. Move pointers to the start of the next -group and repeat.
After all groups are processed, return dummyNode.next as the new head of the modified list.
Suppose that we wish to know which stories in a 100-story building are safe for dropping eggs and which will cause the eggs to break upon landing. What strategy should be used to drop the eggs such that the total number of drops in the worst case is minimized, and we find the required floor?
We may make a few assumptions:
Tip 1: Solve the top 100 puzzles for interviews from CN. Interviews mostly ask only famous puzzles.
What happens when you type google.com and hit enter?
Tip 1: Solve the top Computer Networks, OS, and DBMS questions from Coding Ninja.
It was the last round, with almost 10 candidates selected for it.
What is a cache? Design a cache. Consider all cases and use cases, and cover as many of them as possible while designing it. For example, if a website's data is cached in the browser, how does the browser detect when the website is updated from the backend? (Learn)
Tip 1: Study Computer Networks.
Tip 2: Make sure to solve or watch some low-level system design videos featuring well-known use cases.

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