50 Nagarro Interview Questions 2024- HR & Technical (With Answers)

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.

• Aptitude Section - 15 MCQs from numerical reasoning, verbal reasoning, general aptitude, and logical reasoning tests.
• Technical Section -  25 MCQs from data structures and algorithms will be asked.

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.

Nagarro HR Interview Questions

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:

1. Tell us about yourself.

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.

2. Why do you want to work for Nagarro?

Tell the interviewer about your matching skills that are relevant to the job. Highlight a connection between you and the company principles. 

3. Why should we hire you?

Explain your skills and accomplishments in a way that highlights why you are the best choice for the job.

4. Sum up your previous work experience.

Highlight your past accomplishments and tell the interviewer how you have evolved.

5. What is your greatest strength?

By asking about your greatest strength, the interviewer is trying to unearth what makes you special, both skill-wise and personality-wise.

6. Why do you want this job?

This question gives the interviewer an insight into your motivation.

7. Tell me about an instance when teamwork and loyalty were shown by you.

Employers need to know how you deal with conflicts and challenges with teamwork, loyalty, and teamwork.

8. Tell me about a time when you had to work with someone difficult.

Employers want to find out how you behave in a high-pressure situation.

9. Tell me about an instance when you took initiative and showed courage.

It need not be a big move. It could be something small like asking your supervisor how they want things to be organized.

10. What are the go-to activities that you enjoy?

Speak about your hobbies and explain how these activities help you to relieve stress.

11. Why do you want to leave your current job?

Downplay this question and simply say that you want to change career paths or want to learn something new.

12. What do you know about Nagarro's products and services?

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.

13. What is your explanation of the gap in your resume?

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.

14. Describe your ideal workplace.

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.

15. What are your weaknesses?

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.

16. How would you rate yourself as a professional out of 10?

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.

17. Where do you see yourself in the next five years?

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.

Nagarro Aptitude Test Questions

This section consists of numerical ability and verbal reasoning questions. Given below are some questions in this section:

18. A village's population increased by 5% from 2007 to 2008 and by 25% from 2005 to 2009. From what amount, proportionate to 480, did the population grow?

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

19. Hiren allocated 45% of his monthly pay to paying bills and rent in March. He then invested 60% of his extra cash into the PPF scheme and kept the remaining 20%. He deposited $15,400 into his bank account. If his salary increased by 10% in April, what was it?

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

20. 120 liters of milk was mixed with 24 liters of water in Jar A. 12 liters of the resulting mixture was withdrawn and 3 liters of water was added. How many liters of the new mixture will be produced if 27 liters of the resulting substance is removed?

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

21. A boat travels 30 km downstream at 15 km per hour and returns upstream in 4 hours and 30 minutes. What is the downstream speed of the boat?

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

Nagarro Technical Test Questions 

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:

22. What are the levels of data structure implementation?

a) Abstract Level
b) Implementation Level
c) Application Level
d) All of the above

Answer: d) All of the above

23. Using what protocol, does the PPP identify the network layer protocol?

a) NCP
b) ISDN
c) HDLC
d) LCP

Answer: a) NCP

24. What is missing from the abstract data type description?

a) Data
b) Operation
c) Both
d) None

Answer: d) None

25. Which structure enables both deleting data items and adding them at the back?

a) Stack
b) Queue
c) Binary Search Tree
d) Dequeue

Answer: a) Stack

26. Find the operating system that is not a real-time operating system.

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.

• PL/SQL is a procedural programming language that runs on top of the SQL database. It has its syntax, but it can also be used with SQL to access the full range of database features. PL/SQL is often used for business applications because it is capable of performing more complicated tasks than SQL alone.
• One key advantage of PL/SQL is its ability to run on top of a relational database, giving it access to all the data integrity and security features that are available in SQL. Another advantage is its ability to work with other languages, such as HTML and cascading style sheets (CSS).

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.

• Information Rule
  Every piece of data stored in a database must be represented as a value of a table cell. It is imperative to keep everything in a table format.
• Guaranteed Access Rule
  Every data element/value that is present in the database can be accessed logically using a table name, primary key (row_value), and attribute name (column_value). No pointers or other techniques may be used to access the data.
• Systematic Treatment of NULL Values
  It is very important to treat the NULL values in a database systematically and uniformly. This is because a NULL value may be thought of as being missing data, unconfirmed data, or nonstandard data.
• Active Online Catalog
  An online catalog of the database's structure must be maintained, known as a data dictionary. Users may query the catalog using the same query language used for accessing the database itself.
• Comprehensive Data Sublanguage Rule
  A database must be only accessible using a language that has linear syntax and it must support data definition, data manipulation, and transaction management operations, and can be used directly or through some application.
• View Updating Rule
  Every aspect of a database that may have been altered, must also be accessible to the system.
• High-level Insert, Update and Delete Rule
  It is necessary for a database to support high-level insertion, deletion, and updating of data records. The database does not need to support only a single row of data, that is, it must also support the union, intersection, and negation operations to yield sets of data records.
• Physical Data Independence
  Accessing a database should not depend on the physical structure of the database. Any change in the physical structure of a database should not affect how the data is accessed by external applications.
• Logical Data Independence
  A database must maintain logical data that is independent of the way it is used by applications. When two tables are combined or one is split into two new tables, there should be no effect on the applications.
• Integrity Independence
  It is critical for a database that is used by an application to be independent of the application and interface. Integrity constraints of the database can be altered without modifying the application.
• Distribution Independence
  The data should always appear to be located at a single location to end users. This fundamental design principle has been built upon the notion that users should never be able to see that data is distributed across various locations.
• Non-subversion Rule
  A system's interface must not be able to subvert the system and bypass security and integrity constraints if the interface provides low-level access to records.

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."

41. What are serialization and deserialization OOPs?

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.

• When a live cell has fewer than two live neighbors, it dies because of being under-populated.
• A cell with two or three living neighbors survives to the next generation.
• An overcrowded 1 live cell kills off any cells with more than three live neighbors.
• Whenever a dead cell comes across three live cells, it becomes alive again by reproduction.
• The current state is computed by applying the above rules to every cell in the m x n grid board in succession. Write a program to return to the next state.

With this above value, we can proceed with the solution. The below solution will be like this:

            //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 example - the next permutation of arr = [1,2,3] is [1,3,2].

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; }
        

You may choose the same number from the candidates array an unlimited number of times. Whether two combinations are unique depends on the frequency of at least one of the chosen numbers.

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> ans;
   //Helper method that generates the result.
   private void findSum(int i, int target, List 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> combination(int[] candidates, int target) {
       ans = new ArrayList<>();
       
       //Calling helper function for solving the problem
       findSum(0, target, new ArrayList<>(), candidates);
       return ans;
   }
}
        

You are initially in the first position. Write a program that returns true if it reaches the last index from the first index. Otherwise, return false. 

Example -   

1. 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.

2. 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 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);
   }
}
        

About Nagarro

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:

1. Top L&T Interview Questions With Answers (2022) To Help You Ace Your Job Interview!
2. Top Uber Interview Questions With Answers 2022 (For Freshers & Experienced)
3. Best Paypal Interview Questions To Take You A Step Closer To Your Dream Job!
4. Top DXC Technology Interview Questions With Answers (2022)