472 questions from 41 interviews · updated from reports 2016-2024
About
Arcesium is a financial technology company that provides cloud-based data, operations, and accounting platforms for hedge funds, asset managers, and other financial firms. In India, it commonly hires for technical roles such as software engineer, software engineer intern, and senior software engineer.
The roles that come up most are Software Engineer, Software Engineer Intern and Senior Software Engineer. This covers 41 candidate interviews reported from 2016 to 2024. The largest group sat it at internship level (17 of 39 that recorded a level). Among the 35 that recorded either route, arrivals split between campus drives (20, 57%) and off-campus applications (15, 43%). Most questions fall under CS fundamentals and DSA.
Ans. Print the first node visible at each depth when the tree is viewed from the left. Do a level order traversal using a queue, and for each level print the first node removed from the queue. This visits every node once, so the time complexity is O(n), with O(w) space for the queue.
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. Design it with levels, parking spots by type, vehicles, tickets, gates and a payment service. Keep an in-memory or database-backed index of available spots per spot type, so entry can allocate the nearest valid spot quickly and exit can free it, calculate fees from the ticket, and update occupancy atomically.
Ans. Synchronization is coordinating multiple threads so shared data is accessed safely and consistently. In Java it is achieved using synchronized methods or blocks, which use an object’s intrinsic lock. It can also use Lock classes, atomic variables, concurrent collections, and volatile for visibility. The key point is preventing race conditions and ensuring memory visibility.
Ans. Use dynamic programming where dp[i] is the maximum sum of an increasing subsequence ending at index i. Initialise dp[i] to arr[i], then for each earlier j, if arr[j] < arr[i], update dp[i] with dp[j] + arr[i]. The answer is the maximum value in dp. Time complexity is O(n²).
Ans. ACID properties are guarantees that make database transactions reliable: Atomicity, Consistency, Isolation, and Durability. Atomicity means all changes commit or none do. Consistency keeps data valid under rules and constraints. Isolation makes concurrent transactions behave safely. Durability means committed changes survive crashes, usually through logging and persistent storage.
Ans. Thrashing is a state where an operating system spends most of its time swapping pages between memory and disk instead of executing processes. It usually happens when there is not enough physical memory for the active working sets, causing constant page faults, very low CPU utilisation, and poor overall performance.
Ans. HashMap is not synchronised and allows one null key and multiple null values, while Hashtable is synchronised and allows neither null keys nor null values. HashMap is generally preferred for new code because it is faster in single-threaded use. If thread safety is needed, ConcurrentHashMap is usually a better choice than Hashtable.
Ans. Check it by traversing the tree recursively with an allowed value range for each node. The root can have an infinite range; the left child must be less than the node, and the right child greater. Use the call stack as the data structure. Time complexity is O(n), space is O(h).
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. Design it as a set of entry and exit services backed by a real-time inventory of spaces by car park, level, zone and vehicle type. On entry, allocate the nearest valid free bay, issue a ticket, and mark it occupied atomically. On exit, calculate fee, take payment, release the bay, and update displays.
Ans. Dijkstra’s algorithm finds the shortest path from a source node to all other nodes in a weighted graph with non-negative edge weights. It keeps tentative distances, repeatedly picks the unvisited node with the smallest distance using a priority queue, and relaxes its neighbours. With an adjacency list, it runs in O((V + E) log V).
Ans. Virtual address space is the range of memory addresses that a process can use, as seen by that process. These addresses are not necessarily physical RAM locations. The operating system and hardware memory management unit map virtual addresses to physical memory, enabling isolation between processes, simpler memory use, and support for paging or swapping.
Ans. A copy constructor in C++ creates a new object as a copy of an existing object, usually with the form ClassName(const ClassName& other). The key detail is that classes owning resources, such as dynamic memory or file handles, should define it to perform a deep copy and avoid shared ownership bugs.
Ans. Use cookies in REST APIs by returning a Set-Cookie header from the server, then reading the Cookie header on later requests. They are commonly used to carry a session identifier or refresh token. Set HttpOnly, Secure, and SameSite, and remember cookie-based authentication may need CSRF protection.
Ans. Normalize a table by identifying keys and dependencies, then decomposing it into smaller tables that remove redundancy and update anomalies. Ensure 1NF by making values atomic, 2NF by removing partial dependency on a composite key, and 3NF by removing transitive dependency. Preserve relationships using primary keys and foreign keys.
Ans. Use binary search by treating the matrix as a sorted one-dimensional array. For a matrix with m rows and n columns, map index mid to matrix[mid / n][mid % n], compare with the target, and shrink the search range. This uses no extra data structure and takes O(log(mn)) time.
Ans. A shallow copy creates a new outer object but keeps references to the same nested objects, while a deep copy also copies the nested objects recursively. The key difference is aliasing: changes to a shared nested object affect both shallow copies, but a deep copy is independent unless it intentionally shares immutable values.
Ans. Virtual memory is an abstraction that gives each process its own large, private address space, independent of physical RAM. Paging implements this by splitting virtual memory and physical memory into fixed-size pages and frames. A page table maps virtual pages to frames, and missing pages can be loaded from disk on demand.
Ans. Model it with classes such as Bank, Customer, Account, Transaction, Card and Loan, with Account subclasses like Savings and Current. Keep balances private and expose operations like deposit, withdraw and transfer. The most important detail is transaction safety: every money movement should be atomic, validated, audited and protected with locking or database transactions.
Ans. Use two stacks, one for incoming elements and one for outgoing elements. Enqueue pushes onto the incoming stack. Dequeue pops from the outgoing stack; if it is empty, move all elements from incoming to outgoing first. This reverses order correctly. Each operation is amortised O(1), with O(n) extra space.
Ans. Design it as modular services for patients, appointments, admissions, clinical records, billing, pharmacy, lab, staff, and notifications, backed by a relational database. The most important detail is access control and auditability, because medical data is sensitive. Use role based permissions, encrypted records, immutable audit logs, and reliable integrations with labs, insurers, and external systems.
Ans. SQL joins combine rows from two tables using a related column, usually a primary key and foreign key. The main types are INNER JOIN, which returns matching rows only; LEFT JOIN and RIGHT JOIN, which keep all rows from one side; FULL OUTER JOIN, which keeps all rows; and CROSS JOIN, which returns every combination.
Ans. Make the list circular, then break it at the new tail. First count the nodes n, set k = k mod n, and if k is zero return the head. Link the old tail to the head, move n - k - 1 steps to find the new tail, set its next as the new head, then cut the link. Time is O(n).
Ans. Build a manager to subordinates adjacency list, then run DFS or BFS from the head to compute the longest accumulated inform time. For each employee, add their manager’s informTime to the time so far. The answer is the maximum time reached. This visits each employee once, so time is O(n) and space is O(n).
Ans. Interfaces in C++ are usually implemented as abstract classes containing only pure virtual functions. C++ has no separate interface keyword, so a class “implements” an interface by publicly inheriting from that abstract class and overriding its functions. The important detail is to provide a virtual destructor to allow safe deletion through the interface pointer.
Ans. Use prefix sums and count equal remainders modulo K, because a subarray sum is divisible by K when two prefix sums have the same remainder. Keep a frequency map or array of remainders, starting with remainder 0 seen once. For each prefix, add its existing frequency to the answer. Time is O(n), space is O(K).
Ans. Virtual memory is an abstraction that gives each process its own large, private address space, mapped by the operating system and hardware to physical RAM or disk. A page fault happens when a process accesses a page not currently in RAM, so the OS loads it, or raises an error if the access is invalid.
Ans. Use level order traversal with a queue storing each node and its positional index, as if the tree were a complete binary tree. For each level, the width is last index minus first index plus one. Normalise indices at each level to avoid overflow. Time complexity is O(n), space complexity is O(w).
Ans. Multithreading in Java means running multiple threads within one process to perform tasks concurrently while sharing the same memory. Threads can be created with Thread, Runnable, Callable, or preferably managed through ExecutorService. The key concern is thread safety, handled using synchronised blocks, locks, volatile variables, concurrent collections, and careful coordination.
Ans. TCP provides reliable, ordered, connection-based delivery of bytes between two applications. It first establishes a connection using a three-way handshake, then splits data into segments with sequence numbers. Receivers send acknowledgements, and lost segments are retransmitted. TCP also uses flow control and congestion control to avoid overwhelming the receiver or network.
Ans. A DBMS is software that stores, organises and controls access to data. Core concepts include tables, rows, columns, schemas, primary and foreign keys, relationships, SQL queries, normalisation, indexing, transactions, ACID properties, concurrency control and recovery. The most important idea is maintaining correct, consistent data while allowing efficient access.
Ans. Indexing works by storing a separate data structure that maps column values to the locations of matching rows, so the database can find data without scanning the whole table. Most indexes use B-trees, which keep values sorted and make lookups, ranges, and ordering efficient, but indexes add storage cost and slow writes.
Ans. Use Floyd’s slow and fast pointer method to detect the loop, then remove it by finding the node where the cycle starts and setting the previous node’s next pointer to null. After slow and fast meet, move one pointer to head and advance both one step at a time. Time is O(n), space is O(1).
Ans. A file system is the operating system’s way of organising, storing, naming and retrieving data on storage devices. It provides files, directories, permissions and metadata while mapping logical file names to physical disk blocks. The key detail is that it manages both user-visible structure and low-level allocation, free space and access control.
Ans. Use a postorder DFS and keep a global best sum. For each node, compute the best downward gain from its left and right children, ignoring negative gains by taking zero. Update the global answer with node value plus both gains, then return node value plus the larger gain. Time is O(n), space is O(h).
Ans. volatile in Java makes a variable’s updates immediately visible to other threads and prevents certain instruction reordering around reads and writes of that variable. It is useful for simple shared flags or state. It does not make compound actions like increment atomic, so it is not a replacement for locking or Atomic classes.
Ans. Use dynamic programming to decide whether any subset sums to the target. Keep a boolean array dp of size target + 1, with dp[0] true, and for each number update sums backwards from target to number. Backward iteration ensures each item is used at most once. Time is O(n × target), space is O(target).
Ans. Indexing in a DBMS is a technique that creates a separate data structure to help find rows faster without scanning the whole table. It is used to speed up search, filtering, sorting, and joins. The key trade-off is that indexes take extra storage and make inserts, updates, and deletes slightly slower.
Ans. The diamond problem is an ambiguity caused by multiple inheritance when a class inherits from two classes that share the same base class. The derived class may get duplicate base members or unclear method resolution. It is resolved using virtual inheritance in C++, or by using interfaces and explicit override rules in languages like Java.
Ans. A DBMS transaction is a sequence of database operations treated as one logical unit of work. ACID means Atomicity, all operations happen or none do; Consistency, rules and constraints remain valid; Isolation, concurrent transactions do not interfere incorrectly; Durability, committed changes survive failures. These properties protect correctness, especially during errors or concurrency.
Ans. Function pointers are variables that store the address of a function and allow it to be called indirectly. They are used for callbacks, event handlers, dispatch tables, plugin interfaces, and choosing behaviour at runtime without large conditional blocks. The key detail is that the pointer’s type must match the function’s signature.
Ans. Use a running prefix sum and a hash map from prefix sum to its earliest index. At each index, if currentSum minus target has been seen, the subarray after that index to the current index has the required sum. Store unseen prefix sums. This works with negative numbers and runs in O(n) time and O(n) space.
Ans. Count frequencies with a hash map, then keep the K most frequent elements using a min heap of size K. For each distinct element, push its frequency and remove the smallest if the heap grows past K. This takes O(n log K) time and O(n) space.
Ans. Deadlock is a state where two or more processes wait forever because each holds a resource the other needs. It happens when mutual exclusion, hold and wait, no preemption, and circular wait all exist. Resolve it by prevention, avoidance such as Banker’s algorithm, detection with recovery, resource ordering, timeouts, or aborting processes.
Ans. Create an immutable object by making the class final, making all fields private and final, setting them only in the constructor, and providing no setters. The most important detail is to protect mutable state: make defensive copies in the constructor and return copies, not the original objects, from getters.
Ans. Increasing RAM to 1 TB lets the system keep much more data and more processes in memory, reducing paging or swapping to disk. This can greatly improve performance for memory-heavy workloads, but it does not make the CPU faster. The OS, motherboard, processor, and address space must support that much RAM.
Ans. Use fast doubling to compute the Nth Fibonacci number in O(log n) time by recursively calculating pairs F(k) and F(k + 1). The key formulas are F(2k) = F(k) × [2F(k + 1) − F(k)] and F(2k + 1) = F(k)^2 + F(k + 1)^2. Space is O(log n).
Ans. Use a custom stack implemented as a doubly linked list, with an extra pointer to the middle node. On every push or pop, update the size and move the middle pointer one step when the parity changes. Then finding the middle is just returning that pointer’s value, so it is O(1).
Ans. Make all elements equal to the median, and the minimum cost is the sum of absolute differences from that median. Sort the array, choose the middle element as the target, then add abs(a[i] minus median) for every element. Sorting dominates the time complexity, so it is O(n log n) with O(1) extra space apart from sorting.
Ans. Test authentication, authorisation, input validation, session handling, data protection, error handling, and configuration. Verify strong password rules, account lockout, MFA, access control for every role, SQL injection, XSS, CSRF, file upload restrictions, secure cookies, session timeout, HTTPS, sensitive data masking, safe error messages, rate limiting, and security headers.
Ans. Reverse each group of k nodes by iterating through the list and reversing pointers within the current group, then connect the previous group’s tail to the new head. Use only node pointers, not an extra data structure. If fewer than k nodes remain, usually leave them unchanged. Time complexity is O(n), space is O(1).
Ans. Sort people by crossing time. Send the two fastest as shuttlers. At each step, compare two strategies for moving the two slowest: fastest escorts each, or the two fastest move together then return. Add the cheaper cost, remove the two slowest, and repeat. For the classic 1, 2, 5, 10 case, the minimum is 17 minutes.
Ans. There is no unique answer without the jar capacities, starting amounts, and target. The method is to model each situation as a state of three water levels, then repeatedly fill, empty, or pour until a jar or combination equals the target. A target is possible only if it is a multiple of the capacities’ greatest common divisor.
Ans. About 2 to 3 percent. Assume 70 percent of residents have Facebook and about half of them use it daily, so 35 percent of the town. If a daily user spends about 30 minutes on it across 16 waking hours, the instant share is 35% × 30/960, then roughly doubled for lunchtime.
Ans. Pick a real case where you used data to narrow a gradual regression. Emphasise baseline metrics, latency breakdowns, traffic changes, dependencies, database queries, deploy history, and profiling. Interviewers listen for structured diagnosis, not guessing: isolate scope, form hypotheses, validate with evidence, mitigate user impact, then fix root cause and add monitoring.
Ans. Identify the topic first, then write the key formula before calculating. For profit and loss, use cost price, selling price and percentage change. For work and time, convert work into rates. For probability, use favourable outcomes over total outcomes. For basic maths, simplify step by step and check units, signs and percentages.
Ans. Use equations and clear variables. For time and work, convert each person’s work into rate per day and add or subtract rates. For ages, set present ages as variables and use time shifts. For family relations, draw or mentally trace the relation step by step, keeping gender and generation in mind.
Ans. A knockout tournament with n teams has n minus 1 matches. In each match, exactly one team is eliminated. To get one champion, n minus 1 teams must be eliminated. Therefore, the total number of matches is n minus 1. This also holds when some teams receive byes.
Ans. Choose a real challenge with stakes, such as a missed deadline risk, conflict, unclear requirements, or technical blocker. Emphasise your actions, judgement, communication, and learning, not just the problem. Interviewers listen for ownership, resilience, practical problem solving, collaboration, and evidence that the outcome improved because of what you did.
No question matches those filters. Reset filters.
Showing 60 of 472 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 (51%) and DSA (39%).
Candidate interviews show an average of 4.1 rounds per experience, with a typical sequence of Online test → Technical → Technical → Technical → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 36%, medium 56%, hard 8%.
