867 questions from 83 interviews · updated from reports 2013-2025
About
Morgan Stanley is a financial services firm that provides investment banking, securities, wealth management, and investment management services to clients. In India, it hires for technology roles such as Software Engineer, Technology Analyst, and Summer Intern, often supporting trading, risk, data, and internal platforms.
The roles that come up most are Software Engineer, Summer Intern and Technology Analyst. This covers 83 candidate interviews reported from 2013 to 2025. Most sat it at entry level (42 of 82 that recorded a level), with 35 internship interviews alongside. Among the 74 that recorded either route, arrivals split between campus drives (50, 68%) and off-campus applications (24, 32%). Most questions fall under CS fundamentals and DSA.
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. Use dynamic programming to build the longest common subsequence length for every pair of prefixes of the two strings. Store results in a two-dimensional table where a character match adds one from the diagonal, otherwise take the maximum of left and top. Backtrack through the table to reconstruct the subsequence. Time is O(nm), space is O(nm).
Ans. A process is an independent running program with its own memory space, while a thread is a smaller unit of execution inside a process that shares that process’s memory. Processes are more isolated but heavier to create and switch between. Threads are lighter and communicate easily, but shared memory makes bugs and races more likely.
Ans. Use depth first search from the root, carrying the running sum, and update the answer only when a leaf is reached. The key detail is that a valid path must end at a leaf, so do not stop at missing children. Visit each node once, using the recursion stack, with O(n) time and O(h) space.
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. Use breadth first search with a queue. Put the root in the queue, then repeatedly remove the front node, visit it, and add its left and right children if they exist. This visits nodes level by level from left to right. The time complexity is O(n), and the space complexity is O(w), where w is the maximum width.
Ans. Copy the data from the next node into the given node, then link the given node to the next node’s next pointer, effectively removing the next node. This works in O(1) time and O(1) space, but it cannot be done if the given node is the tail.
Ans. Call by value passes a copy of the variable, while call by reference passes access to the original variable. If a function changes a call by value parameter, the caller’s variable is unchanged. With call by reference, the caller’s variable can change, such as a swap function actually swapping two original numbers.
Ans. I would write a query that joins orders, customers, and payments, groups by customer, filters recent orders, and uses a window function to rank customers by total spend. The key detail is to aggregate before ranking, so each customer has one row. With indexed join and filter columns, performance is mainly driven by scan and sort cost.
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. Design it as services for catalogue, search, recommendations, reviews, payments, developer publishing, entitlement, and downloads, backed by relational metadata, object storage for APKs or bundles, and a CDN. The key detail is versioned, signed artefacts with staged rollout rules, so clients securely fetch the right app build for device, region, and user entitlement.
Ans. Design it with search, booking, payment, ticketing and notification services over train, schedule, fare and seat inventory data. The key detail is preventing double booking: lock or reserve seats with a short expiry during payment, then confirm atomically after payment succeeds. Use caches for search, but keep inventory in a strongly consistent store.
Ans. Use BFS to find the minimum number of Fibonacci jumps from position -1 to the bank at N. Precompute Fibonacci numbers up to N + 1, then explore reachable leaf positions and the bank with a queue and visited array. Each level is one jump. Time complexity is O(N log N).
Ans. Implement a Trie using nodes that store a map from character to child node and a boolean marking the end of a word. To insert or search, walk character by character, creating nodes for insert and failing early for search if a child is missing. Insert, search, and prefix lookup take O(L) time, where L is the string length.
Ans. Use Floyd’s slow and fast pointers to detect the loop, then find the loop start and set the last node in the loop to null. After detection, move one pointer to the head and advance both one step until they meet. Then traverse the loop to find its previous node. Time is O(n), space is O(1).
Ans. Scan the sorted intervals once, keeping the current merged interval and extending it while the next interval overlaps. If the next start is greater than the current end, add the current interval to the result and start a new one. Use a list for output. Time complexity is O(n), with O(n) extra space.
Ans. Design it as a service that tracks car parks, floors, bays, vehicle entries, payments and exits, with real-time bay availability. Gate devices call APIs to allocate the nearest suitable bay, create a ticket, calculate fees on exit and update occupancy atomically. The most important detail is preventing double allocation using transactions or distributed locks.
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. Use Quickselect to find the middle element without fully sorting the array. For odd length, select index n/2; for even length, select both middle indices and average them. Quickselect partitions like Quicksort and runs in average O(n) time with O(1) extra space, though worst case is O(n²).
Ans. A map is usually implemented as either a hash table or a balanced search tree. In a hash table, a key is hashed to find a bucket, and collisions are handled by chaining or probing. Average lookup, insert and delete are constant time. Ordered maps often use balanced trees with logarithmic time operations.
Ans. Use dynamic programming where dp[s] stores the number of ways to reach sum s after processing some dice. For each die, build a new array by trying every face value from 1 to k and adding previous counts. Take modulo 1,000,000,007. Time complexity is O(n target k), space is O(target).
Ans. Virtual memory is an OS mechanism that gives each process a large logical address space by mapping virtual pages to physical RAM or disk. Thrashing happens when memory is overcommitted and the system spends most of its time swapping pages instead of running programs. It is reduced by adding RAM or limiting active processes.
Ans. A polymorphic reference in Java is a superclass or interface variable that refers to an object of a subclass or implementing class. It lets code treat different concrete objects uniformly. The key detail is dynamic dispatch: overridden instance methods are chosen at runtime based on the actual object type, not the reference type.
Ans. Hadoop works by storing large files across a cluster using HDFS and processing them in parallel using MapReduce, usually managed by YARN. HDFS splits files into blocks, replicates them on DataNodes, and tracks metadata in the NameNode. Jobs run near the data, then map, shuffle, and reduce results with fault recovery.
Ans. Virtual memory is an OS memory abstraction that gives each process its own address space, while semaphores are synchronisation primitives used to control access to shared resources. Virtual memory maps virtual addresses to physical memory or disk pages. A semaphore holds a count, with wait decreasing it and signal increasing it, blocking when needed.
Ans. Print the matrix by maintaining four boundaries: top, bottom, left, and right, and repeatedly traverse right, down, left, and up while shrinking those boundaries. After each direction, check the boundaries have not crossed. This visits every cell once, uses no extra data structure apart from output, and runs in O(rows × columns) time.
Ans. RAID combines multiple disks to improve performance, reliability, or both. RAID 0 stripes data for speed but has no redundancy. RAID 1 mirrors data for fault tolerance. RAID 5 uses striping with distributed parity and can survive one disk failure. RAID 6 survives two failures. RAID 10 combines mirroring and striping.
Ans. Hashing with quadratic probing stores keys in a hash table and resolves collisions by trying positions at quadratic distances from the original hash index. For key k, probes are typically h(k), h(k)+1², h(k)+2², modulo table size. It reduces primary clustering, but needs a suitable table size and load factor.
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. Use a breadth first traversal with a queue, where each queue entry starts a diagonal. For each popped node, follow its right pointers, adding values to the current diagonal sum and pushing any left child into the queue for the next diagonal. This visits every node once, so time is O(n) and space is O(w).
Ans. Use DFS to detect a cycle by tracking visited nodes and the current recursion stack. In a directed graph, reaching a node already in the recursion stack means a cycle exists. In an undirected graph, a visited neighbour is a cycle only if it is not the parent. Time complexity is O(V + E).
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. Store the result as an array or string of decimal digits and simulate multiplication from 2 to n with carry. For each multiplier, multiply every stored digit, update it with value modulo 10, and carry forward the quotient. The time complexity is O(n d), where d is the number of digits in n!.
Ans. Use Kahn’s algorithm: compute indegree for every vertex, push all zero-indegree vertices into a queue, repeatedly remove one, add it to the order, and reduce indegrees of its neighbours. If a neighbour becomes zero, enqueue it. Use an adjacency list and indegree array. Time complexity is O(V + E).
Ans. All-pairs shortest path means finding the shortest distance between every ordered pair of vertices in a weighted graph. The standard solution is Floyd-Warshall, using a distance matrix and relaxing through each intermediate vertex. It handles negative edges but not negative cycles, and runs in O(V³) time with O(V²) space.
Ans. Java Garbage Collection automatically frees heap memory by removing objects that are no longer reachable from live references. The key idea is reachability from GC roots, such as thread stacks, static fields and JNI references. Most JVMs use generational collection, treating young objects and long-lived objects differently to reduce pause time and improve throughput.
Ans. Scan the grid and start a DFS or BFS whenever you find an unvisited land cell, counting that as one island. Use a visited set or mark cells in place, and explore the four neighbouring cells to consume the whole island. The time complexity is O(rows × columns), with similar worst-case space.
Ans. Cassandra routes each request through a coordinator node, which uses the partition key and token ring to find replica nodes. Writes go to the commit log and memtable, then flush to immutable SSTables and are compacted. Reads check memtables and SSTables using indexes and Bloom filters, then reconcile replicas by timestamp.
Ans. Concurrency in MongoDB is achieved through the storage engine’s locking and transaction model, mainly document-level concurrency in WiredTiger. Multiple clients can read and write different documents in the same collection at the same time. Operations on a single document remain atomic, while conflicting writes to the same document are serialised.
Ans. ConcurrentHashMap stores entries in an internal hash table and allows safe concurrent access by locking only small parts of the table, not the whole map. In modern Java, reads are mostly lock-free using volatile reads, while updates use CAS and synchronisation on individual bins. Collisions use linked lists or tree bins, and resizing is shared across threads.
Ans. Delta tables are storage tables in Delta Lake that store data in Parquet files with a transaction log. Their main advantage is reliable data lake processing with ACID transactions, so reads and writes stay consistent. They also support schema enforcement, time travel, updates, deletes, merges, and efficient batch or streaming workloads.
Ans. In Python, a list is the built-in general-purpose sequence, while an array usually means a typed sequence from the array module or NumPy. Lists can hold mixed types and resize dynamically. Arrays store elements of one type, so they are more memory efficient and better for numeric data. Both support indexed access.
Ans. A mutex provides exclusive access to one shared resource, while a semaphore controls access to a limited number of resource instances. A mutex is locked and unlocked by the same thread, giving ownership. A semaphore is usually a counter, and any thread may signal it, making it useful for coordination as well as resource limiting.
Ans. Garbage Collection in Java automatically reclaims heap memory used by objects that are no longer reachable from live references. The collector starts from GC roots such as stack variables, static fields and active threads, marks reachable objects, then frees or compacts the rest. Most collectors are generational, because short-lived objects are common.
Ans. Object slicing happens when a derived class object is copied or assigned to a base class object by value, so only the base part is kept and the derived fields and behaviour are lost. The key point is to use references or pointers, often smart pointers, when polymorphic behaviour must be preserved.
Ans. Boundary traversal is usually root, left boundary, all leaves, then right boundary in reverse order. Add the root if it is not null, collect left boundary excluding leaves, collect leaves by DFS left to right, then collect right boundary excluding leaves and append it reversed. This avoids duplicates. Time complexity is O(n).
Ans. Use backtracking over a digit-to-letters map, building one character choice at each digit position until a complete word is formed. Store the current path in a string or character array and append completed words to a result list. Time complexity is O(k^n), more exactly the product of letters per digit, with O(n) recursion depth.
Ans. Store it as a table with one row per cell: array_id, row_index, column_index, and value. The key detail is access pattern: this normalised form is best if you need to query or update individual cells, while a JSON or binary blob is simpler if you only load and save the whole array.
Ans. Use heapsort: first rearrange the array into a max heap in place, then repeatedly swap the maximum element at the root with the last unsorted element and shrink the heap. Restore the heap property after each swap. It runs in O(n log n) time and uses O(1) extra space.
Ans. Implement Huffman coding by counting character frequencies, pushing each character node into a min heap, then repeatedly merging the two lowest frequency nodes until one tree remains. Assign 0 to one branch and 1 to the other to build prefix codes. Use a priority queue. Time complexity is O(n + k log k).
Ans. Use Kadane’s algorithm: scan the array once, keeping the best subarray sum ending at the current position and the best overall sum seen so far. At each element, either extend the previous subarray or start a new one. This uses only variables, runs in O(n) time, and O(1) space.
Ans. Pick a real example where the usual approach was blocked by time, budget, data, or process constraints. Emphasise how you reframed the problem, involved others, tested a practical alternative, and measured the result. Interviewers listen for originality balanced with judgement, not creativity for its own sake.
Ans. The hands meet at about 3:16:22 PM. At 3:00, the hour hand is 90 degrees ahead of the minute hand. The minute hand gains on it at 5.5 degrees per minute, since it moves 6 degrees per minute and the hour hand moves 0.5. Time taken is 90 ÷ 5.5 minutes.
Ans. Choose a real situation with enough complexity to show judgement, not a perfect success story. Explain the context briefly, your specific actions, the reasoning behind them, and the outcome. Emphasise ownership, communication, fairness, and learning. Interviewers listen for self-awareness, sound judgement under pressure, and behaviour that matches company values.
Ans. Pick a real example where the team faced conflict, unclear ownership, or pressure, and your leadership changed the outcome. Emphasise how you set direction, listened, resolved tensions, delegated, and kept people accountable. Interviewers listen for maturity, collaboration, self-awareness, measurable results, and whether you give credit to the team rather than only yourself.
Ans. Break the problem into known facts, unknowns, and relationships. Convert words into equations, tables, ratios, or diagrams as needed. Use elimination for logical reasoning and test assumptions carefully. Check units, percentages, and boundary cases. Finally, verify the answer by substituting it back into the original conditions.
Ans. Compare the two sets by first checking totals, averages, ranges, or ratios, depending on what the question asks. Look for the quickest relationship, not every possible calculation. Eliminate clearly wrong options early. If numbers are large, estimate first, then calculate only where the comparison is close.
Ans. Fill the 5-litre can and pour into the 3-litre can, leaving 2 litres. Empty the 3-litre can, wasting 3 litres. Pour the 2 litres into it. Fill the 5-litre can again, then pour 1 litre into the 3-litre can. The 5-litre can now holds exactly 4 litres.
Ans. One trip is enough, assuming the bulbs get warm. Give each switch a different heat signature: leave one on, leave one off, turn three others on for long, medium, and short times, then switch them off before leaving. Visit the bulbs once. The lit bulb, hot bulb, warm bulb, slightly warm bulb, and cold bulb identify all switches.
Ans. One turn is enough. Take one ball from the box labelled R+B. Since every label is wrong, that box cannot be mixed, so it must contain only the colour you draw. If it is red, label it R. The box labelled B cannot be B, so it is R+B, and the last is B. Reverse colours if needed.
No question matches those filters. Reset filters.
Showing 60 of 867 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 (45%) and DSA (37%).
Candidate interviews show an average of 3.7 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 36%, medium 58%, hard 6%.