Tip 1: Ensure thorough revision of your projects to grasp all the details solidly.
Tip 2: Prioritize a comprehensive understanding of Data Structures and Algorithms (DSA); platforms like Coding Ninjas are highly recommended for interview preparation.
Tip 3: Maintain confidence and a relaxed demeanour during the interview to effectively convey your skills and knowledge.
Tip 1: Craft a concise resume, ideally limiting it to one page, and ensure it highlights your confidently mastered skills.
Tip 2: Maintain honesty on your resume; avoid including inaccurate information.
In that particular round, there were 60 technical questions covering topics such as output-based, OOPs-based, and a portion dedicated to SQL (ranging from easy to medium difficulty). Additionally, there were ten aptitude questions of easy difficulty. There are negative markings for MCQs. If you clear this round, then only you get the link for the next round. At the last of the assessment, there was a single coding question to code.



This round consists of 3 Coding questions. You have to solve it within the given time and space complexity with proper commenting only then you will be shortlisted. I only remember two of the 3 questions asked.



1. The length of each array is greater than zero.
2. Both the arrays are sorted in non-decreasing order.
3. The output should be in the order of elements that occur in the original arrays.
4. If there is no intersection present then return an empty array.
Finding the intersection of two arrays means identifying the elements that are common to both arrays. Here are the steps to find the intersection of two arrays:
1. Create the Arrays: Start with two arrays that you want to find the intersection of. Let's call them `array1` and `array2`.
2. Initialize an Empty Result Array: You'll need a container to store the common elements. You can use an empty array or any other suitable data structure depending on your programming language.
3. Choose a Method:
- Brute Force: The simplest method is to use nested loops to compare each element of one array with each element of the other array. If an element is found in both arrays, add it to the result array.
- Optimized Methods: Depending on the programming language, you may have access to built-in functions or data structures that can optimize this process, such as sets or hash tables.
4. Iterate Through the First Array:
- If you're using nested loops, start by iterating through `array1`.
5. Compare Elements:
- For each element in `array1`, check if it exists in `array2`. You can use a nested loop for brute force or utilize the optimized methods available in your programming language.
6. Add Common Elements to Result Array:
- If an element is found in both `array1` and `array2`, add it to the result array. Ensure that you don't add duplicates if they exist in either array.
7. Iterate Through the Second Array:
- If you're using nested loops, now iterate through `array2`. This step is essential if you want to find elements that appear in both arrays regardless of their order.
8. Finalize the Result:
- If you haven't been adding elements to the result array in the previous steps (e.g. if you used sets or hash tables), make sure to finalize your result array now.
9. Result Array Contains Intersection:
- The resulting array now contains the intersection of `array1` and `array2`. It includes all the elements that are common to both arrays.
10. Handle Duplicates (Optional):
- If your arrays contain duplicate elements, and you want to eliminate duplicates from the result, you can do so by applying additional logic or using data structures that do not allow duplicates.
11. Output or Use the Intersection: Depending on your use case, you can now use, display, or manipulate the elements in the result array as needed.
Here's a simple example in Python:
```python
def find_intersection(array1, array2):
result = []
for element in array1:
if element in array2 and element not in result:
result.append(element)
return result
```
This function takes two arrays (`array1` and `array2`) as input and returns an array containing their intersection.



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?



Input : 1 -> 2 -> 3 -> 4 -> 'NULL' and 'K' = 2
Output: 1 -> 2 -> 4 -> 'NULL'
Explanation:
After removing the second node from the end, the linked list become 1 -> 2 -> 4 -> 'NULL'.




Input: 'n' = 3, 'm' = 3, 'mat' = [[1, 1, 1], [0, 0, 1], [0, 0, 0]]
Output: 0
Explanation: The row with the maximum number of ones is 0 (0 - indexed).

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