512 questions from 95 interviews · updated from reports 2017-2025
About
Capgemini is an IT services and consulting company that helps businesses with software development, cloud, data, engineering, and business process services. In India, it often hires for technical and delivery roles such as Analyst, Software Engineer, and Senior Analyst.
The roles that come up most are Analyst, Software Engineer and Senior Analyst. This covers 95 candidate interviews reported from 2017 to 2025. Most sat it at entry level (89 of 93 that recorded a level). Among the 74 that recorded either route, arrivals split between campus drives (53, 72%) and off-campus applications (21, 28%). Most questions fall under CS fundamentals and Aptitude.
Ans. A list is mutable, while a tuple is immutable. Lists can have items added, removed, or changed after creation, but tuples cannot. Lists use square brackets and tuples use parentheses. Tuples are often used for fixed collections of values and can be hashable if all their elements are hashable.
Ans. Object-Oriented Programming is a programming style that organises software around objects, which combine data and behaviour. Objects are usually created from classes. The key idea is encapsulation: keeping state and the operations on that state together, with controlled access. OOP also commonly uses abstraction, inheritance and polymorphism.
Ans. C is a procedural, compiled, low-level language with manual memory management, while Java is object-oriented, runs on a virtual machine, and uses garbage collection. C gives more control over memory and hardware, so it is common in systems programming. Java favours portability, safety, and large application development through its standard runtime.
Ans. SQL joins combine rows from related tables using a matching condition, usually a key. INNER JOIN returns only matching rows. LEFT JOIN returns all rows from the left table plus matches from the right. RIGHT JOIN is the reverse. FULL OUTER JOIN returns all rows from both sides. CROSS JOIN returns every combination of rows.
Ans. A primary key uniquely identifies each row in its own table, while a foreign key links a row to a primary key or unique key in another table. A primary key cannot be null and must be unique. A foreign key can repeat, and may be null unless constrained otherwise.
Ans. Generate the Fibonacci series by starting with 0 and 1, then repeatedly adding the previous two numbers to get the next term until the required count is reached. Store the values in an array or list if they must be returned. The time complexity is O(n), with O(n) space, or O(1) if printed directly.
Ans. The four pillars of object-oriented programming are encapsulation, abstraction, inheritance, and polymorphism. Encapsulation hides internal state behind methods. Abstraction exposes only essential behaviour. Inheritance lets classes reuse and extend other classes. Polymorphism lets different objects be treated through the same interface while providing their own behaviour.
Ans. Decorators wrap a function or class to extend or change its behaviour, while generators produce values lazily one at a time. A decorator is usually applied with @ and returns a callable. A generator uses yield, keeping its state between calls, which makes it memory efficient for large or infinite sequences.
Ans. Identify the rule before chasing speed. In switch tasks, track cause and effect after each change. In digit tasks, test arithmetic, position, and repetition patterns. In motion tasks, note direction, rotation, and collision rules. In grid tasks, scan rows, columns, symmetry, and counts. The answer is the option that fits every observed rule.
Ans. A primary key is a column, or set of columns, that uniquely identifies each row in a SQL table. Its values must be unique and not null. A table normally has one primary key, and it is often used by foreign keys in other tables to create relationships.
Ans. The Java Collection Framework is a standard set of interfaces and classes for storing, accessing and manipulating groups of objects. Its core interfaces include List, Set, Queue and Map, with implementations such as ArrayList, HashSet, PriorityQueue and HashMap. The main benefit is consistent APIs, reusable algorithms and predictable performance choices.
Ans. C is mainly a procedural systems programming language, while C++ extends C with object oriented and generic programming features. The key practical difference is that C++ provides classes, constructors, destructors, templates and a richer standard library, enabling abstractions such as RAII and containers while still supporting low level memory control.
Ans. A number is prime if it is greater than 1 and has no divisors other than 1 and itself. Handle n less than or equal to 1 as not prime, then test divisibility only up to the square root of n. This uses constant space and runs in O(sqrt n) time.
Ans. A primary key is a column or set of columns that uniquely identifies each row in a table. It cannot contain null values and should be stable. A secondary key is a non-primary attribute used to search or retrieve records, often through an index, and it may contain duplicate values.
Ans. To check whether a number is an Armstrong number, count its digits, sum each digit raised to that count, and compare the sum with the original number. For example, 153 is valid because 1³ + 5³ + 3³ = 153. Process digits using division and modulo. Time complexity is O(d), space is O(1).
Ans. Encapsulation is the practice of keeping an object’s data and the methods that operate on it together, while hiding internal details from outside code. The key point is controlled access: fields are usually private, and other code interacts through public methods, which helps protect invariants and reduce unintended dependencies.
Ans. The four pillars of Object-Oriented Programming are encapsulation, abstraction, inheritance, and polymorphism. Encapsulation hides internal state behind methods, abstraction exposes only essential behaviour, inheritance lets classes reuse and extend other classes, and polymorphism lets the same interface call different implementations depending on the object.
Ans. Use the DELETE FROM statement followed by the table name and a WHERE clause that selects the rows to remove. The most important detail is that omitting the WHERE clause deletes all rows in the table, although the table structure remains. Use transactions where possible so mistakes can be rolled back.
Ans. A year is a leap year if it is divisible by 400, or if it is divisible by 4 but not divisible by 100. The key detail is that century years are not leap years unless they are also divisible by 400, so 2000 was a leap year but 1900 was not.
Ans. A Class Loader in Java is part of the JVM that loads class files into memory when they are needed. It turns bytecode into Class objects and helps with linking and initialisation. The key detail is the parent delegation model, where loaders ask their parent first to avoid duplicate or unsafe class loading.
Ans. Storage classes in C++ define an object’s lifetime, visibility, and linkage. The main specifiers are static, extern, thread_local, and mutable. Historically, auto and register were also storage class specifiers, but auto now means type deduction and register is obsolete. The key idea is how long data exists and where it can be accessed.
Ans. Virtual functions in C++ are member functions declared with virtual so calls are resolved at runtime based on the actual object type, not the pointer or reference type. They enable polymorphism, letting derived classes override base behaviour. A common important rule is to make base class destructors virtual when deleting derived objects through base pointers.
Ans. OOP organises software as objects that combine data and behaviour. Encapsulation hides state, for example a BankAccount exposes deposit but not its balance field directly. Abstraction exposes only essential operations. Inheritance lets Car reuse Vehicle features. Polymorphism lets different shapes implement draw differently while callers use the same interface.
Ans. There is no single answer because these games vary, but the method is to identify the rule, test it against every example, then apply it consistently. Look for patterns in number changes, shape rotation, position, colour, symmetry, sequence, or exclusion. Avoid guessing from one clue; confirm the rule before choosing.
Ans. A shallow copy creates a new outer object but keeps references to the same nested objects, while a deep copy creates a new object and recursively copies the nested objects too. The key difference is aliasing: changes to shared nested data affect both shallow copies, but not properly made deep copies.
Ans. Use a singly linked list and treat the head node as the top of the stack. To push, create a new node and link it before the current head. To pop, remove the head and return its value. Peek reads the head value. Push, pop and peek are O(1); space is O(n).
Ans. An AVL tree is a self-balancing binary search tree where, for every node, the height difference between its left and right subtrees is at most one. This balance factor keeps the tree height logarithmic. After insertion or deletion, rotations restore balance, so search, insert, and delete take O(log n) time.
Ans. Profiles in Spring Boot are managed by activating named environments, usually with spring.profiles.active in properties, YAML, environment variables, command-line arguments, or deployment settings. Each profile can load its own application-{profile}.properties or YAML file, and beans can be included or excluded with @Profile. This separates dev, test, and production configuration.
Ans. I would describe the algorithm step by step in plain language, defining the inputs, outputs, main loop or recursion, and stopping condition. I would name the key data structure, such as an array, hash map, queue, stack, or graph representation, then state the expected time and space complexity.
Ans. Set out the facts clearly, then eliminate what cannot be true. Use a table or grid for people, places, objects, or times. Mark definite links and contradictions as you read each clue. Work step by step, avoid guessing, and recheck every conclusion against all clues before choosing the answer.
Ans. Look for patterns from the examples, then form a rule that explains every case, not just most of them. Check changes in shape, number, position, colour, order, rotation or arithmetic. Test the rule on all given items, reject it if one case fails, and choose the option that best fits consistently.
Ans. Basic algorithms include searching, sorting, traversal, recursion, divide and conquer, greedy, dynamic programming, and graph algorithms. Searching finds items, sorting orders data, traversal visits structures, greedy optimises local choices, dynamic programming handles overlapping subproblems, and graph algorithms model networks. The key detail is choosing by data shape, constraints, and time complexity.
Ans. Trace the code step by step using the given inputs, writing down each variable value after every statement. Pay close attention to loops, conditions, counters, and updates. Do not assume what the code intends to do. Follow the exact logic, stop when the loop condition fails, then read the final output.
Ans. Use Floyd’s cycle detection algorithm with two pointers, slow and fast. Move slow by one node and fast by two nodes each step. If they ever meet, the linked list contains a loop. If fast reaches null, there is no loop. Time complexity is O(n), space complexity is O(1).
Ans. Pointers are variables that store memory addresses, while friend functions are non-member functions allowed to access a class’s private and protected members. Pointers enable indirect access, dynamic memory, and efficient passing of data. A friend function is declared inside the class with friend, but it is defined and called like a normal function.
Ans. BFS and DFS are graph or tree traversal methods. BFS visits nodes level by level using a queue, so it finds the shortest path in an unweighted graph. DFS goes as deep as possible before backtracking, using recursion or a stack. Both take O(V + E) time on a graph.
Ans. new is a C++ operator that allocates memory and constructs an object, while malloc is a C library function that only allocates raw memory. new returns a typed pointer and throws an exception on failure. malloc returns void* and may return NULL. Memory from new must use delete, and malloc must use free.
Ans. A heap is a complete binary tree, usually stored in an array, where each parent has higher priority than its children. In a max heap the parent is larger, and in a min heap it is smaller. Heaps support fast access to the highest priority item and are used in priority queues, heap sort, scheduling, and graph algorithms.
Ans. Object-oriented programming organises software around objects that combine data and behaviour. Its main concepts are encapsulation, abstraction, inheritance and polymorphism. The key principle is to model clear responsibilities: hide internal state, expose meaningful operations, reuse behaviour carefully, and allow different objects to be used through common interfaces.
Ans. SQL databases store structured data in tables with fixed schemas and use SQL for relational queries. NoSQL databases use more flexible models such as documents, key value pairs, columns, or graphs. The key difference is that SQL favours strong consistency and complex joins, while NoSQL often favours flexibility, scale, and high availability.
Ans. Reverse a linked list iteratively by walking through the nodes and reversing each next pointer. Keep three references: prev, current, and next. Store current.next before changing it, point current.next to prev, then move prev and current forward. Return prev as the new head. This runs in O(n) time and O(1) space.
Ans. Selenium is an open-source suite for automating web browsers, mainly used for testing web applications across browsers and platforms. In its common WebDriver architecture, test code uses Selenium client libraries to send W3C WebDriver commands to a browser driver, such as ChromeDriver, which controls the real browser and returns results.
Ans. The Java Collection Framework is a set of interfaces, classes and algorithms for storing and manipulating groups of objects. Its main interfaces are Collection, List, Set, Queue, Deque and Map, with implementations such as ArrayList, LinkedList, HashSet, TreeSet, PriorityQueue and HashMap. The key detail is choosing the right implementation for ordering, uniqueness and performance.
Ans. Translate the motion into distance, speed and time, then keep units consistent. Use distance equals speed times time, and compare relative speed when objects move towards or away from each other. For accuracy puzzles, separate speed from error rate, calculate each part step by step, and check whether the final result is reasonable.
Ans. Data Structures and Algorithms basics mean knowing how to store data and solve problems efficiently. The key detail is choosing structures like arrays, linked lists, stacks, queues, hash maps, trees or graphs based on access, update and search needs, then analysing the algorithm using time and space complexity, usually Big O notation.
Ans. Merge sort is a divide and conquer internal sorting algorithm that splits the array, recursively sorts each half, then merges the sorted halves. It runs in O(n log n) time and is stable, but needs extra memory. Other internal techniques include quicksort, heapsort, insertion sort, selection sort, bubble sort, and shell sort.
Ans. Represent the grid with coordinates, usually rows and columns. Mark the start, finish, blocks, and any rules for movement. Work step by step, eliminating impossible moves and tracking visited positions if needed. For shortest paths, count moves by layers from the start. Check boundaries, repeated cells, and rule exceptions carefully.
Ans. Read the whole sentence or passage first to understand meaning and tone. For grammar, check subject verb agreement, tense, pronouns, articles, prepositions and punctuation. For comprehension, find evidence in the text, not assumptions. For usage, choose the option that is clear, idiomatic and fits the context. Eliminate obviously wrong answers first.
Ans. Rotate the matrix layer by layer, moving each boundary element one position clockwise. For each ring, store the first value, traverse the left column upward, bottom row left to right, right column downward, and top row right to left, shifting values into their next position. This uses constant extra space and O(mn) time.
Ans. Data structures organise data so operations like search, insert, delete and traversal can be done efficiently. The key is choosing based on access pattern: arrays for indexing, linked lists for frequent insertion, stacks and queues for order, hash tables for fast lookup, trees and heaps for ordered or priority-based data.
Ans. finally is a block used with try and catch to run cleanup code, while finalize is a method the garbage collector may call before reclaiming an object. The key difference is reliability: finally normally runs as part of program flow, but finalize is not guaranteed to run and is deprecated in modern Java.
Ans. Compile-time polymorphism means the method or operation to call is chosen by the compiler, usually through method overloading or operator overloading. Runtime polymorphism means the call is chosen while the program runs, usually through method overriding and dynamic dispatch. The key difference is early binding versus late binding.
Ans. I would optimise a web application by measuring bottlenecks first, then improving the slowest parts across frontend, backend, database, and infrastructure. The most important detail is to use data, such as latency percentiles, error rates, traces, and query timings, before changing anything, then validate improvements with load tests and monitoring.
Ans. Abstraction hides unnecessary details by exposing what an object does, while encapsulation hides internal state and implementation by controlling how data is accessed or changed. Abstraction is about designing a simple interface. Encapsulation is about protecting data, usually by keeping fields private and using methods to enforce valid behaviour.
Ans. Use constraint propagation first, then controlled guessing if needed. For each empty cell, list values allowed by its row, column, and box. Fill singles, remove those values from peers, and repeat. If stuck, choose the cell with fewest candidates and backtrack. No final grid can be given without the actual puzzle.
Ans. Choose a real example where you had clear responsibility, the stakes were meaningful, and the challenge involved people as well as delivery. Emphasise how you set direction, communicated, handled conflict or pressure, and kept the team focused. Interviewers listen for ownership, judgement, calmness, accountability, and measurable improvement or learning.
Ans. Design an IoT-based water management system with flow, pressure and moisture sensors on pipes, tanks and high-risk areas, connected to a central controller that detects abnormal usage, alerts users and automatically shuts valves. The key detail is accurate leak detection using baseline consumption patterns, so normal spikes are not mistaken for leaks.
Ans. Microservices make large systems easier to scale, deploy and evolve independently, but they add significant operational and communication complexity. The main advantage is team and service autonomy around clear business boundaries. The main disadvantage is managing distributed system concerns such as latency, failures, data consistency, observability, testing and deployment coordination.
Ans. Choose a real work example with uncertainty, trade-offs, and consequences. Emphasise how you clarified the problem, gathered evidence, consulted the right people, weighed options, and made a timely decision. Interviewers listen for calm judgement, accountability, ethical thinking, communication, and evidence that you learned from the outcome.
Ans. Pick a real example where you influenced peers without blaming them. Emphasise private conversations, understanding the cause, clarifying shared goals, offering support, and agreeing on measurable responsibilities. Interviewers listen for empathy, ownership, communication, and escalation only if needed. Show that you protected team performance while maintaining trust and professionalism.
No question matches those filters. Reset filters.
Showing 60 of 512 questions. Ranked by how often the same question came back across interviews.
A spoken interview built from these questions, scored when you finish; the feedback is yours.
Start practisingWhen you are ready, record The One: a single interview hiring teams watch, so you stop repeating first rounds.
Candidate interviews most often cover CS fundamentals (52%) and Aptitude (21%).
Candidate interviews show an average of 3.3 rounds per experience, with a typical sequence of Online test → Technical → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 68%, medium 31%, hard 1%.
