119 questions from 24 interviews · updated from reports 2016-2025
About
Fidelity Investments is a financial services company that offers investment management, retirement planning, brokerage, and related services. In India, it is known for hiring software engineering interns, summer interns, apprentices, and entry-level technology roles in software development and support.
The roles that come up most are Software Engineering Intern, Summer Intern and Apprenticeship. This covers 24 candidate interviews reported from 2016 to 2025. Most sat it at internship level (18 of 24 that recorded a level). Among the 20 that recorded either route, arrivals split between campus drives (17, 85%) and off-campus applications (3, 15%). Most questions fall under DSA and CS fundamentals.
Ans. Multithreading runs multiple threads within one process, sharing the same memory space, while multiprocessing runs multiple separate processes, each with its own memory. Threads are lighter and useful for I/O-bound work, but shared state needs careful synchronisation. Processes have more overhead but give better isolation and can use multiple CPU cores more effectively.
Ans. Precompute up to the maximum R using the Sieve of Eratosthenes, then answer each query by returning numbers in [L, R] that are greater than 1 and not prime. Store primality in a boolean array, or store composites in a sorted list. Preprocessing is O(maxR log log maxR); each query is O(k plus log maxR).
Ans. Use three pointers, one for each sorted array, and advance them to find values that are equal in all three. If all current values match, record the value and move all pointers, skipping duplicates if unique results are needed. Otherwise, advance the pointer with the smallest value. Time is linear in total length, space is constant excluding output.
Ans. JavaScript is a runtime programming language, while TypeScript is a typed superset of JavaScript that compiles to JavaScript. TypeScript adds static types, interfaces, generics and better tooling, helping catch errors before execution. Browsers and Node.js run JavaScript, so TypeScript must be transpiled before it can run.
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. Search works like a normal BST. Insert and delete update heights and rebalance using rotations. Search, insertion, and deletion all take O(log n) time.
Ans. Use backtracking to build permutations by choosing each unused character in turn, recursing until the current string has the original length, then print it. Keep a character array, a boolean used array, and a temporary result buffer. The time complexity is O(n × n!) and the recursion depth is O(n).
Ans. Inheritance lets a class reuse and extend behaviour from another class, forming parent and child relationships. The Diamond Problem happens in multiple inheritance when a class inherits from two classes that both inherit from the same base, creating ambiguity about which base member is used. Languages handle it with virtual inheritance, interfaces, or method resolution rules.
Ans. Choose the data structure around the operations you need most, then explain the algorithm and its complexity clearly. For example, use a hash table for fast lookup, a heap for priority access, a stack for last-in first-out processing, or BFS and DFS for graph traversal. Always mention time and space complexity.
Ans. Floyd-Warshall computes all-pairs shortest paths by repeatedly allowing each vertex as an intermediate point. Initialise a distance matrix with edge weights, zero for the same vertex, and infinity where no edge exists. For each k, update dist[i][j] if dist[i][k] + dist[k][j] is smaller. Time is O(V³), space is O(V²).
Ans. Use a V by V distance matrix, initialise it with edge weights, 0 on the diagonal and infinity for missing edges, then for each intermediate vertex k update every pair i, j if dist[i][k] + dist[k][j] is smaller than dist[i][j]. The key detail is the k outer loop. Time is O(V³), space is O(V²).
Ans. Scan the prefix expression from right to left, using a stack of strings. Push operands onto the stack. When you see an operator, pop the first two strings, concatenate them as first operand, second operand, operator, then push the result back. The final stack value is postfix. Time complexity is O(n).
Ans. A friend function in C++ is a non-member function that is allowed to access private and protected members of a class. It is declared with the friend keyword inside the class. Binding is the association of a function call with its definition, either at compile time as static binding or at runtime as dynamic binding using virtual functions.
Ans. Use a sliding window to find the longest substring without repeating characters. Keep two pointers for the current window and a hash set or map of seen characters. Move the right pointer to expand, and move the left pointer when a duplicate appears. This runs in linear time with linear extra space.
Ans. Use expand around centres: for each index, expand once for an odd-length palindrome and once between indices for an even-length palindrome, tracking the best start and length. The key detail is handling both centre types. This uses only a few variables, runs in O(n squared) time, and uses O(1) extra space.
Ans. A hash map stores key value pairs by hashing the key to choose an array index. If two keys map to the same index, collisions are usually handled by chaining with a list or bucket, or by open addressing to find another slot. Good hashing and resizing keep lookup, insert and delete average O(1).
Ans. Use dynamic programming by defining a state, writing a recurrence, setting base cases, and filling a table so each subproblem is solved once. For example, in 0/1 knapsack, let dp[i][w] be the best value using first i items and capacity w. Use a 2D array, with O(nW) time and space.
Ans. Blockchain is a distributed, append-only ledger where transactions are grouped into blocks, cryptographically linked, and agreed by a network without a central authority. Its key value is tamper resistance and shared trust. Applications include cryptocurrencies, supply chain tracking, digital identity, smart contracts, audit logs, voting systems, and asset ownership records.
Ans. Convert every 0 to -1, then find the longest subarray with sum 0. Keep a running prefix sum and store the first index where each sum appeared in a hash map. If the same sum appears again, the subarray between those indices is balanced. This takes O(n) time and O(n) space.
Ans. Use BFS to find a path by starting at the source, visiting neighbours level by level with a queue, and storing each node’s parent to reconstruct the path when the target is found. Mark visited nodes to avoid cycles. BFS gives the shortest path in an unweighted graph, with time complexity O(V + E).
Ans. The Diamond Problem is an ambiguity that occurs when a class inherits the same method or state through two different parent paths. Java avoids it for classes by not allowing multiple class inheritance. With interfaces, if two default methods conflict, the implementing class must override the method and choose the behaviour explicitly.
Ans. An RDBMS is a relational database management system that stores data in tables with rows and columns, using keys and SQL to define, query and manage relationships. Common data mining algorithms include decision trees, k-means clustering, k-nearest neighbours, Naive Bayes, association rule mining such as Apriori, and neural networks.
Ans. I would first define the input, output and constraints, then describe the steps needed to transform the input into the output. I would choose the right data structure, explain the main loop or recursion, handle edge cases, and state the time and space complexity. I would keep the logic simple and unambiguous.
Ans. Use a recursive function that builds a partial solution, tries each valid choice, recurses, then undoes the choice before trying the next one. Stop when the partial solution is complete and record it. The key detail is pruning invalid choices early. Use a list or stack for state. Time is usually exponential.
Ans. Use a self-join by referencing the same table twice with different aliases and joining rows that have a relationship, such as employee.manager_id matching manager.id. Select the required columns from each alias. The key detail is to qualify every column with its alias so SQL knows which copy of the table you mean.
Ans. Sorting algorithms arrange data in order, with trade-offs in time, space, stability and whether they sort in place. Bubble, selection and insertion sort are O(n²), though insertion is good on nearly sorted data. Merge sort is O(n log n) with O(n) space. Quick sort averages O(n log n), worst O(n²). Heap sort is O(n log n) and O(1) space.
Ans. Use a V by V distance matrix, initialised with edge weights, 0 on the diagonal, and infinity where no edge exists. For each intermediate vertex k, update every pair i, j with dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]). It runs in O(V³) time and O(V²) space.
Ans. I would build a sharded in-memory cache cluster using consistent hashing, with replicas for availability and clients routing requests to the right node. Each entry would have a TTL, size limits, and LRU or LFU eviction. The most important detail is defining cache consistency clearly, especially invalidation on writes and behaviour during node failures.
Ans. Floyd Warshall finds shortest paths between every pair of vertices by repeatedly allowing each vertex to be an intermediate stop. Start with a distance matrix from edge weights, zero on the diagonal and infinity where no edge exists. For each intermediate k, update dist[i][j] if dist[i][k] plus dist[k][j] is smaller. It runs in O(n³) time.
Ans. Expand outwards from N by distance d, testing N - d and N + d for primality, and count primes found until the Kth is reached. Handle values below 2 as non-prime, and define a tie order, usually lower number first. Use trial division up to square root; time depends on gaps and primality checks.
Ans. Use Dijkstra’s algorithm to find the fastest route between two locations in a road network. Model junctions as nodes and roads as weighted edges, where weights are travel times. Use a min-priority queue to always expand the quickest known route next. With an adjacency list, the time complexity is O((V + E) log V).
Ans. Sort the array, then use two pointers from the start and end to track the pair whose sum has the smallest absolute difference from the target. If the sum is too small, move the left pointer right; if too large, move the right pointer left. This uses sorting and two pointers, taking O(n log n) time.
Ans. Compute an error-detecting value from the binary string before transmission, send it with the data, then recompute it at the receiver and compare. A parity bit is the simplest method, but it only detects an odd number of bit errors; a checksum or CRC is normally used for stronger detection.
Ans. Use a procedural block with cursors over both tables, store the parent table rows in a hash map keyed by primary key, then scan the child table and use its foreign key to find the matching parent row. This simulates a join procedurally. Time complexity is O(n + m), with O(n) extra memory.
Ans. Return the lexicographically largest digit string among all valid choices: no swap if the number is already even, the best one-swap improvement that leaves an even last digit, and swaps of the last digit with each even digit. If no even digit exists, no solution exists. Use rightmost digit positions; time is linear, space constant.
Ans. Convert 0 to -1 and find the longest subarray with sum 0 using prefix sums. Keep a hash map from each prefix sum to its earliest index. When the same sum appears again, the elements between those indices are balanced. This runs in O(n) time and O(n) space.
Ans. The largest triangle area is half the rectangle’s area, so return round(width × height / 2). Use three corners of the rectangle to form the triangle, giving base equal to one side and height equal to the other. If coordinates are given, compute width and height by absolute differences. Time complexity is O(1).
Ans. Count frequencies of all matrix values, then traverse the main and secondary diagonals and add only values whose total frequency in the matrix is greater than 3. Use a hash map for counts. For an n by n matrix, counting takes O(n²) time, diagonal traversal takes O(n), and space is O(k) for distinct values.
Ans. Object-oriented programming models software as objects with state and behaviour. Encapsulation hides data behind methods and access modifiers. Abstraction exposes essential operations through classes or interfaces. Inheritance lets a class reuse and extend another class. Polymorphism lets the same method call behave differently through overriding, interfaces, or virtual methods.
Ans. Greedy makes the best local choice at each step, while dynamic programming solves overlapping subproblems and stores results. Quick Sort partitions around a pivot, average O(n log n), worst O(n²), fast in-place. Merge Sort divides and merges, always O(n log n), needs extra space. Use Quick Sort for arrays, Merge Sort for stability or linked lists.
Ans. Select the employee row where emp_name is “Akash” and that employee’s emp_id does not appear as any other row’s manager_id. The safest approach is to use a NOT EXISTS check against the same employee table, because manager_id may contain NULL values and NOT IN can then give incorrect results.
Ans. Separate the array into two lists, one for even numbers and one for odd numbers, sort both lists in ascending order, then print the even list followed by the odd list. The main detail is preserving the required ordering within each group. This takes O(N log N) time and O(N) extra space.
Ans. Machine Learning is the broader field where models learn patterns from data, while Deep Learning uses multi-layer neural networks to learn features automatically. Activation functions add non-linearity so networks can model complex relationships. Vanishing gradients occur when gradients become too small in early layers. Leaky ReLU reduces this by allowing a small negative slope.
Ans. Normalization organises relational data to reduce duplication and update anomalies. Triggers are automatic actions fired by database events, while cursors process query results row by row. RDBMS uses structured tables and SQL; NoSQL uses flexible models. Joins combine tables, commonly inner, left, right and full. A primary key uniquely identifies rows; a composite key uses multiple columns. Indexing speeds reads but slows writes.
Ans. Use binary search on the answer between the largest element and the total sum. For each candidate maximum sum, greedily scan the array and start a new subarray whenever adding the next element would exceed it. If more than K subarrays are needed, increase the limit; otherwise decrease it. Time complexity is O(n log sum).
Ans. Find the second largest by scanning once while tracking the largest and second largest values, updating them as each element is read. This takes O(n) time and O(1) space. For the kth largest element, use quickselect for average O(n) time, or a min heap of size k for O(n log k) time.
Ans. Count characters in the first string, then output characters following the order given by the second string, using their counts. While scanning the first string, keep characters not present in the second string in a separate list so their relative order is preserved. Use a hash map and set. Time complexity is O(n + m).
Ans. Pad the matrix with 1s until rows and columns are both n, where n is the larger original dimension, then sum each main diagonal value only if its frequency in all non-diagonal cells is odd. Use a hash map to count non-diagonal values after padding, then scan the diagonal. Time is O(n²), space is O(n²) or O(k).
Ans. You need to pick 21 socks. In the worst case, you could first pick one sock from each of the 20 colours, giving no matching pair. The next sock must be one of those same 20 colours, so it must match a sock already picked. By the pigeonhole principle, the guarantee is 21.
Ans. Use a greedy scan: keep a running surplus of drink energy minus distance cost, and start at village 0. Whenever the surplus becomes negative, no village in that failed segment can be the answer, so set the next village as the start and reset surplus. If total surplus is non-negative, return that start index; otherwise none exists.
Ans. The answer is the number of subtraction steps needed to make the two counts equal or make one zero. This is the subtraction form of the Euclidean algorithm. Instead of subtracting one by one, add larger divided by smaller to the count, replace larger by larger mod smaller, and continue. Time complexity is logarithmic.
Ans. Fix two column boundaries, compress the rows between them into a one dimensional array of row sums, then run Kadane’s algorithm on that array to find the best vertical span. Repeat for all column pairs and keep the maximum. Use an auxiliary sums array. Time complexity is O(cols squared times rows), or transpose to minimise it.
Ans. Use two pointers from both ends, tracking the maximum height seen on the left and right. Move the side with the smaller current height, because its trapped water is limited by that side’s maximum. Add max minus current height when positive. This uses constant extra space and runs in O(n) time.
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. C is mainly a procedural systems programming language, while C++ extends C with object oriented and generic programming features. The key practical difference is that C++ provides classes, constructors, destructors, templates and a richer standard library, enabling abstractions such as RAII and containers while still supporting low level memory control.
Ans. Choose a real example where you had clear responsibility for people, delivery, or coordination. Emphasise the goal, your role, how you organised the work, handled issues, and measured success. Interviewers listen for ownership, communication, planning, judgement under pressure, and whether you helped others perform rather than simply doing everything yourself.
Ans. Choose a situation that shows you can adapt between collaboration and ownership. Emphasise clear communication, reliability, sharing knowledge, and asking for help early when needed. For individual work, show self-management and accountability. Interviewers listen for maturity, flexibility, low ego, and evidence that you help the team succeed rather than just completing your own tasks.
Ans. Solve the inequality first: 3i + 1 > N gives i > (N - 1) / 3. For integer i in the exclusive range (1, N), count values from floor((N - 1) / 3) + 1 up to N - 1, also ensuring i > 1. Thus use the valid lower bound and count inclusively.
Ans. The nth element is found by first taking the common difference as third element minus second element. If the 2nd term is x and the 3rd term is y, then d = y - x. The nth term is x + (n - 2)d, so Tn = x + (n - 2)(y - x).
Ans. Read the instruction first, then identify what skill is being tested, such as grammar, vocabulary, sentence order, inference or error spotting. Eliminate clearly wrong options using meaning, tone and grammar rules. For passages, read the question before the text and answer only from the given information, not outside knowledge.
Ans. Pick a simple concept, such as the internet, passwords, or saving a file. Use a real situation where you adapted your language for a non-technical person. Emphasise analogies, patience, checking understanding, and avoiding jargon. Interviewers listen for clarity, empathy, structure, and evidence that you can make complex ideas useful.
No question matches those filters. Reset filters.
Showing 60 of 119 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 DSA (43%) and CS fundamentals (43%).
Candidate interviews show an average of 3.1 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 50%, medium 46%, hard 4%.
