Capgemini Interview Questions

The Capgemini Recruitment Process generally consists of three rounds of selection:

• Online assessment test
• Technical interview round
• HR interview round

Online Assessment Test:

The online-based assessment test is the first step in the recruitment process. The candidates who clear this round are called for the technical interview rounds. The test is divided into 4 parts.

 The detailed online test pattern for the Capgemini recruitment process is mentioned below: 

• Pseudocoding: This is an MCQ round. Capgemini's Pseudo Code section assesses candidates' ability to answer questions that include: Understanding of programming logic (tested through Pseudocode Questions), C, C++, Java, Data Structures and Object-Oriented Programming (OOPS).
• English Communication Test: This exam will put your grammatical and vocabulary skills to the test. This is also an MCQ round. The areas to study for the English Communication test are Reading Comprehension, Para-Jumbles, Direct and Indirect Speech, Active and Passive Voice, Sentence Correction, and completion.
• Game-Based Aptitude: The Capgemini Gamified Quantitative Aptitude Test is the most interesting new stage in the Capgemini Recruitment Process. It is expected to be a series of four games to be completed. The various types of games that occur in the test are related to Deductive Logical Thinking, Inductive Logical Thinking, Grid Challenge, and Motion Challenge.
• Behavioral Competency: This round (also known as the Adaptive Employee Personality Test or ADEPT-15) is a personality psychometric designed to assess work-related behavior. The evaluation is made up of pairs of assertions. You must choose the one you agree with the most. 
  Only those candidates who have passed all three steps of the test evaluation will be invited to the interview. This round can be skipped by HR  for experienced professionals having adequate work experience and knowledge based on the company's requirements.
  The Behavioral Profiling Module is for understanding the candidate's profile, and students who complete the module will receive a work-style report.

Technical Interview Round:

The candidates who clear the online test are called for the face-to-face technical interview round.

Technical interview evaluates your technical abilities, which are usually related to the technical knowledge required for the position and the company you want to work for. The questions are designed to test your problem-solving and numerical reasoning skills.

Thus, the interviewer will evaluate you in the Technical Round based on your:

• Technical Expertise and problem-solving skills.
• IQ Quotient
• Projects  and your past work experiences

The technical face-to-face interview is the most important part of the entire procedure. You should know the principles of computer science, such as OOPS, DBMS, CN, and OS, etc, and be able to properly describe them to the interviewer. Knowledge of a programming language is essential. Make sure you know how to program in at least one language. You do not need to be fluent in all programming languages, but you should have enough familiarity with at least one, such as C++, Java, or Python. The interviewer will also assess your problem-solving abilities. You'll be questioned about your previous projects and professional experiences, including what you did, what technology you used, what you developed, and how successful you were. Questions about the CV and the company may be asked as well.

The number of technical interviews to be conducted will be based on your profile, performance in the previous rounds, and company requirements. 

HR Interview Round:

Students who have cleared the Technical interview will be called for the HR round. HR interviews are conducted to assess a candidate's personality in order to determine whether or not they are qualified for the position and how well a candidate will fit into the company's work culture. In addition to the normal HR questions regarding strengths and weaknesses, reasons for applying to the company, why you should be hired, and so on, expect questions about work experience, educational qualification, interests, and family background. They can also ask questions related to Capgemini, such as when it was founded, its objectives, beliefs, goals and organizational structure, among other things.

The hiring process comes to a close at this point. Adaptability is demanded of candidates, although this stage allows for negotiation. The most often asked questions are:

