297 questions from 32 interviews · updated from reports 2014-2024
About
Intuit is a software company that makes financial and business tools, including TurboTax, QuickBooks, Credit Karma, and Mailchimp. In India, it is known for hiring software engineers and software engineering interns for product development, data, and platform teams.
The roles that come up most are Software Engineer, Software Engineering Intern and Software Engineer Intern. This covers 32 candidate interviews reported from 2014 to 2024. Most sat it at internship level (17 of 31 that recorded a level). Among the 21 that recorded either route, arrivals split between campus drives (14, 67%) and off-campus applications (7, 33%). Most questions fall under CS fundamentals and DSA.
Ans. Use a hash map plus a doubly linked list. The map gives O(1) access to cache nodes by key, and the list keeps usage order, with most recent at the front and least recent at the back. On get or put, move the node to the front. When capacity is exceeded, remove the back node.
Ans. Use two pointers: for each node current, scan the rest of the list with a runner pointer and delete any later node with the same value. Then move current forward and repeat. This uses no temporary buffer and keeps only pointer variables, so space is O(1), but time is O(n²).
Ans. Use depth first search to compute the maximum root-to-leaf sum, carrying the current path and sum as you go. When you reach a leaf, compare its sum with the best seen so far and store that path if larger. Use recursion or an explicit stack. Time is O(n), space is O(h) plus the stored path.
Ans. Use binary search on the smaller array to find a partition where the left halves of both arrays contain half the total elements and every left value is less than or equal to every right value. The median is then the max of left values, or the average of max left and min right. Time is O(log min(m,n))).
Ans. Use dynamic programming over expression intervals, storing for each substring the number of ways it can evaluate to true and false. For every operator position, combine left and right true/false counts according to &, |, or ^. Fill by increasing length. This takes O(n³) time and O(n²) space.
Ans. A student can achieve academic excellence through a closed-loop system of clear goals, planned study, active learning, regular testing, feedback, and adjustment. The key detail is measurement: track syllabus coverage, practice scores, error patterns, deadlines, sleep, and attendance weekly, then use that data to prioritise weak areas before they become long-term gaps.
Ans. Build a service that maps a short code to a long URL, with APIs to create, redirect, and optionally expire links. Store mappings in a durable key value store, generate unique codes using base62 over an ID or random token, cache hot redirects, and use 301 or 302 depending on analytics needs.
Ans. The Banker’s Algorithm is a deadlock avoidance method that grants a resource request only if the system remains in a safe state afterwards. It tracks available resources, current allocations, and each process’s maximum need. If some ordering lets all processes finish, the request is safe; otherwise it is delayed.
Ans. Build a service with route search, trip inventory, seat map, booking, payment and notification APIs backed by relational storage. The key detail is preventing double booking: keep seats per trip in a transactional table, hold a seat with an expiry, confirm only after payment, and enforce a unique constraint on trip and seat.
Ans. Use a FIFO queue protected by a mutex, with condition variables for “not empty” and, if bounded, “not full”. Enqueue locks, waits while full, pushes, then signals not empty. Dequeue locks, waits while empty, pops, then signals not full. Use while loops for spurious wakeups. Each operation is O(1).
Ans. A hash table stores key value pairs by using a hash function to turn each key into an array index. The value is placed in the bucket at that index. The key detail is collision handling, because different keys can hash to the same bucket. Common approaches are chaining with lists or open addressing. Average lookup, insert and delete are constant time.
Ans. Delete by searching for the key, then handle three cases: leaf, one child, or two children. A leaf is removed directly, and a node with one child is replaced by that child. For two children, replace its value with the inorder successor or predecessor, then delete that replacement node. Time is O(h), space O(h) recursively.
Ans. Design it as a modular web system with services for admissions, students, courses, enrolment, timetable, attendance, exams, fees and staff. Use a central relational database with strong constraints around student, course and enrolment records, because correctness matters more than scale. Add role-based access, audit logs, reporting and integrations with email, payments and identity.
Ans. AtomicInteger is a Java class that provides thread-safe operations on an integer without using explicit locks. It uses atomic compare-and-swap operations and volatile-style visibility. Common use cases include shared counters, sequence number generation, retry counts, metrics, and state flags where multiple threads update the same value safely.
Ans. Elasticsearch is a distributed search and analytics engine built on Apache Lucene, used to store, index and query large volumes of data quickly. Its key strength is near real-time full-text search with relevance ranking. Common use cases include website search, log analysis, monitoring, security analytics, autocomplete and filtering large document datasets.
Ans. Use two heaps: a max heap for the lower half of numbers and a min heap for the upper half. Keep their sizes equal, or let one heap have one extra element. Insert in O(log n), rebalance after each insert, and get the median in O(1) from the heap tops.
Ans. Scan every cell and start a DFS or BFS whenever you find unvisited land; each such start counts one island. During the search, mark all connected land cells as visited, usually using four directions: up, down, left and right. The grid is processed once, so time is O(rows × columns).
Ans. A strong answer should show structured thinking: core search flow first, then UI, accessibility, performance, localisation, browser and device coverage, and negative cases. Emphasise risk based prioritisation because the page looks simple but has huge scale. Interviewers listen for clarity, sensible trade-offs, and awareness of reliability, speed, and user experience.
Ans. Google search works by crawling pages, building a huge inverted index, then matching a user query against that index and ranking the results. The key detail is that Google does not scan the web at query time; it searches precomputed indexes, then orders results using relevance, links, freshness, location, quality and personalisation signals.
Ans. MVC separates an application into Model, View and Controller. The Model holds data and business rules, the View displays data to the user, and the Controller handles input and updates the Model or View. For example, in a shopping app, products are the Model, the product page is the View, and request handling is the Controller.
Ans. Scan from the right to find the first index i where a[i] < a[i+1], then swap it with the smallest larger element to its right and reverse the suffix. Use the array in place with no extra data structure. If no such i exists, reverse the whole array. Time is O(n), space is O(1).
Ans. MapReduce in Hadoop is a programming model that processes large data sets by splitting work into map tasks and reduce tasks across a cluster. For example, in word count, each mapper emits each word with 1, and reducers group the same words and sum the counts. Hadoop handles distribution, fault tolerance and data locality.
Ans. Use a modified binary search: compare the middle element with the ends to decide which half is sorted, then check whether the target lies inside that sorted half. If it does, search there, otherwise search the other half. For distinct elements, this takes O(log n) time and O(1) space.
Ans. Use a SELECT statement with the required columns, the source table, and a WHERE clause expressing the given conditions. Add JOIN clauses if data comes from multiple tables, GROUP BY and HAVING for aggregate filters, and ORDER BY if sorting is required. Performance mainly depends on indexes and filtered row count.
Ans. Use two threads sharing a counter, with one thread responsible for odd numbers and the other for even numbers. Protect the counter with a lock and use a condition or wait and notify so each thread sleeps until it is its turn. Increment after printing. Time complexity is linear in the number of values printed.
Ans. Joins combine rows from two tables based on a related column or condition, producing results such as matching rows, unmatched rows, or all combinations. Common types are inner, left, right, full outer, cross, and self join. DBMS implementations mainly use nested loop join, hash join, and sort-merge join, chosen by indexes, table size, and cost estimates.
Ans. REST is an architectural style for designing web APIs around resources, identified by URLs, manipulated using standard HTTP methods such as GET, POST, PUT, PATCH and DELETE. Its key principles are stateless requests, client-server separation, a uniform interface, resource representations like JSON, meaningful HTTP status codes, and optional caching for scalability.
Ans. Sort the array, then fix each element and use two pointers on the remaining range to find pairs that make the sum zero. Skip duplicate fixed values and duplicate pointer values to avoid repeated triplets. This uses no extra data structure apart from the output and runs in O(n squared) time.
Ans. Java Garbage Collection is a generational, tracing memory management system that automatically finds and frees unreachable objects. The heap is usually split into young and old generations because most objects die young. Collectors trace from GC roots, copy or compact live objects, and reclaim the rest, balancing throughput, latency, and pause times.
Ans. Use backtracking to build each valid string by adding an opening bracket while open count is less than n, and a closing bracket while close count is less than open count. Store the current path in a mutable string or list and add it to results at length 2n. Time is O(Cn · n), where Cn is the nth Catalan number.
Ans. Normal forms are rules for reducing redundancy and update anomalies in relational tables: 1NF ensures atomic values, 2NF removes partial dependency, 3NF removes transitive dependency, and BCNF strengthens determinant rules. Codd’s 12 rules define what a true relational DBMS should support, including tables, keys, nulls, relational operations, integrity, views, and data independence.
Ans. Threading is the OS concept of running multiple threads of execution within a single process. Threads share the process memory and resources, but each has its own program counter, registers and stack. The key benefit is concurrency with lower overhead than separate processes, though shared data needs synchronisation to avoid race conditions.
Ans. Scan the file once, count each element in a hash map, then keep a min heap of size k ordered by frequency to retain the top k elements. For each distinct element, push it into the heap or replace the minimum. Time is O(n + m log k), space is O(m + k), where m is distinct elements.
Ans. AtomicInteger stores an int in a volatile field and updates it using hardware compare-and-swap operations. Methods like incrementAndGet read the current value, compute the new value, then atomically replace it only if unchanged. If another thread changed it, the operation retries, giving lock-free thread-safe updates with volatile visibility guarantees.
Ans. Use a patience sorting approach: maintain an array tails, where tails[i] is the smallest possible tail value of an increasing subsequence of length i + 1. For each number, binary search its position in tails and replace or append it. The length of tails is the LIS length. Time complexity is O(n log n).
Ans. Use a hash map where the key is a canonical form of each string and the value is the list of words matching that key. For each word, sort its characters to form the key, then append the word to that group. Time complexity is O(n k log k), where k is word length.
Ans. A Java HashMap stores entries in an array of buckets, using the key’s hashCode to choose a bucket index. If multiple keys land in the same bucket, it compares keys with equals and stores them in a linked list or, after many collisions, a balanced tree. It resizes when the load factor is exceeded.
Ans. Use a min heap of size k, where the heap root is always the kth largest element seen so far. Add numbers until the heap has k elements, then only insert a new number if it is larger than the root, removing the root first. Each update is O(log k), with O(k) space.
Ans. Use an auxiliary stack as sorted storage, inserting each popped element from the original stack into its correct position. Pop current, move elements from the auxiliary stack back while they are greater than current, then push current, and restore moved elements. This is insertion sort on stacks, using O(n) space and O(n²) time.
Ans. Secondary sort in MapReduce sorts values within each primary key by making a composite key such as pair of primary key and secondary field. Use a custom partitioner on the primary key, a sort comparator on both fields, and a grouping comparator on only the primary key. Sorting cost is dominated by shuffle sort, about O(n log n).
Ans. Topological sorting orders the vertices of a directed acyclic graph so every edge u to v places u before v. Implement it with Kahn’s algorithm: store adjacency lists and an indegree array, push all zero-indegree vertices into a queue, remove them, and reduce neighbours’ indegrees. If not all vertices are output, a cycle exists. Time is O(V + E).
Ans. Use the same idea as binary addition: add matching bits plus a carry, create a result node with sum mod 2, and carry sum divided by 2. If lists store most significant bit first, reverse them first or use stacks. Process until both lists and carry are exhausted. Time is O(n + m).
Ans. I use a distributed cache such as Redis or Memcached with a cache-aside pattern, clear key design, TTLs, and consistent hashing or clustering for scale. The most important detail is invalidation: update or delete cached entries when the source of truth changes, and use short TTLs to limit stale reads if events are missed.
Ans. A DBMS manages structured data, transactions, concurrency, recovery, security and query processing. Indexing speeds reads by storing searchable keys, commonly in B-trees or hash indexes, but costs extra storage and slower writes. The CAP theorem says a distributed database cannot fully guarantee consistency, availability and partition tolerance together during a network partition.
Ans. Use a running prefix sum and a hash map of prefix sum frequencies. For each element, update the prefix sum, then add the number of times prefix sum minus K has been seen, because those starts form subarrays ending here. Store the current prefix sum. Initialise sum 0 with frequency 1. Time is O(n), space is O(n).
Ans. Convert it by keeping the tree shape unchanged, collecting all node values using inorder traversal, sorting those values, then doing another inorder traversal to write them back. The key detail is that inorder traversal of a BST must be sorted. This takes O(n log n) time and O(n) extra space.
Ans. Reduce k modulo 4, because four right rotations return the matrix to its original state. For each 90 degree clockwise rotation, transpose the matrix and then reverse each row if it is square. For a rectangular matrix, build a new matrix with changed dimensions. Time is O(mn), space is O(1) for square in-place.
Ans. Use an array to implement the heap, with children of index i at 2i+1 and 2i+2, and the parent at (i-1)/2. Heapify compares a node with its children and swaps with the smaller or larger child until the heap property holds. Heapify takes O(log n), and building a heap takes O(n).
Ans. I choose the database by matching the application’s access patterns, consistency needs, scale, data model, and operational constraints. The most important detail is how the data will be queried and updated. Relational databases suit structured data and transactions, document stores suit flexible records, and specialised stores suit search, analytics, caching, or graph use cases.
Ans. The browser turns the URL into a network request, finds the server, fetches the resource, and renders the response. It checks cache, resolves the domain with DNS, opens a TCP connection and usually TLS, sends an HTTP request, receives HTML, CSS and JavaScript, builds the DOM and render tree, then paints the page.
Ans. Visibility is whether one thread is guaranteed to see another thread’s latest writes, while synchronization is how threads coordinate access to shared state safely. Visibility problems come from caching and reordering. Synchronization, such as locking, gives mutual exclusion and memory ordering. Volatile improves visibility, but does not make compound operations atomic.
Ans. Multiple inheritance means a class inherits behaviour and state from more than one parent class. It can be useful for combining capabilities, but it creates issues such as method name conflicts, ambiguous calls, tighter coupling, and the diamond problem, where the same base class is inherited through multiple paths and shared state becomes unclear.
Ans. Memory management is how an operating system tracks, allocates, protects and frees main memory for processes. It gives each process a virtual address space, maps it to physical memory using page tables, and allocates memory in pages or segments. The key detail is isolation, so one process cannot read or corrupt another’s memory.
Ans. 22 times. The method is to use relative speed: the minute hand moves at 6 degrees per minute and the hour hand at 0.5 degrees per minute, so the minute hand gains 5.5 degrees per minute. It catches up every 360 ÷ 5.5 minutes, giving 11 crossings in 12 hours and 22 in 24 hours.
Ans. Label the balls A to H. Weigh A, B, C against D, E, F. If they balance, the heavy ball is G or H, so weigh G against H. If one side is heavier, the heavy ball is among those three. Weigh two of them; the heavier one wins, or if equal, the third is heavier.
Ans. Yes. Start at bottom left, draw a diagonal through the centre to top right. Continue left across the top row to just beyond top left. Draw a diagonal down right through middle left and bottom middle to just below bottom right. Finish by going straight up through bottom right and middle right. Each dot is crossed once.
Ans. Assume one ant starts at each vertex and each independently chooses clockwise or anticlockwise. For a triangle, there is no collision only if all three choose the same direction. That has probability 2 out of 8, so collision probability is 6 out of 8, or 3/4. For n vertices, collision probability is 1 − 2/2^n = 1 − 1/2^(n−1).
Ans. The angle is 7.5 degrees. To solve clock-angle problems, place 12 at 0 degrees. The minute hand moves 6 degrees per minute, so at 15 minutes it is at 90 degrees. The hour hand moves 30 degrees per hour plus 0.5 degrees per minute, so it is at 97.5 degrees.
Ans. A strong answer should use a clear troubleshooting example involving search relevance, data quality, or user intent. Emphasise checking the query, location, language, personalisation, ranking signals, synonyms, and recent content changes. Interviewers listen for structured diagnosis, separating user-side issues from algorithmic issues, evidence-based testing, and clear escalation if a systemic relevance problem appears.
Ans. A strong answer should use a real troubleshooting example with a clear, calm process. Pick a situation where you checked simple causes first, such as mute, volume, input, cables and TV audio settings, then isolated the fault by testing another device or speaker. Emphasise communication, safety, documentation and confirming the fix. Interviewers listen for logical diagnosis.
No question matches those filters. Reset filters.
Showing 60 of 297 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 (47%) and DSA (42%).
Candidate interviews show an average of 3.4 rounds per experience, with a typical sequence of Online test. Individual interview paths can vary.
Among questions with a recorded difficulty, the mix is easy 37%, medium 53%, hard 10%.
