348 questions from 23 interviews · updated from reports 2016-2024
About
Veritas is a software company that provides enterprise data protection, backup and recovery, and data management products. In India, it is known for hiring Software Engineers, Associate Software Engineers, and Associate SQA Engineers for development, testing, and quality roles.
The roles that come up most are Software Engineer, Associate Software Engineer and Associate SQA Engineer. This covers 23 candidate interviews reported from 2016 to 2024. Most sat it at entry level (19 of 23 that recorded a level), with 3 internship interviews alongside. Among the 22 that recorded either route, arrivals split between campus drives (22, 100%). Most questions fall under CS fundamentals and DSA.
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 two pointers: move a slow pointer one node at a time and a fast pointer two nodes at a time. When the fast pointer reaches the end, the slow pointer is at the middle. This uses no extra data structure, runs in O(n) time, and O(1) space.
Ans. A mutex is a lock for exclusive access by one thread, while a semaphore is a counter that allows a fixed number of threads to access a resource. The key difference is ownership: the thread that locks a mutex should unlock it, but a semaphore can be signalled by another thread.
Ans. C++ program memory is commonly divided into code, static data, heap and stack areas. Code stores instructions, static data stores globals and static variables, including zero-initialised data. The stack holds function calls and local automatic variables. The heap holds dynamically allocated objects. The key detail is lifetime: stack objects end automatically, heap objects must be managed.
Ans. Use a difference array to accumulate how much each character must be shifted, then scan the string once and apply the prefix sum to each character. For range updates, add the value at the start index and subtract it after the end index. This avoids updating every character per operation. Time complexity is O(n + q).
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. 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. Use two pointers: move slow one node at a time and fast two nodes at a time. When fast reaches the end, slow is at the middle. For an even length list, this usually returns the second middle node. This takes linear time and constant extra space.
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. Interprocess Communication is the set of methods that lets separate processes exchange data and coordinate their actions. It is needed because processes normally have isolated memory spaces. Common IPC mechanisms include pipes, message queues, shared memory, sockets and signals, often with synchronisation to avoid races and inconsistent data.
Ans. Function overloading means defining multiple functions with the same name but different parameter lists, while function overriding means a subclass provides its own implementation of a method already defined in its superclass. Overloading is resolved at compile time in many languages; overriding is resolved at run time using dynamic dispatch.
Ans. Use two pointers, one at the start and one at the end, and swap their elements while moving them towards the centre. This reverses the array in place, so no extra array or in-built function is needed. The time complexity is O(n) and the space complexity is O(1).
Ans. The TCP/IP stack is the set of layered protocols used to move data across networks, usually described as application, transport, internet, and link layers. Applications use protocols like HTTP, TCP provides reliable ordered delivery, IP handles addressing and routing, and the link layer sends frames on the local network. IP itself is best effort.
Ans. GCC translates source code into an executable through preprocessing, compilation, assembly and linking. It expands macros and headers, checks and optimises the code, converts it through internal representations into target assembly, assembles that into object files, then links those with libraries to produce the final binary.
Ans. Java collection classes are reusable data structures in the Java Collections Framework for storing and manipulating groups of objects. Common examples are ArrayList and LinkedList for ordered lists, HashSet and TreeSet for unique elements, PriorityQueue for queues, and HashMap for key value lookup. The key detail is choosing by ordering, uniqueness, and access performance.
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. 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. main() is not private because the Java launcher must be able to call it from outside the class as the program’s entry point. Therefore the standard signature is public static void main(String[] args). public makes it accessible, static lets it run without creating an object, and void means it returns no value.
Ans. Linux is a Unix-like operating system where the kernel manages hardware, processes, memory, filesystems and networking. Users interact mainly through a shell using commands such as ls, cd, pwd, cp, mv, rm, cat, grep, chmod, ps, top, kill and ssh. The key concept is that almost everything is represented as a file with permissions.
Ans. The diamond problem in C++ happens when a class inherits from two classes that both inherit from the same base class. The final derived class can contain two separate copies of the base, causing ambiguity when accessing base members. The usual fix is virtual inheritance, which shares one common base subobject.
Ans. The Diamond Problem is an ambiguity in multiple inheritance where a class inherits from two classes that both inherit from the same base class. The compiler may not know which inherited version of a method or state to use. Languages handle it differently, for example Java avoids it with interfaces, while C++ uses virtual inheritance.
Ans. The deadly diamond of death is the ambiguity that occurs in multiple inheritance when a class inherits from two classes that both inherit from the same base class. The derived class may contain two copies of the base or face ambiguous method and field resolution. Languages handle it with virtual inheritance, interfaces, or method resolution rules.
Ans. Ternary search finds a target in a sorted array by splitting the current search range into three parts using two midpoints. It compares the target with both midpoints, then continues only in the third that could contain it. Its time complexity is O(log n), but binary search is usually preferred because it uses fewer comparisons.
Ans. Normalization in DBMS is the process of organising data to reduce redundancy and avoid update, insert, and delete anomalies. It divides data into related tables and defines relationships using keys. Common forms include 1NF for atomic values, 2NF for full key dependency, and 3NF for removing transitive dependency.
Ans. Paging is a memory management technique where an operating system divides virtual memory into fixed-size pages and physical memory into matching frames. A page table maps each virtual page to a physical frame, allowing processes to use non-contiguous memory. If a needed page is not in RAM, a page fault occurs.
Ans. Atomicity in Firebase is achieved using transactions or batched writes, depending on the database and operation. A transaction reads data, applies an update, and commits only if the data has not changed meanwhile, otherwise it retries. Batched writes commit multiple write operations as one all-or-nothing unit.
Ans. Use merge sort by splitting the linked list into halves with slow and fast pointers, recursively sorting each half, then merging the two sorted lists by relinking nodes. The key detail is to cut the list at the middle before recursing. Time complexity is O(n log n), with O(log n) recursion stack space.
Ans. When you start a computer, firmware runs first, checks and initialises hardware, then finds a bootable device and loads the bootloader. The bootloader loads the operating system kernel into memory. The kernel then starts core system processes, device drivers and services, after which the machine is ready for user login or use.
Ans. HashMap stores key value pairs in an array of buckets, using the key’s hashCode to choose a bucket index. If keys collide, entries share the bucket, first as a linked list and, in Java 8+, as a balanced tree when large enough. Lookup then checks hash and equals. Average operations are O(1).
Ans. Process termination in C++ usually happens by returning from main or calling std::exit, which ends the program and returns a status code to the host environment. The key detail is cleanup: returning from main destroys local automatic objects normally, while std::exit skips stack unwinding but still runs registered exit handlers and static object destructors.
Ans. Locks are synchronisation mechanisms that control access to shared resources so that concurrent threads or processes do not corrupt data. Common types include mutex locks for exclusive access, read-write locks for many readers or one writer, spinlocks that busy-wait, semaphores with a counter, and reentrant locks that the same thread can acquire repeatedly.
Ans. Use a central scheduler with a queue of pending jobs and a registry of servers reporting capacity, health and supported job types. The key detail is making assignment atomic and retryable: reserve capacity before dispatch, mark the job leased, require heartbeats, and requeue it if the server fails or the lease expires.
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 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. Design test cases from the requirements, risks, and expected user behaviour. Cover normal flows, boundary values, invalid inputs, error handling, security, performance, and integration points. The most important detail is traceability: each important requirement should have clear positive and negative tests, with expected results defined before execution.
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 two pointers to find the middle, reverse the second half of the linked list, then compare it node by node with the first half. The key detail is restoring the reversed half afterwards if the list must remain unchanged. This uses constant extra space and takes O(n) time.
Ans. A page table maps a process’s virtual page numbers to physical frame numbers, plus bits such as valid, protection and dirty. Each process usually has its own page table. An inverted page table has one entry per physical frame, storing which process and virtual page occupy it, saving memory but making lookup more complex.
Ans. C++ has no “virtual class” keyword; it usually means a virtual base class, used in multiple inheritance to keep only one shared base subobject. Declare inheritance as virtual public Base. In a diamond hierarchy, both intermediate classes share the same Base instance. This is a language feature, not an algorithm, so time complexity is not applicable.
Ans. Use merge sort by splitting the list into halves, sorting each half recursively, then merging the two sorted lists by relinking nodes. The key detail is finding the middle with slow and fast pointers and cutting the list there. It runs in O(n log n) time with O(log n) recursion space.
Ans. free() tells the C memory allocator that a block previously obtained from malloc, calloc, or realloc is no longer in use. The allocator uses metadata stored near the block to find its size, marks it available, may coalesce neighbouring free blocks, and may later reuse it. Invalid or double free causes undefined behaviour.
Ans. Use an inner join to combine related tables, then use a subquery to filter rows based on an aggregate result. For example, return customers whose total order value is above the average order value by joining customers to orders and comparing each customer’s total with a subquery that calculates the overall average.
Ans. A vtable is a compiler-generated table of function pointers for a class with virtual functions, and a vptr is a hidden pointer in each polymorphic object that points to that table. During construction, the vptr is set to the current class’s vtable. A virtual call uses the vptr to find and call the correct overridden function.
Ans. Use Floyd’s slow and fast pointer method to detect the loop, then reset one pointer to the head and move both one step at a time; the node where they meet is the first node of the loop. This works in O(n) time and O(1) extra space.
Ans. Scan every cell and start a DFS or BFS whenever you find an unvisited land cell, counting that as one island. Mark all connected land cells as visited, usually by changing them in place or using a visited set. Connectivity is normally up, down, left and right. Time is O(rows × cols), space is O(rows × cols) worst case.
Ans. The critical section problem can be solved by enforcing mutual exclusion using synchronisation mechanisms such as mutex locks, semaphores, monitors, or atomic hardware instructions. The key requirement is that only one process or thread enters the critical section at a time, while also ensuring progress and bounded waiting to avoid deadlock or starvation.
Ans. A compiler resolves method overloading at compile time by matching the method name and argument list against available method signatures. It considers the number of arguments, their static types, allowed conversions or promotions, and then chooses the most specific applicable overload. The return type alone cannot distinguish overloads, and ambiguity causes a compile error.
Ans. Functions with variable length arguments can accept a different number of arguments each time they are called. The function gathers the extra arguments into a structure such as an array, tuple, or language-specific argument list. This is useful for operations like formatting strings, logging, or summing values where the exact count is not known in advance.
Ans. Process management is the operating system function that creates, schedules, runs, pauses, and terminates processes. It allocates CPU time, maintains process states, and handles context switching between processes. The key detail is that the scheduler decides which ready process runs next, enabling multitasking while protecting process isolation and system stability.
Ans. Use the two fastest people to manage returns. With times sorted as a, b, c, d, compare two plans: a + 3b + d, or 2a + b + c + d. Pick the smaller. For the classic 1, 2, 5, 10 case, that gives 17 minutes. Different values need the same comparison.
Ans. I would build a REPL that reads an expression, tokenises it, parses it respecting precedence and brackets, then evaluates it and prints the result. The key detail is separating parsing from evaluation, using an AST or two stacks via the shunting-yard algorithm. Each expression is processed in linear time.
Ans. Rewrite it as n = p^2 − q^2 = (p − q)(p + q). For integer solutions, count factor pairs a and b of n where a = p − q, b = p + q, and a and b have the same parity. Then p = (a + b)/2 and q = (b − a)/2.
Ans. Light one wire at both ends and the other at one end at the same time. The first wire burns out in 30 minutes, however unevenly it burns. At that moment, light the other end of the second wire. Its remaining part would have taken 30 minutes from one end, so it burns in 15 more minutes. Total is 45 minutes.
Ans. List all triples whose product is the given product, usually 36, then compare their sums. The only ambiguous sum is 13, from 1, 6, 6 and 2, 2, 9. The clue that there is an oldest daughter rules out 1, 6, 6. The ages are 2, 2 and 9.
Ans. Choose a real work situation with clear stakes, limited information, or conflicting priorities. Emphasise how you defined the problem, gathered facts, involved the right people, compared options, acted, and measured the result. Interviewers listen for structure, judgement, ownership, communication, and learning, not a perfect outcome or an overdramatic story.
Ans. Choose a real, low-drama conflict about priorities, communication, or ownership, not a personal feud. Emphasise how you listened, clarified facts, stayed respectful, and agreed a practical way forward. Interviewers listen for self-awareness, accountability, emotional control, and proof that the relationship and the work both improved afterwards.
Ans. Choose a real situation involving conflict, missed deadlines, unclear ownership, or low morale. Emphasise how you diagnosed the issue, involved the team, set expectations, supported individuals, and followed up. Interviewers listen for calm judgement, fairness, communication, accountability, and evidence that your approach improved both performance and trust.
Ans. I would define exceptions as typed runtime values and implement throwing by unwinding the call stack until a matching handler is found. Each stack frame would carry metadata for active try, catch and finally blocks. The key detail is guaranteeing cleanup during unwinding, so finally or defer actions always run before control reaches the handler.
Ans. 31 trailing zeros. A trailing zero comes from a factor pair 2 and 5, and factorials have more 2s than 5s, so count the 5s. For n!, add ⌊n/5⌋ + ⌊n/25⌋ + ⌊n/125⌋ and so on. For 125!: 25 + 5 + 1 = 31.
Ans. Identify the question type first, then write down the given data clearly. Convert words into equations, ratios, tables, or diagrams as needed. Use shortcuts only when they are reliable. For reasoning, look for patterns, conditions, and eliminations. Check the final answer against the question to avoid calculation or interpretation errors.
No question matches those filters. Reset filters.
Showing 60 of 348 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 (67%) and DSA (26%).
Candidate interviews show an average of 3.9 rounds per experience, with a typical sequence of Online test → Technical → Managerial → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 47%, medium 51%, hard 2%.