• Please tell me about yourself. (If you're a beginner, start with your academics, projects, achievements, other curriculum activities, and strengths. Also, include information about your interests, background, and so on. Start with your current position, achievements, past work history, and academic and personal details if you're an experienced professional.)
• What is your expectation with respect to this role?
• Why are you interested in working for Capgemini?
• Are you open to relocating to various parts of India?
• Why are you looking for a job change? (If you're an experienced professional seeking a change, this is a common question. The easiest method to respond to this question is to state that you are leaving your current work in order to advance your career. Make sure you don't criticize or speak poorly about the company where you now work.)
• What is your expected salary? (This is a difficult question to answer. It is generally asked from experienced employees. You may inquire about the company's standard raise for employees.)
• Do you have a question for us about the company?

Following are some advantages of using DBMS:

• Minimizing Data Redundancy: DBMS supports a system to eliminate data redundancy within the database by integrating all data into a single database, and because data is stored in only one location, there is no duplication of data.
• Data Sharing: In a DBMS, data can be shared among several users at the same time because the same database is shared across all users and by various applications.
• Data Integrity: This refers to the database's data being consistent and accurate at all times. It is critical because a database management system (DBMS) contains numerous databases, each of which contains data that is visible to multiple users. As a result, it's critical to guarantee that data is accurate and consistent across all databases and for all users.
• Data Security: Only approved users should be allowed access to the database, and their identities should be authenticated using a legitimate login and password. Under no circumstances should unauthorized users be allowed to access the database, as this would break the integrity limitations.

The term "normalization" refers to the process of analyzing relation schemas based on their functional dependencies. Normalization is the technique of splitting up data into numerous tables to reduce redundancy.

The advantages of normalization are:

• Standardization eliminates the copy information, allowing a smaller database to be maintained. As a result, the size of the database is reduced in general.
• Better execution is assured, which is related to the previous point. As the size of information bases shrinks, the time it takes to process it becomes shorter and more constrained, enhancing reaction time and speed.
• Narrower tables may be possible as standardized tables are altered and feature fewer segments, allowing for more data items per page.
• With fewer files per table, support assignments are completed faster (file modifies).

To aggregate the results of two or more SQL SELECT queries, we use the SQL UNION method. In the union operation, the number of data types and columns in both tables on which the UNION action is performed must be the same. Duplicate rows are removed from the result set by the UNION operation. Union ALL operation is the same as a Union operation. It returns the set without sorting the data or deleting duplicates.

DataSet. Clone() copies only the DataSet object's schema and returns a DataSet object with the same structure as the existing dataset object, including all the relations, constraints, and schemas. The data from the old one will not be copied to the new one.

DataSet.Copy() copies the entire code and structure of an existing DataSet object. 

Both these C functions read characters from the keyboard, the only difference being:

• getch() is a function that reads characters from the keyboard without using any buffers. As a result, no data is presented on the screen.
• getche() uses a buffer to read characters from the keyboard. As a result, information is displayed on the screen.

Here is an example to demonstrate the difference between the two functions:

#include<stdio.h>
#include<conio.h>
int main()
{
    char c;
    printf("Enter a character here: ");
    c = getch();
    printf("nYou entered the character: %c",c);
    printf("nEnter another character: ");
    c = getche();
    printf("nYour new entered character is: %c",c);
    return 0;
}

Output:

Enter a character here:
You entered the character: c
Enter another character: b
Your new entered character is: b

getch() immediately returns the character without waiting for the enter key to be pressed and the character is not displayed on the screen. getche() displays the character on the screen without waiting for the enter key to be pressed.

#pragma is a preprocessor directive for turning on or off specific functionalities. #pragma startup, #pragma exit, and #pragma warn are its three types.

• We can use #pragma startup to provide functions that are called when the script starts working.
• #pragma exit allows us to specify functions that are executed when the code terminates.
• #pragma warn tells the computer whether or not to suppress any warnings.

The file structure is used to connect the operating system and an application. The header file “stdio.h” (standard input/output header file) defines the file. It contains information on the currently open file, its current size, and its memory location. It has a character pointer that indicates which character is currently being opened. When you open a file, you're telling the software and the operating system which file you want to open.

With a string of characters, scanf() will fail. A multi-word string cannot be entered into a single variable using scanf(). The gets( ) function is used to avoid this. When the enter key is pushed, it gets a string from the keyboard and ends it. As part of the input string, spaces and tabs are permitted.

The entry point for any Java code is called main() and is always written as a public static void main (String[] args).

• public: The term "public" refers to an access modifier. It's used to specify who has access to use this method. This method is public, which implies that it can be accessed by any class.
• static: This is a keyword that indicates that it is a class-based system. In Java, main() is made static so that it can be accessed without having to create a class instance; however if main is not made static, the compiler will throw an error because main() is called by the JVM before any objects are created, and only static methods can be directly invoked via the class.
• void: The return type of a method is void, and it defines a method that does not return any value.
• main: It's the name of the method that JVM looks for when it's searching for a starting point for an application with a specific signature, and it's the method where the main execution happens.
• String args[]: The parameter passed to the main method is String args[]. args[] is an array of arguments with each element as a string.

The developers of Java were well aware that programmers would rely heavily on the String data type. As a result, they sought optimization from the beginning. They came up with the idea of storing String literals in the String pool (storage space in the Java heap).

As a result, whenever a new object is created, the String pool first checks to see if the object has previously been generated in the pool, and if it has, the same reference is returned to the variable. Otherwise, a new object in the String pool will be created and the reference will be returned.

They wanted to use sharing to reduce the size of the temporary String object. To make sharing easier, an immutable class is required. It is not possible to share mutable structures with two unknown parties. As a result, immutable Java Strings aid in the implementation of the String Pool concept.

String objects in Java are immutable by definition. This signifies that the String object's state cannot be changed once it has been created. As a result, if you try to update the value of that object rather than the values of that object, Java creates a new string object.

Because String objects are often cached in the String pool, Java String objects are immutable. Because String literals are frequently shared among numerous clients, one client's action may have an impact on the others. It improves the application's security, caching, synchronization, and performance by doing so.

To begin, we've developed a string literal “Python” that runs in the pool. The string “Data Science” is then formed, and it is also used in the pool. Finally, we've constructed the “Python” string once more. However, JVM checks for the string at this point and finds that the string literal is indeed present. Instead of creating a new String pool instance, it returns the pooled instance's reference, i.e. str1.

Similarly, if we use the new keyword to produce string literals, we're using the String pool. Three string literals have been created: “Java”, “C++”, and “Data Science”. We can see that string literals in “Java” and “C++” are new. However, there is already a “Data Science” literal in the pool. JVM now allocates space in the Java heap for the literal “Data Science”. It's important to remember that all String literals formed with the new keyword are stored in the Java heap, not the String pool.

The method of copying an object that is used by default in cloning is a shallow copy. The fields of an old object X are copied to a new object Y in this procedure. The reference is duplicated to Y while copying the object type field, i.e. object Y will point to the same location as X. If the field value is a primitive type, the primitive type's value is copied. As a result, any changes made in object X or Y's linked objects will be reflected in other objects.

// Java
// An object reference of this class is
// contained by IBS
class IB {
    int a, b;
}
 
// Contains a reference of IB and
// implements clone with shallow copy.
class IBS implements Cloneable {
    int x;
    int y;
    IB z = new IB();
    public Object clone() throws CloneNotSupportedException
    {
        return super.clone();
    }
}

// Driver class
public class Main {
    public static void main(String args[])
        throws CloneNotSupportedException
    {
        IBS t1 = new IBS();
        t1.x = 1;
        t1.y = 2;
        t1.z.a = 3;
        t1.z.b = 4;
 
        IBS t2 = (IBS)t1.clone();
 
        // a copy of object t1 is created
        // and is passed to t2
        t2.x = 10;
 
        // any modification in the primitive type of t2
        // does not get reflected in the t1 field
        t2.z.a = 30;
 
        // any modification in object type field
        // gets reflected in both t2 and t1(shallow copy)
        System.out.println(t1.x + " " + t1.y + " " + t1.z.a
                           + " " + t1.z.b);
        System.out.println(t2.x + " " + t2.y + " " + t2.z.a
                           + " " + t2.z.b);
    }
}

Output:

1 2 30 4
10 2 30 4

In the above program, t1.clone returns a shallow copy of the object t1. After receiving the copy, specific modifications to the clone technique must be applied in order to acquire a deep copy of the object.

A deep copy duplicates all fields as well as the dynamically allocated memory that the fields point to. When an item is copied together with the objects to which it refers, it is called a deep copy.

// Java
// An object reference of this
// class is contained by IBS
class IB {
    int a, b;
}
 
// Contains a reference of IB and
// implements clone with deep copy.
class IBS implements Cloneable {
    int x, y;
 
    IB z = new IB();
 
    public Object clone() throws CloneNotSupportedException
    {
        // Assigning the shallow copy to
        // the new reference variable t
        IBS t = (IBS)super.clone();
 
        // Creating a deep copy for c
        t.z = new IB();
        t.z.a = z.a;
        t.z.b = z.b;
 
        // Creating a new object for the field c
        // and assigning it to the obtained shallow copy
        // in order to make it a deep copy
        return t;
    }
}

public class Main {
    public static void main(String args[])
        throws CloneNotSupportedException
    {
        IBS t1 = new IBS();
        t1.x = 1;
        t1.y = 2;
        t1.z.a = 3;
        t1.z.b = 4;
 
        IBS t3 = (IBS)t1.clone();
        t3.x = 10;
 
        // any modification in the primitive type of t2
        // does not get reflected in the t1 field
        t3.z.a = 30;
 
        // any modification in object type field of t2
        // does not get reflected in t1(deep copy)
        System.out.println(t1.x + " " + t1.y + " " + t1.z.a
                           + " " + t1.z.b);
        System.out.println(t3.x + " " + t3.y + " " + t3.z.a
                           + " " + t3.z.b);
    }
}

Output:

1 2 3 4
10 2 30 4

We can see how a new object for the IB class has been designated to replicate an object that will be delivered to the clone method in the preceding example. As a result, t3 will acquire a deep copy of t1's object. As a result, any changes made by t3 to the ‘z' object properties will not be reflected in t1.

Python's private heap space is in charge of memory management. The private heap contains all Python objects and data structures, but the programmer does not have access to it. The Python interpreter, on the other hand, takes care of this.

• The memory manager in Python is in charge of allocating heap space for Python objects. The core API then gives the programmer access to a few programming tools.
• It also contains an integrated garbage collector, which, as the name implies, recycles all unused memory and makes it available to the heap space.

xrange and range are nearly identical in terms of functionality. They both allow you to generate a list of integers that you may use whatever you want. The only difference between range and xrange is that xrange produces an xrange object while range provides a Python list object.

This implies that, unlike range, xrange does not create a static list during execution. It generates the values as needed using a technique known as yielding. Generators, which are a type of object, are employed with this technique. That is, if you have a large range and want to construct a list for a billion people, you should use xrange.

This is particularly the case if you're working with a system that demands a lot of memory, such as a cell phone, because range will utilise as much RAM as it can to build your array of numbers, causing a memory problem and crashing your app.

The following are some advantages of NumPy arrays over Python lists:

• NumPy arrays store data in a sequential manner, unlike Python lists, making data processing simpler.
• NumPy is not just more efficient, but it's also easier to use. We get a lot of vector and matrix operations for free, allowing us to avoid doing unnecessary work. They're also put to good use.
• NumPy arrays are faster, and NumPy has a lot of useful features like FFTs, convolutions, quick searching, simple statistics, linear algebra, histograms, and so forth.

The cons of using an array to implement a queue are:

• Even if the queue is empty, if it has a significant number of enqueue and dequeue operations, we may not be able to insert entries at some time (as in the case of linear increment of front and rear indices) (this problem is solved by using circular queue).
• When using an array to construct a queue, there may be occasions where we need to extend the queue to insert additional elements. Because it is nearly impossible to extend the array size when using an array to implement a queue, determining the suitable array size is always an issue.

If you wish to compare the two: an AVL tree to a simple binary search tree (BST) without balancing it, then AVL:

• will require additional memory (each node must keep track of its balance factor) and
• Each operation has the potential to be slower (because you need to maintain the balance factor and sometimes perform rotations).

The worst-case for BST without balancing is quite terrible (linear). However, if you are confident that this worst-case scenario will not occur, or if you don't mind if the process is slow in rare circumstances, BST without balancing may be preferable to AVL.

The advantages of Tries over binary search trees (BSTs) are as follows:

• It's quicker to lookup keys. In the worst-case scenario, looking up a key of length m takes O(m) time. Because lockups are dependent on the depth of the tree, which is logarithmic in the number of keys if the tree is balanced, a BST does O(log n) key comparisons, where n is the number of items in the tree. As a result, a BST takes O(m log n) time in the worst scenario. Furthermore, log(n) will approach m in the worst-case scenario. Also, on real processors, the simple actions Tries utilize during lookup, such as array indexing with a character, are quick.
• Because nodes are shared between keys with common starting sub-sequences, tries with a large number of short keys are more space-efficient.
• Tries facilitate longest-prefix matching, assisting in the discovery of the key with the longest possible prefix of characters, all of which are unique.
• The length of the key is equal to the number of internal nodes from root to leaf. As a result, balancing the tree isn't an issue.

There are a few distinctions between a class in C++ and a structure. 

These are the following:

• When creating a structure from a class or another structure, the base class or structure's default access specifier is public. When deriving a class, on the other hand, the default access specifier is private.
• The members of a structure are always public, but the members of a class are always private.
• The variables of a structure are stored in the stack memory while those of the class are stored in the heap memory.
• Class supports inheritance whereas structures do not.
• The type of class is reference type whereas the type of structure is a value type.

In C++, both malloc() and new are used for memory allocation at runtime. The differences are listed below:

• Malloc() is a function, whereas new() is a pre-processor.
• When using new(), there is no requirement to allocate memory; nevertheless, when using malloc(), you must use sizeof ().
• new() sets the new memory to 0 and malloc() assigns a random value to the newly allocated memory.
• The new() operator allocates memory and invokes the constructor for object initialization, whereas the malloc() function allocates memory but does not invoke the constructor.
• Because the operator is faster than the function, the new() operator is faster than the malloc() function.

A virtual function is a member function that is declared in a base class and overridden by a derived class. When we are using a pointer or a reference to the base class to refer to a derived class object, we can invoke a virtual function for that object and have it run the derived class's version of the function.

• Regardless of the type of reference (or pointer) used for a function call, virtual functions make sure the right function is called for an object.
• They're mostly implemented to accomplish polymorphism at runtime.
• The virtual keyword is used to declare functions in base classes.
• Run-time resolution of function calls is performed.

Functions that are only declared in the base class are known as pure virtual functions or abstract functions. This indicates that they have no definition in the base class and must be redefined in the subclass.

A DNS forwarder is a DNS server that forwards DNS queries for external DNS names to DNS servers outside the network. A forwarder is used with a DNS server when it receives DNS queries that cannot be resolved quickly. Therefore, it forwards these requests to external DNS servers for resolution. 

A DNS server that is configured as a forwarder behaves differently than a DNS server that is not configured as a forwarder. 

The DNS server behaves as follows when configured as a forwarder: 

• When the query is received by the DNS server, it resolves it using a cache.
• If the DNS server is not able to resolve the request, it forwards it to another DNS server.
• If the forwarder is not available, it tries to resolve the query using a root hint.

The network administrator uses the dynamic host configuration protocol to create a pool of IP addresses instead of going to each client computer to configure a static IP address. This group is known as an area that can be dynamically assigned to clients.

Users can access public data through anonymous FTP. The server does not need the user to identify himself, and the login is anonymous. As a result, while utilizing anonymous FTP, you must substitute 'anonymous' for the user id. Anonymous FTPs allow you to send large files to a large number of individuals without having to give out a large number of password and username combinations.

Any two consecutive (one after the other) Fibonacci Numbers have a ratio that is very close to the Golden Ratio, which is equal to 1.618034.... (approx). In fact, the larger the pair of Fibonacci Numbers, the closer the approximation. Let's have a look at a few:

3/2 = 1.5
5/3 = 1.666666666...
...
233/377 = 1.618055556...

This also works when we start the sequence with two random whole numbers.

Useful Preparation Resources:

Java 

Automation Testing

API Testing

SQL

• “Self Confidence” is the first stage in nailing any interview. You've already completed half of the task if you're confident enough. Always keep a cheerful attitude and a smile on your face.
• Read about the company. Understand the company's services and product lines, as well as its mission and philosophy. Employers expect you to know who the company is, what it does, and how it relates to your professional goals. These types of questions about the company can be asked during the HR round.
• The more you prepare for the interview, the easier it will be to pass. Acquire sufficient understanding of, among other things, interview stages, rounds, and questions. Practice your responses to common HR and management interview questions. Study your technical subjects and final project carefully. Above all, remain calm and confident, and you'll have a good chance of surviving.
• Answers should be short and to the point. Use no word arts to explain the core solution. Don't waste time offering ineffective responses or asking irrelevant inquiries. Any interviewer who observes you doing this will automatically deduct points from your score.
• Ensure you're up to date on the most recent technological developments. You should have a basic awareness of contemporary technological trends like artificial intelligence (AI), big data, and so on.
• Speak confidently. Listening to the interviewer is more crucial than responding. Make sure you fully comprehend a question before attempting to respond. Don't be scared to ask for clarification if you don't understand something.

For employees with less than one year of experience to two years of experience, the average Capgemini Fresher salary in India is 3.4 lakhs per year.

Capgemini is a great place to work. Your abilities will be valued here. The organization's policies and opportunities are excellent, and it works in a variety of domains and nations. Once you're in, you'll have a plethora of options dependent on your abilities. Without a doubt, Capgemini's infrastructure and team management are top-notch. 

Generally, there is a 2 years service bond for freshers in Capgemini.

Capgemini visits numerous college campuses in their final placements, conducts walk-ins, and mega placement drives for fresher hiring. You can also apply to Capgemini in a variety of ways, including through employment sites, registering on the company’s website(www.capgemini.com), attending recruiting drives, using the employee referral system, or consulting with placement experts.

It doesn't matter whether the Capgemini interview is challenging or easy. The truth is that the more you prepare for the interview, the easier it will be to pass. Acquire sufficient understanding of, among other things, interview stages, rounds, and questions. Programming languages, logical thinking, and products/software/projects on which the candidate has recently or previously worked are among the topics covered.

Capgemini gives you the opportunity to reach your full potential at every level of your career. Capgemini's work culture is generally positive. Job security is excellent too. You can take advantage of a flexible working environment that allows you to precisely blend your professional and personal lives.