255 questions from 23 interviews · updated from reports 2014-2024
About
Informatica is a software company that provides data integration, data management, cloud data, and data governance products for businesses. In India, it hires technical roles such as Software Engineer, Associate Software Developer in R&D, and Global Customer Support.
The roles that come up most are Software Engineer, Associate Software Developer (R&D) and Global Customer Support. This covers 23 candidate interviews reported from 2014 to 2024. Most sat it at entry level (17 of 22 that recorded a level), with 5 internship interviews alongside. Among the 18 that recorded either route, arrivals split between campus drives (17, 94%) and off-campus applications (1, 6%). Most questions fall under CS fundamentals and DSA.
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. Decode it by scanning left to right and building the final output directly. Use a stack for repeat counts and a stack for the output length before each opening bracket. When a closing bracket appears, repeat only the suffix just produced. This avoids separate temporary decoded strings. Time is O(final output length), space is O(n).
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 a stack to check balanced parentheses by pushing each opening bracket and matching each closing bracket with the top of the stack. If the stack is empty when closing, or the types do not match, it is invalid. At the end, it is balanced only if the stack is empty. Time is O(n), space is O(n).
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. The maximum non-contiguous sum is the sum of all positive numbers in the array. If every number is negative or zero, return the largest element, depending on whether an empty subset is allowed. Scan once, accumulate positives, track the maximum element, and return the appropriate value. Time complexity is O(n), space is O(1).
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 two pointers, one at the start and one at the end, and compare characters while moving inward. For a number, either convert it to a string or reverse its digits and compare with the original. The string approach uses constant extra data and runs in O(n) time.
Ans. Number the bags 1 to 10. Take 1 coin from bag 1, 2 from bag 2, and so on, then weigh all 55 coins together. If all were genuine, you know the expected weight. The shortfall, divided by the per-coin weight difference, gives the bag number containing the false coins.
Ans. Rotations in an AVL tree are local restructuring operations used to restore balance when a node’s height difference becomes more than one. A right rotation fixes a left-left case, a left rotation fixes a right-right case, and left-right or right-left cases need two rotations. They preserve binary search tree order and require height updates.
Ans. C++ does not have built-in garbage collection in the usual sense; memory is managed through object lifetimes, destructors, and explicit allocation and deallocation. The preferred approach is RAII, using stack objects and smart pointers such as unique_ptr and shared_ptr, so resources are released deterministically when ownership ends.
Ans. Flatten it by doing a depth first traversal, splicing each child list between the current node and its next node, then continuing from the child before returning to the saved next node. Use recursion or an explicit stack to remember next pointers. It visits each node once, so time is linear and space is proportional to depth.
Ans. CPU scheduling algorithms decide which ready process gets the CPU next. Common algorithms include First Come First Served, Shortest Job First, Round Robin, Priority Scheduling and Multilevel Queue. The key trade-off is between throughput, response time, waiting time and fairness, with pre-emptive algorithms allowing the OS to interrupt a running process.
Ans. A subnet mask defines which part of an IP address is the network portion and which part identifies the host. In IPv4 it is often written like 255.255.255.0 or as a prefix such as /24. Devices use it with the IP address to decide whether a destination is local or must go through a router.
Ans. An AVL tree is a self-balancing binary search tree where, for every node, the heights of the left and right subtrees differ by at most one. This balance factor keeps the tree height logarithmic. After insertions or deletions, rotations restore balance, so search, insert and delete all take O(log n) time.
Ans. Use a bounded blocking queue protected by a mutex, with two condition variables or semaphores for not full and not empty. Producers wait when the buffer is full, lock, enqueue an item, unlock, and signal consumers. Consumers wait when empty, lock, dequeue, unlock, and signal producers. Each produce or consume operation is O(1).
Ans. DNA pattern matching finds occurrences of a nucleotide sequence within larger DNA strings using exact or approximate string matching. For one pattern, KMP gives linear time. For many patterns, tries or Aho-Corasick work well. For large genomes, suffix arrays, suffix trees or FM-indexes allow fast searches after preprocessing, often supporting mismatches too.
Ans. Use level order traversal with a horizontal distance for each node, and keep the latest node seen at each distance. Start root at distance 0, left child at -1, right child at +1. A queue stores nodes with distances. After traversal, print map values from smallest to largest distance. Time is O(n log n).
Ans. Use level order traversal with alternating direction at each level to print the tree in spiral order. Maintain two stacks: push children into the next stack in left to right order on one level, then right to left on the next. Swap stacks after each level. Time complexity is O(n), space is O(w).
Ans. Check it by recursively verifying that every node lies within an allowed value range. The root starts with no bounds, the left child gets an upper bound of the node value, and the right child gets a lower bound. Use strict inequalities for a normal BST. Time is O(n), space is O(h).
Ans. Print the top view by doing a level order traversal while tracking each node’s horizontal distance from the root. Use a queue storing node and distance, and a map from distance to the first value seen. Insert only if the distance is absent. Finally print map values in increasing distance order. Time complexity is O(n log n).
Ans. Print the right view by traversing the tree level by level and printing the last node seen at each level. Use a queue for breadth first search, process one level at a time, and record the final node in that level. The BST ordering is not important. Time is O(n), space is O(w).
Ans. Add them the same way as manual addition, from right to left, keeping a carry. Use two indices for the strings and append each result digit to a character list or string builder, then reverse it at the end. This avoids integer overflow. The time complexity is O(max(n, m)) and space is O(max(n, m)).
Ans. OOP organises software around objects that combine data and behaviour. A class is a blueprint, and an object is an instance, such as a Car class and myCar object. Encapsulation hides internal state, inheritance reuses behaviour, polymorphism lets different objects share an interface, and abstraction exposes only essential details, like a payment interface.
Ans. Compute a 1-based rank by scanning left to right and counting how many valid permutations would start with a smaller available character at each position, then add one. Use character frequency counts and factorials, dividing by duplicate factorials when characters repeat. This takes O(n alphabet) time with fixed alphabet.
Ans. Use BFS from the start cell, because in an unweighted matrix it explores cells in increasing distance order and the first time you reach the target is the shortest path. Store cells in a queue with their distance, mark visited when enqueuing, check valid neighbours, and run in O(rows × columns) time.
Ans. Quick Sort partitions around a pivot, while Merge Sort splits the array and merges sorted halves. For [4, 2, 7, 1], Quick Sort with pivot 4 gives [2,1], 4, [7], then [1,2,4,7]. Merge Sort splits to [4,2] and [7,1], sorts to [2,4] and [1,7], then merges. Average time is O(n log n).
Ans. A correlated subquery is a nested query that refers to columns from the outer query, so it is evaluated for each outer row. To solve one, identify the outer reference, run the inner condition per candidate row, and return rows where it matches. For performance, often rewrite it as a join or window function.
Ans. Sorting algorithms can be comparison based, like bubble sort, insertion sort, selection sort, merge sort, quicksort and heap sort, or non-comparison based, like counting sort, radix sort and bucket sort. The key difference is that comparison sorts usually have a lower bound of O(n log n), while non-comparison sorts can be linear for suitable data.
Ans. Memory allocation is how the operating system assigns memory to processes and takes it back when they finish. The kernel tracks free and used memory, gives each process a virtual address space, and maps it to physical RAM using paging. This improves isolation, simplifies allocation, and lets inactive pages move to disk when RAM is limited.
Ans. CAP theorem says a distributed system cannot simultaneously guarantee consistency, availability, and partition tolerance during a network partition. Consistency means all nodes see the same data, availability means every request gets a response, and partition tolerance means the system continues despite network splits. Since partitions are unavoidable, systems usually choose between consistency and availability.
Ans. Implement Stack<T> as a generic class backed by an ArrayList<T>, with push adding to the end, pop removing the last element, and peek returning the last element without removal. Check for underflow on pop and peek. Push, pop, peek, and isEmpty are O(1) amortised time.
Ans. Rotate an n by n matrix 90 degrees clockwise in-place by first transposing it, then reversing each row. Transpose swaps matrix[i][j] with matrix[j][i] for the upper triangle only. Reversing each row completes the rotation. This uses constant extra space and takes O(n²) time.
Ans. Implement a Trie as a tree where each node stores child links, usually in a map or array, and a boolean marking the end of a word. To insert or search, walk character by character, creating nodes for insert when missing. Insert, search, delete, and prefix lookup take O(L) time, where L is string length. Space is O(total characters stored).
Ans. Java 8 added functional programming features to Java 7, most importantly lambda expressions and the Stream API. Java 7 focused on smaller language and JVM improvements such as try-with-resources, diamond syntax, multi-catch and NIO.2. Java 8 also introduced default interface methods, Optional, and the new date and time API.
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. Select the distinct salary values, sort them in descending order, skip the first two, and return the next one. The key detail is using distinct salaries, so duplicate top salaries do not change the ranking. Most databases do this with ordering plus offset, or with a dense rank window function. Sorting dominates the cost.
Ans. Use dynamic programming where each cell stores the side length of the largest all-1s square ending at that cell. If matrix[i][j] is 1, its value is 1 plus the minimum of top, left, and top-left values; otherwise it is 0. Track the maximum value. Time is O(nm), space can be O(m).
Ans. There is no single answer without the four specific numbers. The method is to try all pairings and operator orders, because brackets matter: combine two numbers, combine the result with a third, then with the fourth, checking whether any expression equals 31. If you provide the numbers, I can derive the exact expression.
Ans. Use two pointers, one starting at each list head, and move both one step at a time. When a pointer reaches the end, redirect it to the other list’s head. They will meet at the first shared node, or both become null if there is no intersection. This is O(m+n) time and O(1) space.
Ans. I would optimise it by first finding the bottleneck, then reducing unnecessary repeated work using a better data structure or algorithm. For example, if the solution uses nested loops for lookups, I would replace them with a hash set or hash map, reducing time from quadratic to linear while keeping space linear.
Ans. Advanced OS concepts include process and thread scheduling, virtual memory, paging, synchronisation, deadlocks, file systems, permissions, IPC, system calls, and I/O management. In Linux, I use commands like ps, top, kill, grep, find, chmod, chown, df, du, journalctl, systemctl, and strace to inspect, manage, debug, and secure running systems.
Ans. Java HashMap is implemented as an array of buckets, where each bucket stores key-value entries based on the key’s hash code. The hash is spread and mapped to an index in the array. Collisions are handled by linked lists, or red-black trees when a bucket grows large. It resizes when the load factor threshold is exceeded.
Ans. Use a modified Kadane’s algorithm to track the largest and second largest contiguous subarray sums. For each element, keep the best two sums ending at that index, formed either by starting new or extending previous sums. Update the global best two values. This uses constant space and runs in O(n).
Ans. Model each lift with current floor, direction, state, target stops and door state, controlled by a central dispatcher. Hall calls are assigned to the lift that can serve them with the lowest estimated wait, favouring same direction, then nearest idle lift. Each lift maintains ordered stops and moves one floor at a time, updating state after arrivals.
Ans. Scan the matrix and count each unvisited 1 as a new island, then flood fill all connected 1s from it. Use DFS or BFS with a stack or queue, marking cells visited or changing them to 0. Check four neighbours unless diagonals are specified. Time is O(rows × columns), space is O(rows × columns) worst case.
Ans. Implement it as a RAII dynamic array holding a pointer, size and capacity, with constructors, destructor, copy and move operations, operator[], at(), push_back, pop_back and reserve. The key detail is exception safety: allocate new storage first, copy or move elements, then commit, using copy-and-swap. Index errors throw out_of_range. Access is O(1), push_back amortised O(1).
Ans. Use binary search: check mid, if a[mid] equals mid return it, if a[mid] is greater than mid search left, otherwise search right. This works in O(log n) time for sorted arrays with distinct integers and O(1) extra space. With duplicates, search both sides using bounded ranges.
Ans. Search the BST once, keeping the best floor and ceil seen so far. If the current value equals the key, both floor and ceil are that value. If current value is greater, update ceil and move left. If smaller, update floor and move right. This takes O(h) time and O(1) space.
Ans. Use Floyd’s cycle detection with two pointers, slow and fast, starting at the head. Move slow by one node and fast by two nodes each step. If they ever meet, a loop exists. If fast or fast.next becomes null, there is no loop. It uses O(1) extra space and O(n) time.
Ans. Use a monotonic decreasing stack to find the next greater element for each array value in O(n) time. Traverse from right to left, popping values less than or equal to the current element. The stack top is then the next greater element, or -1 if the stack is empty. Push the current element afterwards.
Ans. Improve it by keeping the BST balanced, usually by using a self-balancing tree such as an AVL tree or a Red-Black tree. These trees perform rotations during insertions and deletions so the height stays O(log n), making search, insert, and delete O(log n) in the worst case instead of O(n).
Ans. Use depth-first search with backtracking, carrying the current path and remaining sum from the root to each node. When a leaf is reached, if the remaining sum equals the leaf value, copy the path into the result. The key detail is to remove the node after returning. Time is O(n), excluding path-copy cost.
Ans. The maximum non-contiguous subarray sum is the sum of all positive elements, because including any positive number increases the total and including any negative number reduces it. If the array has no positive elements, the answer is the largest element. Scan once, track positive sum and maximum element, using O(n) time and O(1) space.
Ans. Traverse the BST recursively and remove every node whose value is greater than K. If a node’s value is greater than K, discard that node and its entire right subtree, then return the pruned left subtree. Otherwise, keep the node and prune its right child. Use recursion stack. Time is O(n), space is O(h).
Ans. The Singleton pattern ensures a class has exactly one instance and provides a global access point to it. It is usually implemented by making the constructor private, storing a static instance inside the class, and exposing a static method or property to return it. In multithreaded code, creation must be thread safe.
Ans. The necessary conditions for a deadlock are mutual exclusion, hold and wait, no preemption, and circular wait. A resource must be non-shareable, processes must hold resources while waiting for others, resources cannot be forcibly taken, and a cycle of processes must each wait for the next. All four must hold simultaneously.
Ans. Informatica Developer Tool is a client that lets developers design mappings, validate metadata, and deploy objects to Informatica services for execution. Internally, it stores design-time objects in the Model Repository, resolves connections and schemas through metadata services, compiles mappings into executable plans, and runs them through the Data Integration Service with logging, monitoring, and error handling.
Ans. Twitter computes trending tweets with a real time stream pipeline that counts recent engagements per tweet, per region and topic, then ranks by velocity rather than total volume. Events enter Kafka, are aggregated in sliding windows with decay, filtered for spam and duplicates, and the top K results are stored in Redis for fast reads.
Ans. Pick a recent team situation with a clear shared goal, tight deadline, or dependency between people. Emphasise how you clarified priorities, communicated progress, supported others, avoided duplication, and adapted when plans changed. Interviewers listen for reliability, collaboration, ownership, respect for others’ time, and evidence that your efficiency improved the team’s outcome.
No question matches those filters. Reset filters.
Showing 60 of 255 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 (48%) and DSA (45%).
Candidate interviews show an average of 5.4 rounds per experience, with a typical sequence of Online test → Technical → Technical → Technical → Technical → HR. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 45%, medium 49%, hard 6%.
