Candidates receive the assessment link and detailed instructions via email on the scheduled day. A mandatory system check is conducted to verify webcam functionality, microphone access, browser compatibility, and internet stability.

The total duration of the online assessment is approximately two hours.

Candidates are required to sit in a quiet room with adequate lighting. Webcam monitoring remains active throughout the assessment.

The online assessment consists of multiple sections designed to evaluate aptitude, language skills, technical knowledge, and cognitive ability.

This section focuses on numerical ability, logical reasoning, and analytical thinking. Questions require conceptual clarity and step-by-step reasoning.

Example Questions

1. A number is increased by twenty percent and then decreased by twenty percent. What is the net percentage change?
2. Find the next number in the series 2, 6, 12, 20, 30.

The English section tests grammar, sentence correction, vocabulary, and reading comprehension. Questions are moderately tricky and assess attention to detail.

Example Questions

1. Identify the grammatically correct sentence from the given options.
2. Choose the correct synonym based on the given context.

Technical questions assess fundamental computer science knowledge, including programming basics, data structures, databases, and operating systems.

Example Questions

1. Which data structure follows the First In First Out principle?
2. What is the purpose of a primary key in a relational database?

This section evaluates cognitive ability, pattern recognition, decision-making speed, and problem-solving under time pressure.

The assessment is balanced and concept-oriented. Effective time management is essential, particularly in the game-based section.

The coding round lasts forty-five minutes and consists of two programming problems. Full-screen mode and screen recording remain enabled throughout the test.

The difficulty level ranges from medium to high, with strong emphasis on logic, edge case handling, and clean implementation.

Array-Based Problem
The first problem typically involves array traversal, sorting logic, or conditional manipulation.

Sample Problem
Rearrange an array such that the first element is the maximum value, the second element is the minimum value, and the pattern continues alternately.

Answer

#include <stdio.h>
void sort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = i + 1; j < n; j++) {
            if (arr[i] > arr[j]) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

void rearrange(int arr[], int n) {
    int temp[n];
    int left = 0, right = n - 1;
    int index = 0;

    while (left <= right) {
        if (left != right) {
            temp[index++] = arr[right--];
            temp[index++] = arr[left++];
        } else {
            temp[index++] = arr[left++];
        }
    }

    for (int i = 0; i < n; i++)
        arr[i] = temp[i];
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6};
    int n = sizeof(arr) / sizeof(arr[0]);

    sort(arr, n);
    rearrange(arr, n);

    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

String Manipulation Problem
The second problem generally focuses on string processing and logical validation.

Sample Problem
Given a string, determine whether it can be rearranged to form a palindrome.

#include <stdio.h>
#include <string.h>

int canFormPalindrome(char str[]) {
    int freq[256] = {0};
    int oddCount = 0;

    for (int i = 0; str[i] != '\0'; i++)
        freq[(int)str[i]]++;

    for (int i = 0; i < 256; i++) {
        if (freq[i] % 2 != 0)
            oddCount++;
    }

    if (oddCount <= 1)
        return 1;
    else
        return 0;
}

int main() {
    char str[] = "carrace";

    if (canFormPalindrome(str))
        printf("Yes");
    else
        printf("No");

    return 0;
}

Evaluation is based on the correctness of logic, the number of test cases passed, code structure, and optimization.

The first problem is usually manageable, while the second problem requires deeper logical thinking. Solving even one problem completely significantly improves selection chances.

The interview lasts approximately twenty-five to thirty minutes and is conducted via Microsoft Teams or Zoom.

The panel generally consists of one senior technical lead.

Introduction
A brief self-introduction to understand the candidate's educational background and interests.

Project Discussion
A detailed discussion on the final year project, including architecture, technologies used, challenges faced, and real-world relevance.

Data Structures and Algorithms
Candidates are asked questions related to linked lists, trees, and basic algorithmic concepts.

Example Questions

1. Explain the logic to reverse a linked list.

Sample Answer with Code

struct Node {
    int data;
    struct Node* next;
};

struct Node* reverseList(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* curr = head;
    struct Node* next = NULL;

    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

2. What are the properties of a Binary Search Tree?

Sample Answer
A Binary Search Tree is a binary tree in which the left subtree contains nodes with values less than the root, and the right subtree contains nodes with values greater than the root. Both subtrees must also follow the same rule. An in order traversal of a Binary Search Tree always produces sorted output.

Sample Code to Validate a Binary Search Tree

int isBSTUtil(struct Node* root, int min, int max) {
    if (root == NULL)
        return 1;

    if (root->data < min || root->data > max)
        return 0;

    return isBSTUtil(root->left, min, root->data - 1) &&
           isBSTUtil(root->right, root->data + 1, max);
}

int isBST(struct Node* root) {
    return isBSTUtil(root, INT_MIN, INT_MAX);
}

Object-Oriented Programming Concepts: Interviewers focus on abstraction, inheritance, and polymorphism with practical examples.

Candidate Questions: Candidates are encouraged to ask questions related to team structure, learning opportunities, and project exposure.

The interview is professional and interactive, with strong emphasis on conceptual clarity and real-world application.

The interview lasts approximately fifteen to twenty minutes and is conducted by an HR business partner.

Tell me about yourself

• Why do you want to join Capgemini?
• Strengths and areas of improvement
• Situational questions related to teamwork and pressure handling
• Relocation and shift preferences
• Opportunity to ask questions

The interaction is conversational and informative. HR focuses on cultural fit, long-term career goals, and alignment with Capgemini's work culture.

Candidates typically receive a provisional offer email within one week of completing the HR interview. The official offer letter with joining details follows shortly after.

Offered Package: Candidates who successfully solve both coding questions are generally offered a package of approximately 7.5 L per annum.

• Aptitude Assessment: Aptitude questions are moderate in difficulty and focus on logical reasoning, numerical understanding, and attention to detail rather than shortcut-based calculations.
• Programming and Coding Rounds: Programming assessments emphasize structured thinking, clean coding practices, and the ability to handle real-world constraints. Partial solutions with correct logic are often evaluated positively.
• Interview Rounds: Technical and HR interviews are structured yet conversational, with a strong focus on project understanding, practical application of concepts, and communication skills.
• Overall Difficulty: The Capgemini recruitment process is well-balanced and professionally designed, ensuring the selection of candidates with strong fundamentals, adaptability, and long-term potential.