0 min read
Nagarro is one of the biggest IT firms in India. If you want to be a part of this tech giant, then this article could be of great help to you. We have covered some of the most important technical as well as HR round questions that will help you prepare well and bag a job at Nagarro Software.
Nagarro hires freshers and experienced people, both in four different ways. The hiring is done on-campus, off-campus, through employee referrals, or by applying on the career portal.
There are four rounds conducted by Nagarro to choose the right candidates for the offered roles:
Round 1: Online Test (Aptitude + Technical) - You need to solve technical and aptitude questions. There will be 40 MCQ questions to be solved within an hour.
Round 2: Online Coding Test - An online 3-hour coding test of medium to hard difficulty having five questions related to data structures and one related to algorithms. Concepts related to Java programs from tree, graph, string, and array will be asked as questions. The approach will be mostly on dynamic programming testing your coding skills.
Round 3: Technical Interview - The 1-hour test with coding questions from SQL Query, data structures and algorithms, operating systems, computer networks, database management systems, object-oriented programming, and programming language (Java preferred) will be conducted.
Round 4: HR Interview - This involves a general conversation with HR, where behavioral questions would be asked. It is a non-elimination round. Following are some examples of questions asked in this round.
The HR interviewer begins by asking basic questions. You will be grilled for checking whether you are the right fit for the job. For experienced candidates, questions about your previous work experience will be asked like:
Be genuine, without being too deep and delicate. Tell the interviewer about any specific achievement that is connected to a job-relevant skill that you have.
Tell the interviewer about your matching skills that are relevant to the job. Highlight a connection between you and the company principles.
Explain your skills and accomplishments in a way that highlights why you are the best choice for the job.
Highlight your past accomplishments and tell the interviewer how you have evolved.
By asking about your greatest strength, the interviewer is trying to unearth what makes you special, both skill-wise and personality-wise.
This question gives the interviewer an insight into your motivation.
Employers need to know how you deal with conflicts and challenges with teamwork, loyalty, and teamwork.
Employers want to find out how you behave in a high-pressure situation.
It need not be a big move. It could be something small like asking your supervisor how they want things to be organized.
Speak about your hobbies and explain how these activities help you to relieve stress.
Downplay this question and simply say that you want to change career paths or want to learn something new.
Do not go talking about the company and its services at length. The aim here is to understand how much you have studied about the company before applying. Keep it short and restricted to the top points.
First of all, this question is applicable if you have a gap in your resume. In that case, be honest and explain the reason for that gap calmly.
First, understand that this question is asked to learn whether you are compatible with the company culture. So, there is no right or wrong answer here. Just be diplomatic and give a very generic answer.
This question is asked to see how honest you are about yourself. So, be humble and honest about where you lack in terms of your work. This makes a positive impression.
The idea behind this question is to understand what you think of yourself. So, do not give a 10 out of 10 as it projects overconfidence and no scope for improvement. Also, do not undervalue yourself. Rather assign a score that is in between.
Even though it comes across as a simple question about your ambition, it is a ploy to understand how long you plan to stay in a company. So, answer carefully and explain how you see your future with this company.
This section consists of numerical ability and verbal reasoning questions. Given below are some questions in this section:
a) 630
b) 610
c) 640
d) 620
Answer: a) 630
Explanation: The population in 2007 was 480
Population in 2008 = 1.05 × 480 = 504
Population in 2009 = 1.25 × 504 = 630
a) ₹ 80,000
b) ₹ 59,000
c) ₹ 1,10,000
d) ₹ 77,000
Answer: d) ₹ 77,000
Explanation: Let the initial salary of Hiren be ‘x’. Then:
(0.55 × 0.4) x = 15400 => x = 70000
After increment, Hiren’s salary = 1.1 × 70000 = 77000
a) 10 liters
b) 20 liters
c) 15 liters
d) 30 liters
Answer: b) 20 liters
Explanation: Milk ratio : water in Jar A = 120 : 24 = 5 : 1
12 liters of this mixture is taken out => milk = 5/6 × 12 = 10 liters and water = 2 liters is taken out
3 liters of water is added = 24 – 2 + 3 = 25 liters => new ratio of milk : water
= 110 : 25 = 22 : 5
Now, 27 liters of this mixture is again taken out =>
water taken out = 5 / 27 × 27 = 5 liters
water left = 25 – 5 = 20 liters
a) 10 km/h
b) 6 km/h
c) 5 km/h
d) 4 km/h
Answer: c) 5 km/h
Explanation: Speed of boat = 15 km/h
Let the speed of the stream be ‘x’
Given: 30/(15+x) + 30/(15-x) = 9/2
By solving this, we get, x = 5 km/h
In the technical test, the questions can be asked mostly from data structures and algorithms, along with some computer fundamentals. The questions are like this:
a) Abstract Level
b) Implementation Level
c) Application Level
d) All of the above
Answer: d) All of the above
a) NCP
b) ISDN
c) HDLC
d) LCP
Answer: a) NCP
a) Data
b) Operation
c) Both
d) None
Answer: d) None
a) Stack
b) Queue
c) Binary Search Tree
d) Dequeue
Answer: a) Stack
a) VX Works
b) RT Linux
c) Palm OS
d) Windows CE
Answer: c) Palm OS
The stack is a data collection where data is stored one on top of another. Stacks organize with a constant backup in case of an incident.
Stack data structures are a commonly used simplified process of storing and retrieving data. It is also useful for storing several values of the same type. Another advantage of using a stack is that it makes it easier to build algorithms that perform array operations.
A data segment is a portion of the disk space that is allocated to store user data. The disk space can be divided into segments that store different types of data.
It affects the system's performance. The amount of time it takes for your computer to respond, when you press a key on your keyboard, depends on the speed of data transfer from your hard drive to the processor. If there is a logjam in one area, it can affect performance in other areas.
Dr. Edgar F. Codd established 12 rules for databases that adhered to the relational model after conducting extensive research on it. He said that a database must follow these rules in order to be considered a true relational database. These RDBMS rules are called Codd rules.
A database trigger is an SQL statement that is run when you insert, update, or delete a row in your database. It allows you to execute code before or after the data is inserted into your database. This can be useful if you want to check for certain conditions before inserting data into your database, such as making sure the value of one field does not already exist. It also checks if a user is logged in before allowing them to modify a record or deleting an existing record.
Rename is a task that changes the name of an object. Alias is a task that creates a symbolic reference for an object. Creating an alias means that you can refer to the object by a different name, but this does not change the underlying identity of the object or its value.
An abstract class is a class that is defined without any implementation. Abstract classes can be used to provide a common base for other classes or to define an interface that can be implemented by other classes.
The main advantage of using an abstract class is that it can allow programmers to write code that only needs to access the abstract methods defined in the class, while other code in the program can use the methods in the class if they are needed.
The main disadvantage of using an abstract class is that it cannot be used for any actual implementation.
Artificial intelligence (AI) is the ability of a machine to behave like a human. AI is a field in computer science that deals with the creation of machines that can perform tasks normally requiring human intelligence. AI can be used in automated planning, speech recognition, and translation.
Machine learning is different from AI because it focuses on algorithms that learn how to detect patterns in data without being explicitly programmed to do so. It is also different from AI as it does not involve creating a machine that behaves as a human would.
TCP/IP is the networking protocol that allows computers to communicate with each other over a network irrespective of location. TCP/IP is an acronym for transmission control protocol (TCP) and internet protocol (IP). Together they form the TCP/IP protocol suite, which is used to route information from one location to another over the internet.
A binary search tree (or BST) is a data structure that organizes data into two different types of nodes, which are leaves and internal nodes. Each node has a key value that uniquely identifies it. The purpose of a binary search tree is to organize data so that it can be accessed efficiently by keywords.
Cache memory serves a similar purpose as RAM in a computer. Cache memory is temporary storage that can be used to store frequently accessed data.
A critical section is a section of code in an operating system where the execution cannot proceed until all threads reach the section. If any thread attempts to access the critical section before the other threads are finished, it will be blocked until all threads have reached the section.
The data from two-dimensional arrays are in a contiguous fashion. So, how these data are to be stored in the memory are derived by the row-major order and the column-major order.
In row-major order, first, the entire row will be stored one after another in a continuous manner.
In column-major, the data in the two-dimensional matrix is represented and stored in the memory column-wise.
Private members are used for storing data, while public members are used for accessing that data. Private members are inaccessible outside of the class itself, while public members can be used by any other class in the same program. Public and private members are also referred to as "class variables" and "instance variables."
Serialization is the process of converting an object into a compact representation that can be stored and transported reliably. A serializer takes some data of type Object and converts it into another data type: String (or ByteArray) or ArrayList, etc.
Deserialization, on the other hand, is the reverse process of serialization. It is the process of converting the serialized data stream object into the actual instance of the class. Deserialization is often used to convert data back from our storage systems when we need it again.
With this above value, we can proceed with the solution. The below solution will be like this:
Home
//Method that updates the value of the grid.
public void gameOfLife(int[][] board) {
/*
A special number that we considered to count the sides with 1
1 -> 0 = -2
0 -> 0 = 0
1 -> 1 = 1
0 -> 1 = 2
*/
int m = board.length;
int n = board[0].length;
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
int count = 0;
//Counting the dead cell in the neighbor
if(i-1 >= 0){
if((j-1 >= 0) && ((board[i-1][j-1] == 1) || (board[i-1][j-1] == -2)))
count++;
if((board[i-1][j] == 1) || (board[i-1][j] == -2))
count++;
if((j+1 < n) && ((board[i-1][j+1] == 1) || (board[i-1][j+1] == -2)))
count++;
}
if(i+1 < m){
if((j-1 >= 0) && ((board[i+1][j-1] == 1) || (board[i+1][j-1] == -2)))
count++;
if((board[i+1][j] == 1) || (board[i+1][j] == -2))
count++;
if((j+1 < n) && ((board[i+1][j+1] == 1) || (board[i+1][j+1] == -2)))
count++;
}
if((j-1 >= 0) && ((board[i][j-1] == 1) || (board[i][j-1] == -2)))
count++;
if((j+1 < n) && ((board[i][j+1] == 1) || (board[i][j+1] == -2)))
count++;
//Updating the value of the grid based on the live count.
if(count == 3 && board[i][j] == 0)
board[i][j] = 2;
else if(count < 2 && board[i][j] == 1)
board[i][j] = -2;
else if(count > 3 && board[i][j] == 1)
board[i][j] = -2;
}
}
//Loop to update the value by special identification number.
for(int i = 0; i < m; i++){
for(int j = 0; j < n; j++){
if(board[i][j] == -2)
board[i][j] = 0;
else if(board[i][j] == 2)
board[i][j] = 1;
}
}
}For solving this problem, we can find the peak element and then search for the element that has the next lowest element. Then we can sort the element. The element will be the next permutation.
public void next permutation(int[] nums) {
int peakIndex = 0;
//Finding the peak index
for(int i = 1; i < nums.length; i++){
if(nums[i] > nums[i-1])
peakIndex = i;
}
//When the index is 0 the next permutation
//will be the first. So return by sorting.
if(peakIndex == 0){
Arrays.sort(nums);
return;
}
//Adjusting Pointers
int prevIndex = peakIndex - 1;
int index = prevIndex;
int currIndex = peakIndex;
//Finding the next greater element index
while(currIndex < nums.length && nums[currIndex] > nums[index]){
prevIndex = currIndex;
currIndex++;
}
//swapping the value of that location
int temp = nums[index];
nums[index] = nums[prevIndex];
nums[prevIndex] = temp;
//Changing the values by sorting
Arrays.sort(nums, index+1, nums.length);
}We can follow the approach of mathematics by the formula of (n*n + n) / 2. This calculates the actual sum that needs to be in the array. The difference will be the answer.
//Method that returns the missing value
public int missingNumber(int[] nums) {
int sumArray = 0;
int n = nums.length;
// Finding the sum of the array
for(int i = 0; i<n; i++)
sumArray += nums[i];
// Calculating actual sum.
int ActualSum = (n*n + n)/2;
return ActualSum - sumArray;
}Given the linked list, return true if there is a cycle in the linked list. Otherwise, return false.
//Method that detects the loop in the linked list.
public boolean hasCycle(ListNode head) {
if(head == null || head.next == null)
return false;
//Managing slow and fast pointers.
ListNode slow = head, fast = head;
/*
moving the pointers slow by 1 position
and fast pointer by 2. If they meet that
means there is a cycle. So return true.
*/
while(fast != null && fast.next != null){
fast = fast.next.next;
slow = slow.next;
if(slow == fast)
return true;
}
//Otherwise return false if the linked list reaches the end
return false; }Example - Input: candidates = [2,3,6,7], target = 7
Output: [[2,2,3],[7]]
This problem can be solved using the backtracking approach. So, the solution will be:
class Solution {
List<List<Integer>> ans;
//Helper method that generates the result.
private void findSum(int i, int target, List<Integer> consider, int[] candidates){
//If reaches the target then add one of the possible answers
//to the answer array and terminate the recursive call
if(target == 0){
ans.add(new ArrayList<>(consider));
return;
}
//If the index array is out of bound then terminate the call.
else if(i == candidates.length)
return;
//If the target goes negative then also terminate the call.
else if(target < 0)
return;
else{
//Skipping the element and finding the sum with the next
//Sub problem
findSum(i+1, target, consider, candidates);
//Adding the element to the list and trying the possibility
//with the element and recursively calling for the next
//sub-problem
consider.add(candidates[i]);
findSum(i, target-candidates[i], consider, candidates);
//Backtracking. Removing the element from the list and
//recursively calling for solving the next sub-problem.
consider.remove(consider.size() - 1);
}
}
public List<List<Integer>> combination(int[] candidates, int target) {
ans = new ArrayList<>();
//Calling helper function for solving the problem
findSum(0, target, new ArrayList<>(), candidates);
return ans;
}
}Example -
Input: nums = [2,3,1,1,4]
Output: true
In the above example, we can reach the last index either from the 0 indexes or 1 index.
Input: nums = [3,2,1,0,4]
Output: false
In the above example, we cannot reach the last index if any steps start from 0 so will return false.
This problem seems to be a dynamic programming problem. So, we can try all the possibilities by using the top-down approach and using memorization to optimize the recursive calls.
We can solve this problem by counting the frequency in the hash and can check if all the values in the hash are the same or not.
public boolean areOccurrencesEqual(String s) {
int max = 0;
char[] hash = new char[26];
//Counting the frequency and getting the max frequency
for(int i = 0; i < s.length(); i++){
hash[s.charAt(i)-'a']++;
max = Math.max(max, hash[s.charAt(i)-'a']);
}
//Checking if the frequency matches with the max number
for(int i = 0; i < 26; i++){
if(hash[i] != 0 && hash[i] != max)
return false;
}
return true;
}We can use a recursive approach to reverse the linked list. We can use head recursion and while returning time, we can adjust the pointers. The solution is:
class Solution {
private ListNode reverse(ListNode head){
if(head == null || head.next == null){
return head;
}
// Recursively calling function that returns the linked list for sub problem
ListNode x = reverse(head.next);
//Adjusting the pointers
head.next.next = head;
head.next = null;
return x;
}
public ListNode reverseList(ListNode head) {
//Calling helper method that returns reversed liked list
return reverse(head);
}
}We can follow the approach of dynamic programming by storing the last three values and updating the values on iteration. The solution is:
class Solution {
int trib(int n, int [] dp){
//Base case for terminating the recursive call
if(n == 0 || n == 1)
return n;
if(n == 2)
return 1;
//Finding the result not already computed
if(dp[n] == 0){
dp[n] = trib(n-1, dp) + trib(n-2, dp) + trib(n-3, dp);
}
//Returning already computed result or the result that
//latest computed
return dp[n];
}
public int tribonacci(int n) {
int []dp = new int[n+1];
//Calling helper method that computes and returns the result.
return trib(n, dp);
}
}Nagarro Software is a business consultation and software development organization established in Munich, Germany, in 1996. It came to India and made its headquarters in Gurugram, Uttar Pradesh. There are operational office locations in Europe, Asia, and North America. From 2011 to 2016, Nagarro Software underwent multiple mergers, and presently, it has a workforce of over 3,000 employees.
More Reads:
And access exclusive content, personalized recommendations, and career-boosting opportunities.
to our newsletter
Comments
Add comment