191 questions from 22 interviews · updated from reports 2019-2024
About
Publicis Sapient is a digital consulting and technology services company that helps businesses build customer platforms, data systems, and software products. In India, it commonly hires technical talent for roles such as Trainee Engineer, Associate Software Development Engineer, and ASDE-II.
The roles that come up most are Trainee Engineer, ASDE and ASDE-II. This covers 22 candidate interviews reported from 2019 to 2024. Most sat it at entry level (16 of 22 that recorded a level), with 3 internship interviews alongside. Among the 19 that recorded either route, arrivals split between campus drives (18, 95%) and off-campus applications (1, 5%). Most questions fall under CS fundamentals and DSA.
Ans. Agile software development is an iterative approach where teams deliver small, working increments of software and adapt based on feedback. The key idea is to value collaboration, customer feedback, and responding to change over rigid upfront planning, often using short cycles such as sprints to plan, build, test, and review features.
Ans. Swap them using arithmetic: set the first number to the sum of both, set the second to the new first minus the second, then set the first to the new first minus the new second. This uses constant space and constant time. The key caveat is integer overflow, so a temporary variable is usually safer.
Ans. A process is an independent running program with its own memory space, while a thread is a smaller unit of execution within a process that shares that process’s memory. Processes are more isolated and cost more to create or switch between. Threads are lighter, but shared memory makes synchronisation and race conditions important.
Ans. ACID properties are the guarantees that make database transactions reliable: Atomicity, Consistency, Isolation and Durability. Atomicity means all or nothing, Consistency keeps valid rules, Isolation prevents concurrent transactions interfering, and Durability ensures committed changes survive crashes. They are essential for correctness in systems handling critical data.
Ans. Paging is a memory management technique where a process’s virtual address space is split into fixed-size pages, and physical memory is split into same-size frames. The OS maps pages to frames using a page table, allowing non-contiguous allocation. The key benefit is avoiding external fragmentation while supporting virtual memory.
Ans. Software design principles are guidelines for structuring code so it is easier to understand, change, test and maintain. They include ideas such as separation of concerns, low coupling, high cohesion, encapsulation and the SOLID principles. The key point is that they reduce complexity and help systems evolve safely over time.
Ans. No, you cannot override the main function in Java because main is static, and static methods are not overridden. They can only be hidden in a subclass if the same signature is declared. You can overload main with different parameters, but the JVM starts only public static void main(String[] args).
Ans. Static binding resolves which method or variable reference is used at compile time, while dynamic binding resolves the method call at run time. Static binding is used for overloaded methods, private, final, and static methods. Dynamic binding supports overriding and polymorphism, where the actual object type decides which implementation runs.
Ans. Yes, we can store custom objects in a Set in Java. The key detail is how uniqueness is decided: for HashSet or LinkedHashSet, override equals and hashCode correctly. For TreeSet, provide Comparable or a Comparator, because it uses ordering to detect duplicates.
Ans. A hub broadcasts traffic to all ports, a switch forwards frames to the correct device on a LAN, and a router forwards packets between networks. In the OSI model, hubs are layer 1, switches usually layer 2, and routers layer 3. The OSI layers are physical, data link, network, transport, session, presentation, and application.
Ans. Multithreading is running multiple threads within the same process so work can progress concurrently while sharing the same memory space. It should be used for independent tasks, especially I/O-bound work or responsive applications, and sometimes CPU-bound work on multiple cores. The key concern is safely managing shared state to avoid race conditions and deadlocks.
Ans. Deadlock is a state where two or more processes wait forever because each holds a resource the others need. It is usually handled by preventing one of the necessary conditions, avoiding unsafe allocation with algorithms like Banker’s algorithm, or detecting cycles in a wait-for graph and recovering by aborting or rolling back processes.
Ans. Multithreading in Java means running multiple threads within one process so tasks can execute concurrently and share the same memory. The sleep method, Thread.sleep(milliseconds), pauses the currently running thread for at least that time. It does not release locks, and it can throw InterruptedException if interrupted.
Ans. Django model inheritance has three main styles: abstract base classes, multi-table inheritance, and proxy models. Abstract bases share fields without creating a parent table. Multi-table inheritance creates a table for each model and links them. Proxy models keep the same table but change Python behaviour, such as managers or ordering.
Ans. Use GROUP BY to aggregate rows by one or more columns, and HAVING to filter the aggregated groups after calculation. For example, group orders by customer and count them, then use HAVING to keep only customers with more than five orders. WHERE filters rows before grouping, while HAVING filters groups after aggregation.
Ans. Rearrange the array so elements alternate as a[0] < a[1] > a[2] < a[3] and so on. Scan once, keeping a flag for the expected relation; if the current pair violates it, swap them. This uses the array in place, needs no extra data structure, and runs in O(n) time.
Ans. OOP organises software around objects that combine data and behaviour, while abstraction hides unnecessary detail and exposes only what users need. An interface defines a contract of methods a class must provide, without saying how. This lets code depend on capabilities rather than concrete classes, improving flexibility, testing, and maintainability.
Ans. A typical web application uses a client, a web server or API layer, application services, caching, storage, and external services. The browser communicates over HTTPS using HTTP methods, often exchanging HTML, JSON, CSS, and JavaScript. The key detail is separation of concerns, so presentation, business logic, and data storage can scale and change independently.
Ans. Use expand around centres: for each index, expand once for an odd-length palindrome and once between indices for an even-length palindrome, tracking the best start and length. The key detail is handling both centre types. This uses only a few variables, runs in O(n squared) time, and uses O(1) extra space.
Ans. Define a Complex class with two numeric fields, real and imaginary, then overload the addition operator to return a new Complex object whose real part is the sum of both real parts and whose imaginary part is the sum of both imaginary parts. This uses a simple object data structure and runs in constant time.
Ans. Use two pointers from the start and end, swapping only normal characters and skipping special characters. Convert the string to a character array, move the left pointer until it finds a non-special character, do the same from the right, then swap. Special characters stay fixed. Time complexity is O(n), space is O(n).
Ans. Use a min heap of candidate pairs, ordered by sum. Push pairs using the first element of the second array with up to min(k, n) elements from the first array. Repeatedly pop the smallest pair, add it to the answer, then push the same first index with the next second index. Time is O(k log min(k, n)).
Ans. Choose a real situation with pressure, conflict, ambiguity, or a setback, but avoid blaming others. Emphasise your role, the action you took, how you communicated, and the outcome. Interviewers listen for calm judgement, ownership, collaboration, and learning. A strong answer shows you solved the issue professionally and improved something afterwards.
Ans. OOPS is based on encapsulation, abstraction, inheritance and polymorphism. Encapsulation hides state, abstraction exposes essentials, inheritance reuses behaviour, and polymorphism lets the same interface call different implementations. For example, a Shape reference can point to Circle or Rectangle, and calling area uses the correct overridden method. Dispatch is constant time in typical implementations.
Ans. Unit testing is testing small, isolated parts of code, usually individual functions or classes, to check they behave correctly. Software design principles are guidelines for building maintainable systems, such as separation of concerns, loose coupling, high cohesion, and SOLID. The key detail is that good design makes unit testing easier and more reliable.
Ans. Hibernate SessionFactory is a heavyweight, thread-safe factory that creates Session objects for database operations and is usually built once per application. JDBC is low-level and requires manual SQL, connection handling and result mapping. Hibernate is an ORM that maps objects to tables, manages caching, transactions and dirty checking, but adds complexity and less direct control.
Ans. Use prefix sums and a hash map from prefix sum value to all indices where it appeared. If the same prefix sum appears at indices i and j, the subarray i + 1 to j sums to 0. Store prefix sum 0 at index -1. Time is O(n + k), where k is the number of answers, space is O(n).
Ans. I would never make direct changes on the live site. I would work in a local or development environment, use version control, test the change, then deploy through staging to production. The most important detail is to have a rollback plan, such as a backup or previous release, in case something breaks.
Ans. A binary tree is a tree where each node has at most two children. A binary search tree keeps left values smaller and right values larger, enabling average O(log n) search, insert and delete if balanced. A heap is a complete binary tree with heap order. A max heap keeps each parent greater than or equal to its children.
Ans. I ensure good coding practices by following agreed style guidelines, writing simple and readable code, and reviewing changes before they are merged. The most important detail is using automated checks, such as linters, formatters, static analysis, and tests, so standards are enforced consistently rather than relying only on individual judgement.
Ans. Use binary insertion sort: iterate from the second element, use binary search on the already sorted left part to find the correct insertion index, then shift larger elements right and insert the value. The array itself is the data structure. Search is O(log n), but shifting makes total time O(n²).
Ans. The Java Collections framework is a set of interfaces and classes for storing, accessing and manipulating groups of objects. Common interfaces are List, Set, Queue and Map. Common classes include ArrayList, LinkedList, HashSet, TreeSet, HashMap and PriorityQueue. The key detail is choosing by behaviour, such as ordering, uniqueness, key lookup and performance.
Ans. Convert the number by splitting it into three digit groups, translating each group, and appending scale words like thousand, million, and billion. Use arrays for ones, teens, tens, and scales. Handle zero separately, skip empty groups, and join parts with spaces. Time complexity is O(d), where d is the number of digits.
Ans. Build a palindromic tree, also called an Eertree, and the number of distinct palindromic substrings is the number of non-root nodes. Insert characters one by one, following suffix links to find the longest palindromic suffix that can be extended. This gives O(n) time and O(n) space.
Ans. Choose a real situation where the stakes were clear, such as pressure to hide an error, misuse data, or bypass a process. Emphasise staying calm, gathering facts, considering policy and impact, seeking advice when appropriate, and acting transparently. Interviewers listen for judgement, integrity, accountability, and respect for people affected.
Ans. Treat the given ratios as fractions: 1/9, 1/3, and 1/5. Add them: 1/9 + 1/3 + 1/5 = 29/45. Each part is 17 multiplied by its fraction divided by 29/45. The three parts are 85/29, 255/29, and 153/29.
Ans. A HashMap stores key value pairs and gives average O(1) lookup, insertion and deletion. For Two Sum, scan the array once, and for each number check whether target minus number is already in the map. If yes, return both indices. Otherwise store the number with its index. Time is O(n), space is O(n).
Ans. Agile is an iterative software development approach where teams deliver small increments, get feedback early, and adapt quickly to change. Low-level design is the detailed design of components, classes, interfaces, methods, data structures, and interactions before coding. The key point is that Agile guides delivery, while low-level design guides implementation.
Ans. Pick a situation where priorities changed, a deadline was tight, or a new tool had to be learned quickly. Emphasise how you prioritised, communicated trade-offs, learned efficiently, and stayed calm. Interviewers listen for organisation, curiosity, flexibility, ownership, and evidence that speed did not reduce quality or teamwork.
Ans. Use proper indexing, efficient queries, caching, pagination, connection pooling, normalised schema design, and database profiling. The most important detail is to measure first using slow query logs and execution plans, because indexes and query changes should target real bottlenecks rather than guesses. For larger systems, consider denormalisation, partitioning, and read replicas.
Ans. Searching finds an item in a collection, while sorting arranges items in order. Linear search checks each element and takes O(n). Binary search works on sorted data and takes O(log n). Common sorts include bubble, selection and insertion at O(n²), merge sort and heap sort at O(n log n), and quicksort average O(n log n), worst O(n²).
Ans. Select the distinct salaries, sort them in descending order, and return the second row using an offset. The key detail is using distinct, so duplicate top salaries do not hide the true second highest salary. This approach sorts the salary values, so its typical time complexity is O(n log n).
Ans. The browser resolves the domain to an IP address, opens a connection to that server, sends an HTTP or HTTPS request, receives a response, and renders the page. The key step is DNS lookup: www.google.com is translated into an IP address, often using cache first, then recursive DNS servers if needed.
Ans. JavaScript is single threaded, but it handles asynchronous work through the event loop, callback queues and browser or runtime APIs. Timers, I/O and promises run outside the call stack, then resume later. Async functions always return a Promise. Await pauses that function, schedules the continuation as a microtask, and lets other code run.
Ans. Use backtracking to build every subsequence, store each result in a sorted set, then output the set in order. The sorted set removes duplicates caused by repeated characters and maintains lexicographic order. This generates 2^n candidates, with insertion costs, so time is about O(2^n n log k) and space O(kn).
Ans. Store data using a schema designed for the main access patterns, with proper indexing, partitioning, and controlled denormalisation where reads are heavy. The most important detail is to avoid full table scans under load, so frequently queried fields should be indexed and large tables split by key, range, or time.
Ans. Choose a recent work situation with real stakes, such as a missed deadline, conflict, outage, or demanding client. Emphasise your specific actions, judgement, communication, and ownership. Show how you stayed calm, involved others appropriately, made trade-offs, and achieved a measurable result. Interviewers listen for resilience, accountability, and learning.
Ans. I would design it as stateless application services behind a load balancer, backed by scalable data stores, caching, queues, and strong observability. The most important detail is separating read, write, and background work so each can scale independently, with horizontal scaling, database indexing, read replicas, rate limiting, auto-scaling, and clear failure handling.
Ans. Multithreading is running multiple threads within one process so tasks can progress concurrently while sharing the same memory. A simple demonstration is a program that creates two Thread objects, each printing numbers from 1 to 5, starts both, then joins them. It uses no special data structure, and each thread runs in O(n) time.
Ans. Model the main real-world things as classes, their individual examples as objects, their data as attributes, and their actions as methods. For example, in a library system, Book, Member, and Librarian are classes; a specific copy of a book is an object. The key is defining clear responsibilities and relationships between classes.
Ans. Compute the survivor with the recurrence survivor = (survivor + k) mod i for i from 1 to n, starting survivor at 0. This gives the 0-indexed position; add 1 for a 1-indexed answer. Use an iterative approach with constant storage, taking O(n) time and O(1) space.
Ans. A String in Java can be created using a string literal, using new String(), from a character or byte array, or by converting another object such as StringBuilder with toString(). String literals are stored in the String Pool, which is part of the heap in modern Java. Identical literals share the same pooled object.
Ans. Use BFS for an unweighted graph and Dijkstra’s algorithm for a weighted graph with non-negative edge weights. Store distances in an array, initialise the source to 0 and others to infinity. BFS uses a queue and runs in O(V + E). Dijkstra uses a min-priority queue and runs in O((V + E) log V).
Ans. Pick a real example where you addressed poor performance early and fairly. Emphasise understanding the cause, giving clear feedback, agreeing measurable improvements, offering support, and following up consistently. Show you balanced empathy with accountability. Interviewers listen for maturity, direct communication, documentation, and a focus on team outcomes rather than blame.
Ans. OOP organises code around objects that combine state and behaviour, using encapsulation, abstraction, inheritance and polymorphism. Function overloading means same function name with different parameter lists, resolved at compile time. Overriding means a subclass provides a new implementation of a parent method. Virtual functions enable runtime dispatch, so the correct overridden method is called through a base reference.
Ans. Choose a real team conflict with clear stakes, such as missed deadlines, unclear ownership, or tension between colleagues. Emphasise how you listened to both sides, clarified facts, set expectations, and kept the work moving. Interviewers listen for maturity, fairness, communication, accountability, and a practical outcome, not blame or drama.
Ans. Common data structures include arrays, linked lists, stacks, queues, hash tables, trees, heaps, and graphs, while common algorithms include sorting, searching, recursion, dynamic programming, greedy methods, and graph traversal. They help model the problem efficiently, choose fast operations, and reduce time or space complexity, often deciding whether a solution scales.
Ans. It is possible exactly when x is no more than max(a, b) and x is divisible by gcd(a, b). Use the Euclidean method: fill one container, pour into the other until full, empty the full one, and repeat. The amounts reached are multiples of gcd(a, b), so you stop when x appears.
Ans. Model it with ParkingLot, Floor, Spot, Vehicle, Ticket and Payment classes. ParkingLot owns floors, Floor owns spots by type, Vehicle has size, and Ticket links vehicle, spot and entry time. Keep available spots in queues or sets per type for O(1) allocation and release, with payment calculated on exit.
Ans. I solve these by writing down the facts, turning each clue into a constraint, and eliminating impossible options. I look for the strongest clue first, then test remaining cases systematically. Under time pressure, I avoid guessing and state assumptions clearly. If no unique answer follows, I explain why the information is insufficient.
No question matches those filters. Reset filters.
Showing 60 of 191 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 (54%) and DSA (26%).
Candidate interviews show an average of 3.0 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 51%, medium 48%, hard 1%.
