537 questions from 46 interviews · updated from reports 2013-2023
About
VMware is a cloud computing and virtualization software company known for products that help run and manage applications across data centers and clouds. In India, it hires for technical roles such as software engineer, software engineering intern, and IT application developer.
The roles that come up most are Software Engineer, Software Engineering Intern and IT Application Developer. This covers 46 candidate interviews reported from 2013 to 2023. Most sat it at entry level (25 of 45 that recorded a level), with 15 internship interviews alongside. Among the 40 that recorded either route, arrivals split between campus drives (33, 82%) and off-campus applications (7, 18%). Most questions fall under CS fundamentals and DSA.
Ans. Use two pointers: move the first pointer k nodes ahead, then move both pointers together until the first reaches the end. The second pointer is then at the kth node from the end. This uses no extra data structure, runs in O(n) time, and uses O(1) space.
Ans. Garbage collection in Java is automatic memory management that finds objects no longer reachable by the program and reclaims their heap memory. The key point is reachability from roots such as stack variables, static fields and active threads. It reduces manual memory errors, but collection timing is not deterministic and may briefly pause execution.
Ans. Page replacement algorithms decide which memory page to evict when a page fault occurs and RAM is full. Common policies include FIFO, LRU, Optimal and Clock. The key goal is to minimise page faults: LRU approximates real usage well, Optimal is theoretical, and Clock is a practical low overhead approximation.
Ans. CPU scheduling algorithms decide which ready process runs next. Common ones are First Come First Served, Shortest Job First, Priority Scheduling, Round Robin, and Multilevel Queue. The key trade-off is between fairness, response time, throughput, and starvation. Preemptive algorithms can interrupt running processes, while non-preemptive ones wait until completion or blocking.
Ans. Page replacement algorithms choose which memory page to evict when a page fault occurs and physical memory is full. FIFO removes the oldest page, Optimal removes the page used farthest in the future, LRU removes the least recently used page, LFU removes the least frequently used page, and Clock approximates LRU using reference bits.
Ans. Use level order traversal with a queue, but alternate the direction of output at each level. Process one level at a time, collect its nodes in a temporary list, reverse or insert based on the current direction, then toggle the direction. This takes O(n) time and O(w) space, where w is tree width.
Ans. Use a stack to convert infix to postfix by scanning the expression left to right and outputting operands immediately. Push opening brackets, pop until an opening bracket on closing brackets, and for operators pop higher or equal precedence operators before pushing the current one. Finally pop remaining operators. This runs in O(n) time.
Ans. Use BFS while assigning each node a column index, with root at 0, left child at column minus 1 and right child at column plus 1. Store values in a map from column to list. Finally output lists from smallest to largest column. Time is O(n log n) with an ordered map.
Ans. A deadlock is when two or more threads wait forever because each holds a resource the other needs. For example, thread A locks resource 1 then waits for resource 2, while thread B locks resource 2 then waits for resource 1. Demonstrate it with two mutexes and two threads. Time complexity is not relevant.
Ans. Build a hash set of all values in the second linked list, then traverse the first linked list and print each value not found in that set. This avoids nested scans. The time complexity is O(n + m), where n and m are the list lengths, and the extra space is O(m).
Ans. Reverse it by walking through the list once and redirecting each node’s next pointer to the previous node. Keep three pointers: previous, current, and next, so you do not lose the remaining list. At the end, previous becomes the new head. Time is O(n), space is O(1).
Ans. The OSI model has seven layers: physical, data link, network, transport, session, presentation and application. They describe how data moves from raw bits on a medium, through framing, routing and reliable delivery, up to user-facing protocols. The key idea is separation of concerns, so each layer provides services to the one above.
Ans. Build a Node.js API with Express by defining REST routes, middleware for validation and authentication, controllers for business logic, and a repository layer for database access. Use JSON request and response bodies, clear status codes, and central error handling. Store records in a database indexed by id, giving typical lookups O(1) or O(log n).
Ans. The Singleton pattern ensures a class has exactly one instance and provides a global access point to it. It is usually implemented with a private constructor and a static method or property returning the instance. The key detail is thread safety, especially if the instance is created lazily in a multi-threaded program.
Ans. Thrashing is a state where an operating system spends most of its time swapping pages between RAM and disk instead of executing processes. It happens when memory demand is too high and processes suffer frequent page faults. The key effect is severe performance collapse, often fixed by reducing multiprogramming or adding memory.
Ans. An HDD stores data on spinning magnetic disks, while an SSD stores data in flash memory with no moving parts. SSDs are much faster for booting, loading files, and random access, and are more shock resistant. HDDs are usually cheaper per gigabyte and better for large low-cost storage.
Ans. TCP is connection-oriented and reliable, while UDP is connectionless and faster but does not guarantee delivery. TCP orders packets, retransmits lost data, and provides flow and congestion control. UDP sends datagrams with minimal overhead, so it is useful for real-time traffic like video calls, gaming, DNS, or streaming where some loss is acceptable.
Ans. Common data structures organise data so it can be stored, found, updated, and processed efficiently. Arrays store items contiguously for fast indexing, linked lists support cheap insertion by links, stacks and queues control access order, hash tables give fast key lookup, trees keep hierarchy or sorted order, and graphs model connected relationships.
Ans. Use a hash map where the key represents the letters of a word, and the value is the list of words with that key. For each word, sort its characters to form the key, then append it to the matching group. Time complexity is O(n k log k), where k is word length.
Ans. The SDLC phases are planning, requirements analysis, design, implementation, testing, deployment and maintenance. Planning defines scope and feasibility, requirements capture what users need, design describes the architecture, implementation builds it, testing verifies quality, deployment releases it, and maintenance fixes issues and improves the software over time.
Ans. Cut the seven-unit bar into pieces of 1, 2, and 4 units using two cuts. Pay one unit on day one, swap it for the 2-unit piece on day two, add the 1-unit piece on day three, swap both for the 4-unit piece on day four, then combine pieces to make five, six, and seven.
Ans. Use merge sort, because linked lists can be split and merged without random access. Find the middle with slow and fast pointers, recursively sort both halves, then merge two sorted lists by relinking nodes. This takes O(n log n) time and O(log n) stack space, or O(1) extra space if done bottom-up.
Ans. Use a min heap to repeatedly take the smallest current element among the k arrays and append it to the result. Initially push the first element of each non-empty array with its array index and position. After popping one, push the next element from the same array. Time complexity is O(N log k), where N is total elements.
Ans. Trace the code line by line, checking variable values, control flow, object references, and boundary cases. In Java, the most common issues are null references, off-by-one loops, incorrect string comparison using == instead of equals, integer division, and collection mutation during iteration. State the failing input and the minimal fix clearly.
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. Use Floyd’s cycle detection with two pointers, slow and fast, starting at the head. Move slow one node at a time and fast two nodes at a time. If they ever meet, there is a loop. If fast reaches null, there is no loop. This runs in O(n) time and O(1) space.
Ans. The OSI model is a seven-layer framework for understanding network communication: Physical, Data Link, Network, Transport, Session, Presentation and Application. Data is encapsulated as it moves down the layers and decapsulated on receipt. Each layer has a clear role, from sending bits to routing packets, reliable delivery, formatting data and supporting user-facing protocols.
Ans. Quick Sort is a divide and conquer sorting algorithm that chooses a pivot, partitions the array so smaller elements go before it and larger elements after it, then recursively sorts both sides. Its key detail is pivot choice: average time is O(n log n), but poor pivots can make it O(n²).
Ans. Implement an LRU cache with a hash map from key to list node and a doubly linked list ordered by recent use. On get, return the value and move the node to the front. On put, update or insert at the front. If capacity is exceeded, remove the tail. Both operations are O(1).
Ans. Ports are numbered endpoints on a machine, protocols are agreed rules for communication, and SMTP is the protocol used to send email between mail clients and mail servers. A port helps deliver network traffic to the right application. SMTP commonly uses port 25 for server-to-server mail, 587 for authenticated submission, and 465 for TLS.
Ans. A volatile variable in Java is a variable whose reads and writes are always made visible across threads. When one thread writes to it, other threads reading it see the latest value. It also creates ordering guarantees around that access. Volatile does not make compound actions, like incrementing, atomic.
Ans. Use one FIFO queue and rotate it after every push so the newest element moves to the front. To push x, enqueue x, then dequeue and enqueue the previous size elements. Then pop and top are just dequeue and front. Push is O(n), pop and top are O(1), with O(n) space.
Ans. Routing protocols decide paths by exchanging network reachability information, mainly as distance vector, link state, or path vector protocols. Distance vector protocols like RIP share routes with neighbours and use hop count. Link state protocols like OSPF build a topology map. Path vector protocols like BGP choose inter-domain routes using policies and AS paths.
Ans. AES is a symmetric block cipher that encrypts 128-bit blocks using a 128, 192, or 256-bit key. It runs several rounds of substitution, row shifting, column mixing, and key addition. The number of rounds depends on key size. In practice, AES must be used with a secure mode and IV or nonce.
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. AES is a symmetric block cipher that encrypts 128-bit blocks using the same secret key for encryption and decryption. Its main variants are AES-128, AES-192 and AES-256, named by key length, with more rounds for longer keys. In practice, AES is used with modes such as CBC, CTR or GCM, with GCM providing authentication.
Ans. Polymorphism in OOP means one interface can represent different underlying types, and the correct behaviour is chosen for the actual object. It appears as method overloading at compile time and method overriding at run time. The key benefit is writing flexible code against abstractions, while subclasses provide their own specific implementations.
Ans. Reverse the linked list in groups of k by first checking that k nodes exist, then reversing only that block. Use a dummy head and three pointers: previous group tail, current node, and next node. After each reversal, reconnect the reversed block to the list. Leave fewer than k remaining nodes unchanged. Time is O(n), space is O(1).
Ans. Lazy loading loads data or resources only when they are actually needed, while eager loading loads them upfront before they are used. Lazy loading can reduce initial time and memory use but may cause later delays or extra queries. Eager loading can improve later access speed but may waste work if data is never used.
Ans. Use Quickselect to find the Kth largest element by partitioning the array around a pivot and only recursing into the side that can contain the answer. Convert it to the index n minus k in sorted ascending order. Average time is O(n), worst case O(n²), with O(1) extra space.
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. Java heap memory is configured mainly with JVM options such as -Xms for the initial heap size and -Xmx for the maximum heap size. The heap stores objects and is managed by garbage collection. It is typically divided into young and old generations, and correct sizing helps balance throughput, pauses, and memory use.
Ans. A Java thread moves through NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING and TERMINATED states. It is NEW after creation, becomes RUNNABLE after start(), may run when scheduled, may block on locks or wait for signals or timeouts, and ends when run() completes or throws. A terminated thread cannot be restarted.
Ans. Square every number, sort the squared values, then for each largest value treat it as the hypotenuse and use two pointers to find pairs whose sum equals it. Store or print each matching triplet, skipping duplicates if needed. Sorting plus the nested two-pointer search gives O(n squared) time and O(n) space.
Ans. Use a hash set for each list, then return the elements that appear in all three sets. This gives the unique common elements and avoids repeated output from duplicates. Build sets for two lists, scan the third, and check membership in both. Time complexity is O(n + m + k), with O(n + m) extra space.
Ans. Java implements OOP through classes and objects, with encapsulation, inheritance, polymorphism and abstraction built into the language. Encapsulation uses access modifiers and methods to protect state. Inheritance uses extends, while interfaces use implements. Polymorphism comes from method overriding, overloading and dynamic dispatch, with abstraction via abstract classes and interfaces.
Ans. Left rotate the string by 6 by moving the first 6 characters to the end, preserving their order. If the string length is n, first use k = 6 mod n to handle shorter strings or repeated rotations, then form string[k to end] followed by string[0 to k-1]. This takes O(n) time and O(n) space.
Ans. Choose a real, low-drama conflict where you improved the outcome, not one where you simply “won”. Emphasise listening, separating facts from assumptions, staying respectful, and agreeing clear next steps. Interviewers listen for maturity, ownership, calm communication, and whether you can protect relationships while still addressing the issue directly.
Ans. Use a fixed size array with two indices, front and rear, plus a size counter. Enqueue writes at rear and moves rear to (rear + 1) modulo capacity. Dequeue reads from front and moves front similarly. The size counter distinguishes full from empty. Both operations take O(1) time.
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. Pick a real, low-drama disagreement about priorities, approach, or feedback. Emphasise that you stayed respectful, clarified the goal, brought evidence, listened to their view, and looked for a workable decision. Interviewers listen for maturity, ownership, emotional control, and the ability to support the final decision even if it was not yours.
Ans. Design a modular platform with services for ticketing, entry control, ride operations, queues, staff, payments, maintenance, and reporting. The key detail is real-time capacity management: ingest scans, ride status, sensor data, and bookings into an event stream so queues, crowd levels, safety limits, and guest app updates stay accurate.
Ans. Use relational tables for users, addresses, products, categories, inventory, carts, cart_items, orders, order_items, payments, shipments and reviews. The key detail is to copy price, product name and tax data into order_items at purchase time, so historical orders remain correct even if catalogue data changes later.
Ans. Identify the topic first, such as percentages, ratios, time and work, speed, profit, or probability. Write down the given values, convert units if needed, and form a simple equation. Use approximation where exact calculation is slow. Check whether the answer is reasonable before choosing an option.
Ans. Switching is the better strategy: it wins with probability 2/3, while staying wins 1/3. Your first choice has a 1/3 chance of being the car. The other two doors together have 2/3. Monty always opens a goat door among them, so that full 2/3 transfers to the single unopened door.
Ans. Choose a real project where technology choices clearly affected delivery, cost, scale, or maintainability. Explain the problem, constraints, options considered, and why the chosen stack fitted best. Emphasise trade-offs, team skills, risks, and long-term support. Interviewers listen for pragmatic reasoning, not favourite tools or trend-following.
Ans. You should switch. Initially your chosen door has probability 1/3 of hiding the car, and the other two doors together have probability 2/3. Monty knows where the car is and always opens a goat door, so that 2/3 probability moves to the single unopened door. Staying wins 1/3; switching wins 2/3.
Ans. Start by defining inputs, outputs, constraints, and failure cases, then design the main flow with clear components and data movement. Use the simplest data structure that supports the key operations efficiently, such as a hash map for fast lookup or a queue for ordering. State time and space complexity for the critical path.
Ans. Use standard formulas, then solve step by step. For boats, downstream speed is boat plus stream, upstream is boat minus stream. For profit and loss, profit or loss percentage is based on cost price. For data analysis, read tables or charts carefully, total relevant values, compare ratios, averages, or percentages, and avoid mixing units.
Ans. Use standard formulas and convert each problem into rates, ratios, or percentages. For Time and Work, find one day’s work and combine rates. For Probability, count favourable outcomes over total outcomes. For Profit and Loss, use cost price, selling price, profit percentage, and loss percentage relationships, then solve step by step.
No question matches those filters. Reset filters.
Showing 60 of 537 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 (32%).
Candidate interviews show an average of 4.6 rounds per experience, with a typical sequence of Online test → Technical → Technical → Managerial → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 44%, medium 52%, hard 4%.
