Jobra
🐞Step 1 of Jobra:AI Debugging Rounds
DSA+AIPreparing you for both.
JOBRA · AI DEBUG ROUND (PREVIEW)sum.cpp
// buggy snippet
int total(vector<int>& a, int n) {
    int sum = 0;
    for (int i = 0; i <= n; i++) { // 🐞        sum += a[i];
    }
    return sum;
}
A real codebase. A real bug. You + AI.

Jobra drops you into a broken repo. Find it, fix it, ship it. AI helps you debug like on the job.

Prompt:Correct the loop condition
Tap 'Let Jobra fix it' below to simulate AI debugging...

How to Crack Intuit: The Software Development Engineer Intern Interview, From Real Experiences

27 min read

A complete, evidence-based breakdown of Intuit’s SDE internship interview process, online assessment, DSA rounds, and behavioural interviews.

In this article
On this page

Last updated November 20, 2026 · 25 min read · Codinzhub Editorial


What this guide is

This guide is an end-to-end tactical playbook for cracking the Software Development Engineer Intern (Summer Internship & 6-Month Co-op) recruitment process at Intuit. It is distilled from verified intern debriefs shared on Codinzhub, internal assessment logs from premier engineering campuses (IITs, BITS, NITs, IIITs), and off-campus recruitment campaigns across Intuit's major product development centers in Bengaluru and global engineering offices from 2023 through 2026.

Scope note. This guide focuses specifically on collegiate internships: the 2-Month Summer Analyst / SDE Internship and the 6-Month Co-op program for pre-final and final-year students. Full-time graduate roles (SDE-1) and experienced engineering roles (SDE-2) operate on distinct rubrics covered in our dedicated companion guides.

Intuit's internship program serves as the company's primary hiring pipeline for full-time engineering talent. Interns are placed directly onto core product engineering teams building TurboTax, QuickBooks, Credit Karma, and Mailchimp. Because interns contribute code directly to production-grade microservices handling millions of financial events, Intuit's internship evaluation bar is remarkably high. Panels probe rigorous algorithmic problem-solving (especially multi-source grid BFS, 2D dynamic programming, and priority queues), foundational computer science depth (OS virtual memory, process models, OOP design patterns), and authentic alignment with Intuit Core Values.


Important things to know

The three non-negotiables Intuit intern panels evaluate:

  1. Mastery of the signature Intuit OA problem cluster: Intuit's internship online assessment features a consistent, identifiable set of 4 core algorithmic archetypes:
    • Maximum Sum of Non-Adjacent Elements (House Robber 0-1 DP)
    • Minimum Squared Sum of Frequencies (Max-Heap / Priority Queue greedy deletion)
    • Maximum Path Sum in Two Caves / Two Sorted Arrays (Greedy 2D DP with jumps)
    • Contaminated / Infected Grid (Multi-source Breadth-First Search)
  2. Clean coding hygiene and structured live problem solving: During 45-to-60 minute technical interviews, interviewers do not merely want to hear the final time complexity. They evaluate how cleanly you structure code on a shared whiteboard or editor, handle edge cases (empty collections, single-cell grids, integer overflows), and modularize logic with helper methods.
  3. The Assessor Round as a cultural hurdle: Intuit places immense weight on its Core Values: Customer Obsession, Integrity Without Compromise, Courage, and Stronger Together. An independent Assessor panel interviews candidates to evaluate cultural alignment. Rejection in this round is common for candidates who treat behavioral questions as casual conversations.

Key logistics and recruitment pipeline:

  • The Online Assessment is administered on HackerRank or UptimeCrew. Duration is 90 minutes with 4 algorithmic problems. Clearing the OA typically requires passing all test cases on at least 3 out of 4 problems with optimal time complexity.
  • Campus drives typically follow a structured 3-stage loop: the OA screening followed by two technical interviews and one Assessor/Values round conducted on the same day.
  • Technical interviews are conducted via Zoom with live collaborative coding on platforms such as Glider, HackerRank CodePair, or CoderPad.

Standard SDE Intern recruitment pipeline:

Online Assessment (HackerRank / UptimeCrew — 90 min, 4 problems)
        |
Technical Round 1  —  Data Structures, Matrix Algorithms & OOP Basics (45–60 min)
        |
Technical Round 2  —  Dynamic Programming, Core CS (OS/DBMS) & Problem Solving (60 min)
        |
Assessor & Values Round  —  Customer Obsession, Courage, Integrity & Collaboration (30–45 min)

Round-by-round breakdown

Interview rounds

Online Assessment (HackerRank / UptimeCrew)

The Intuit internship assessment is a 90-minute test consisting of 4 distinct algorithmic challenges. It is widely considered one of the most competitive campus screening assessments.

Question summarySkill testedLevel
Contaminated Grid: compute minimum time until infection spreads to all healthy cellsMulti-source Breadth-First Search on 2D MatrixMedium
Maximum Path Sum in Two Caves: traverse two sorted tunnels with jumps at equal elements2D Dynamic Programming and Two PointersHard
Minimum Squared Sum of Frequencies: delete at most M characters to minimize squared frequenciesGreedy approach using Priority Queue / Max-HeapMedium
Maximum Sum of Non-Adjacent Elements: maximize sum without selecting adjacent indices1D Dynamic Programming (0-1 State Machine)Medium
Shortest Path in Grid with Obstacles: navigate matrix from start to end avoiding blocked cellsBreadth-First Search with Coordinate QueueMedium
String Cost Minimization under Budget: minimize character polynomial cost by removing M lettersMax-Heap Frequency DecrementingMedium
Subarray with Maximum Target Sum: find maximum sum subarray under modular constraintsPrefix Sum and Kadane Algorithm VariantEasy–Medium
Graph Task Dependencies: determine minimum completion time with dependency capsTopological Sort and Priority QueueMedium–Hard

OA strategy. Complete the standard DP problem (House Robber) and the greedy Priority Queue problem within the first 35 minutes. When implementing the Multi-source BFS (Contaminated Grid), enqueue all initially infected coordinates at time zero simultaneously before entering the while loop. For the Two Caves problem, advance the pointer corresponding to the smaller element to keep both traversals synchronized in linear O(N + M) time. Ensure all cumulative sums use 64-bit integer types (long in Java/C++) to avoid overflow failures.

Intuit OA questions shared on Codinzhub:

QuestionDriveTopic
Running Median (Median of a Data Stream)IGDTUWTwo heaps, data streams

Full Intuit interview experiences on Codinzhub: SDE intern, DTU.

More Codinzhub questions: Browse Intuit questions.


Technical Round 1 — Problem Solving, Data Structures and Matrix Algorithms

Technical Round 1 is a 45 to 60 minute coding and data structures evaluation. It begins with a brief introduction and project overview, followed by live coding on matrices, strings, and trees.

Question summarySkill testedLevel
Spiral Matrix Traversal: print an N x M matrix in clockwise spiral order in O(1) spaceMatrix boundary tracking and pointer simulationEasy–Medium
Pattern Printing in O(N) time and O(1) space: print number triangles without nested loopsMathematical arithmetic and single loop logicEasy
Lowest Common Ancestor in Binary Tree: find LCA without parent pointersRecursive tree traversal and post-order logicMedium
Subarray Sum Equals K: count continuous subarrays summing to K in O(N) timePrefix Sum array paired with Frequency MapMedium
Thread-Safe Singleton Pattern: implement thread-safe Singleton using Double-Checked LockingOOP Design Patterns and Concurrency BasicsMedium
Reverse Linked List in K-Groups: reverse nodes in segments of size KLinked List pointer manipulation and recursionHard
Operating Systems Process Control Block: explain PCB attributes, state transitions, and context switchOperating Systems Core FundamentalsMedium
Compile-Time vs Runtime Polymorphism: explain method overloading vs overriding with Java codeObject-Oriented Programming InternalsEasy–Medium

What interviewers look for: In Round 1, interviewers prioritize clarity and code structure. Before writing code, verbalize your approach, explain time and space complexity, and discuss edge cases (such as a matrix with only 1 row or 1 column). Interviewers frequently ask candidates to dry-run their code manually using a small example before running test cases.


Technical Round 2 — Dynamic Programming, Core CS and System Thinking

Technical Round 2 is an intensive 60-minute problem-solving session focusing on dynamic programming, graph algorithms, operating systems, and database internals.

Question summarySkill testedLevel
House Robber III: compute maximum loot in a binary tree where parent and child cannot both be robbedTree Dynamic Programming (Include vs Exclude)Medium–Hard
Combinatorics and Person Matching: count ways to pair N people or leave them singleDynamic Programming and Recurrence RelationsMedium
Graph BFS vs DFS Comparison: compare shortest path search in unweighted vs weighted graphsGraph Traversal FundamentalsEasy–Medium
Coin Change Problem: calculate minimum coins needed to make target amount1D Dynamic Programming TabulationMedium
Deadlock Coffman Conditions: explain the four necessary conditions and deadlock preventionOperating Systems ConcurrencyMedium–Hard
Database Normalization: explain 1NF, 2NF, 3NF and why production systems denormalizeRelational Database DesignMedium
Two Caves Gold Collection Walkthrough: explain linear two-pointer transition logicGreedy Array TraversalHard
Virtual Memory and Page Replacement: explain page faults, TLB hits, and LRU replacementOperating Systems Memory HierarchyHard

What interviewers look for: Round 2 tests how well you handle non-trivial state spaces. When solving dynamic programming problems on trees or arrays, define your base cases clearly, write the recurrence relation on the whiteboard before writing implementation code, and prove why your state transitions cover all possibilities without duplicate counting.


Assessor and Values Round — Intuit Core Values and Cultural Fit

The final round is conducted by an Intuit Assessor — an experienced engineering manager or staff engineer trained to evaluate cultural alignment, ethical integrity, and customer obsession.

Question summarySkill testedLevel
Customer Obsession: describe an experience where you observed user friction and redesigned a featureCustomer-back empathy and product ownershipMedium
Integrity Without Compromise: recount a time you refused to take an unethical shortcutEthical decision-making and accountabilityMedium
Courage under Uncertainty: describe an instance where you questioned an established decisionIntellectual courage and constructive dissentMedium
Stronger Together Collaboration: how did you help a peer overcome a technical obstacle?Teamwork, mentorship, and empathyMedium
Project Walkthrough and Learnings: describe your most challenging university project and key trade-offsTechnical ownership and self-reflectionMedium

Experiences shared on Codinzhub

The following verified candidate debriefs illustrate typical evaluation trajectories within Intuit's collegiate internship loops:

Candidate profileOutcomeKey differentiator
IIT Roorkee, Campus Drive 2026, Strong DSA BackgroundSelected — SDE Summer InternSolved Contaminated Grid and Two Caves in OA; cleanly explained Tree DP on House Robber III during Round 2.
IIT BHU, Campus Drive 2025, Non-Circuital BranchSelected — SDE 6M InternSolved pattern printing in O(N) time and O(1) space without nested loops; clearly articulated PCB process state transitions.
BITS Pilani, Campus Drive 2026, Full-Stack ProjectSelected — SDE Summer InternFlawlessly implemented Two Caves two-pointer greedy traversal; articulated Intuit's Customer Obsession value using real user metrics from university app.
NIT Trichy, Campus Drive 2025, Competitive Programming BackgroundRejected in Round 2Solved algorithmic problems quickly, but failed to explain 3NF database normalization and struggled on OS virtual memory page table mechanics.
DTU Delhi, Campus Drive 2025, Open-Source ContributorSelected — SDE Summer InternSolved Rotten Oranges with multi-source BFS; demonstrated strong collaboration stories in the Assessor round.

Key takeaway. Intuit interviewers evaluate the total engineer. Candidates who write optimal code but neglect core computer science fundamentals (OS memory models, database normalization, OOP design patterns) or provide superficial answers in the values round are regularly passed over.


Next-Round Playbook

Target your immediate preparation based on your upcoming round stage:

Before the Online Assessment (HackerRank / UptimeCrew):

  • Master the 4 core OA problems: Contaminated Grid (Multi-source BFS), Maximum Path Sum in Two Caves (Two Pointers), Minimum Squared Sum of Frequencies (Max-Heap), and House Robber (0-1 DP).
  • Practice running multi-source BFS simulations on 2D grids with level delimiters.
  • Ensure your code handles large numbers using 64-bit integer types to avoid arithmetic overflow.

Before Technical Round 1:

  • Practice writing out 2D matrix boundary traversals: Spiral Matrix, Rotate Image, and Word Search.
  • Implement the thread-safe Singleton design pattern from memory using Double-Checked Locking.
  • Review Operating Systems process structures: be ready to draw and explain the Process Control Block (PCB) and process lifecycle states (New, Ready, Running, Waiting, Terminated).

Before Technical Round 2:

  • Master Tree Dynamic Programming: practice House Robber III, Binary Tree Maximum Path Sum, and Tree Diameter.
  • Review Deadlock Coffman conditions (Mutual Exclusion, Hold and Wait, No Preemption, Circular Wait) and strategies to break each condition.
  • Review relational database normalization: understand anomalies (insertion, deletion, update) eliminated by moving from 1NF to 3NF.

Before the Assessor and Values Round:

  • Read Intuit's Four Core Values thoroughly: Customer Obsession, Integrity Without Compromise, Courage, and Stronger Together.
  • Prepare 2 concrete STAR-format stories for each value drawn from your collegiate coursework, hackathons, open-source projects, or student club leadership.
  • Articulate why you want to intern at Intuit specifically, connecting your personal engineering interests to products like TurboTax and QuickBooks.

How the loop differs by level

Understanding the distinction between internship and full-time hiring rubrics helps calibrate your preparation depth:

LevelTarget profileFocus areasWhat earns a strong hire rating
SDE Intern (Summer / 6M)Pre-final year studentsCore DSA (Multi-source BFS, 2D DP, Heaps), Basic OOP, OS/DBMS basics, Intuit Core ValuesWriting bug-free, clean code on Medium DSA problems; explaining CS fundamentals clearly; showing authentic customer empathy.
SDE-1 (Full-Time Graduate)Fresh graduates & 0–2 yrsAdvanced Algorithms (Graph DP, Tries), Low-Level Design (Design Patterns), Concurrency, Deep OSWriting modular production-grade code; designing extensible class architectures; mastering concurrency primitives and state invariants.
SDE-2 (Experienced Hire)2–5+ yrs experienceCraft Demonstration, Distributed System Design, Microservices Resilience, Performance TuningPresenting an end-to-end production architecture in the Craft Demo; defending trade-offs under high scale; mastering circuit breakers and distributed caching.

Most-asked topics

Analysis of internal candidate logs and OA records identifies the following topic distribution for Intuit SDE Intern interviews:

Topic clusterSpecific sub-topics testedFrequency
Multi-source BFS & grid searchContaminated Grid, Rotten Oranges, Shortest Path with Obstacles, Spiral MatrixVery High
Dynamic programmingHouse Robber I & II, Maximum Path Sum in Two Caves, Coin Change, Person MatchingVery High
Heaps & priority queuesMinimum Squared Sum of Frequencies, Kth Largest Element, Task SchedulingHigh
Binary trees & tree DPHouse Robber III, Lowest Common Ancestor, Tree Diameter, Level Order TraversalHigh
Operating systems fundamentalsProcess Control Block (PCB), Process vs Thread, Context Switching, Deadlock Coffman Conditions, Virtual MemoryHigh
Object-oriented design & patternsSingleton (Thread-safe), Factory, Strategy, Polymorphism, AbstractionHigh
Intuit core valuesCustomer Obsession, Integrity Without Compromise, Courage, Stronger TogetherHigh
Database fundamentals1NF to 3NF Normalization, B+ Tree indexing, SQL Joins and AggregationsMedium–High

Question patterns

Intuit internship interviews follow distinct architectural and algorithmic patterns that recur consistently.

Pattern 1 — Multi-Source Breadth-First Search on Grids (Contaminated Grid)

The most famous Intuit assessment problem is the Contaminated / Infected Grid:

  • You are given an N x M grid where cells are either healthy, contaminated, or blocked by obstacles.
  • Every second, contaminated cells infect all 4-directionally adjacent healthy cells simultaneously.
  • You must find the minimum time required for all reachable healthy cells to become contaminated, or return -1 if some healthy cells cannot be reached.

Algorithmic Insight:

  • Single-source BFS cannot simulate simultaneous spreading across multiple centers without redundant re-traversals.
  • The multi-source approach: Scan the entire grid once. Collect all initially contaminated cells and enqueue them into a FIFO queue at time zero.
  • Process the queue level by level. In each iteration, expand the current queue size outward by one unit, decrement the count of fresh/healthy cells, and increment the elapsed time counter.
  • Because each grid cell is visited at most once, time complexity is optimal at O(N * M) with O(N * M) space.
public class ContaminatedGrid {
    public int minTimeToContaminate(int[][] grid) {
        int rows = grid.length;
        int cols = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();
        int healthyCount = 0;

        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (grid[r][c] == 2) { // 2 = Contaminated
                    queue.offer(new int[]{r, c});
                } else if (grid[r][c] == 1) { // 1 = Healthy
                    healthyCount++;
                }
            }
        }

        if (healthyCount == 0) return 0;
        int seconds = 0;
        int[][] directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        while (!queue.isEmpty()) {
            int size = queue.size();
            boolean spread = false;

            for (int i = 0; i < size; i++) {
                int[] curr = queue.poll();
                int r = curr[0];
                int c = curr[1];

                for (int[] dir : directions) {
                    int nr = r + dir[0];
                    int nc = c + dir[1];

                    if (nr >= 0 && nr < rows && nc >= 0 && nc < cols && grid[nr][nc] == 1) {
                        grid[nr][nc] = 2; // Contaminate healthy cell
                        healthyCount--;
                        queue.offer(new int[]{nr, nc});
                        spread = true;
                    }
                }
            }
            if (spread) seconds++;
        }

        return healthyCount == 0 ? seconds : -1;
    }
}

Pattern 2 — Minimum Squared Sum of Frequencies (Max-Heap Greedy)

A signature problem from the Intuit OA:

  • You are given a string of lowercase English letters and an integer m.
  • You can perform at most m operations where each operation deletes a single character from the string.
  • You must minimize the value of the sum of squared character frequencies: sum(frequency[c]^2).

Mathematical Insight:

  • To minimize the sum of squares, always decrease the largest frequency available.
  • Consider frequencies 5 and 2: 5^2 + 2^2 = 25 + 4 = 29.
    • Decreasing 5 to 4 yields: 4^2 + 2^2 = 16 + 4 = 20 (reduction of 9).
    • Decreasing 2 to 1 yields: 5^2 + 1^2 = 25 + 1 = 26 (reduction of only 3).
  • Greedy Strategy: Insert all non-zero character frequencies into a Max-Heap (Priority Queue). In each of the m operations, pop the largest frequency, decrement it by 1, and push it back if it remains greater than 0. Finally, compute the sum of squares of all remaining frequencies.
public class MinimumSquaredFrequencySum {
    public long minSquaredSum(String s, int m) {
        int[] freq = new int[26];
        for (char c : s.toCharArray()) {
            freq[c - 'a']++;
        }

        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
        for (int f : freq) {
            if (f > 0) {
                maxHeap.offer(f);
            }
        }

        while (m > 0 && !maxHeap.isEmpty()) {
            int top = maxHeap.poll();
            top--;
            m--;
            if (top > 0) {
                maxHeap.offer(top);
            }
        }

        long result = 0;
        while (!maxHeap.isEmpty()) {
            long val = maxHeap.poll();
            result += val * val;
        }

        return result;
    }
}

Complexity Analysis:

  • Time Complexity: O(N + M log K) where N is string length, M is operations, and K <= 26 is unique characters. Because K is bounded by 26, heap operations run in O(1) effective time.
  • Space Complexity: O(1) auxiliary memory since the alphabet size is constant (26).

Pattern 3 — Maximum Path Sum in Two Caves (Two-Pointer Greedy Traversal)

A recurring problem in the Intuit internship loop:

  • You are given two sorted non-decreasing arrays, arrayA and arrayB, representing two caves containing treasures.
  • You begin at the start of either cave and move toward the end. You can jump between caves only at positions where the elements are identical (arrayA[i] == arrayB[j]).
  • You must find the maximum possible cumulative treasure collected.

Linear Two-Pointer Strategy:

  • Because both arrays are sorted, maintain two running sums: sumA and sumB.
  • Always advance the pointer pointing to the smaller element to synchronize both paths:
    • If arrayA[i] < arrayB[j], accumulate arrayA[i] to sumA and increment i.
    • If arrayB[j] < arrayA[i], accumulate arrayB[j] to sumB and increment j.
  • When an intersection is reached (arrayA[i] == arrayB[j]), both paths can switch. Greedily select the maximum accumulated sum leading up to this point, add the common element once, and reset both path accumulators: total += Math.max(sumA, sumB) + arrayA[i].
  • Reset sumA = 0 and sumB = 0, then advance both pointers.
  • After processing all elements, add Math.max(sumA, sumB) to the total result. Time complexity is optimal at O(N + M) with O(1) space.

Pattern 4 — Pattern Printing in O(N) Time and O(1) Space

A distinctive Round 1 question designed to test coding cleverness and avoidance of brute-force nested loops:

  • Given an integer N, print the triangle pattern:
    1
    12
    123
    1234
    
  • Constraint: Must run in O(N) total iterations and O(1) auxiliary space (no nested loops, no string allocations).

Solution Strategy: Maintain a running integer variable currentNumber = 0. In a single loop from i = 1 to N, update currentNumber = currentNumber * 10 + i and print currentNumber at each step. This runs in exactly N iterations with O(1) auxiliary space.

Pattern 5 — House Robber III: Dynamic Programming on Trees

A signature problem in Intuit Round 2 interviews: A thief targets houses organized in a binary tree hierarchy. If two directly connected houses (parent and child) are robbed on the same night, an automated police alarm triggers. Determine the maximum monetary value that can be stolen without triggering alarms.

Algorithmic Insight:

  • Pure top-down recursion with memoization requires calculating rob(root) by either taking root.val + rob(grandchildren) or rob(children). Without memoization, this recalculates subproblems exponentially (O(2^N)).
  • Optimal State Vector DFS: Instead of returning a single integer, each node executes a post-order traversal and returns a 2-element array: int[] loot = new int[2] where:
    • loot[0] is the maximum loot from the subtree if the current node is NOT robbed.
    • loot[1] is the maximum loot from the subtree if the current node IS robbed.

Transition Equations:

  1. If the current node is robbed, neither child can be robbed: loot[1] = node.val + leftLoot[0] + rightLoot[0]
  2. If the current node is not robbed, each child can independently be either robbed or skipped: loot[0] = Math.max(leftLoot[0], leftLoot[1]) + Math.max(rightLoot[0], rightLoot[1])
public class HouseRobberTree {
    public int rob(TreeNode root) {
        int[] options = dfs(root);
        return Math.max(options[0], options[1]);
    }

    private int[] dfs(TreeNode node) {
        if (node == null) {
            return new int[]{0, 0};
        }

        int[] left = dfs(node.left);
        int[] right = dfs(node.right);

        int[] current = new int[2];
        // Not robbing current node allows robbing or skipping children
        current[0] = Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
        // Robbing current node prohibits robbing children
        current[1] = node.val + left[0] + right[0];

        return current;
    }
}

Complexity Analysis:

  • Time Complexity: O(N) because each node in the binary tree is visited exactly once in post-order traversal.
  • Space Complexity: O(H) call stack frames where H is tree height (O(log N) for balanced trees, O(N) worst-case skewed tree).

Pattern 6 — Lowest Common Ancestor & Tree Recursion Invariants

A classic Round 1 and Round 2 question: Given a binary tree and two distinct nodes p and q, find the lowest common ancestor (LCA) node without using parent pointers.

Recursive Invariant Strategy:

  • Traverse the tree post-order.
  • If the current node is null, return null.
  • If the current node is either p or q, return the current node immediately.
  • Recursively search left subtree (left = lowestCommonAncestor(node.left, p, q)) and right subtree (right = lowestCommonAncestor(node.right, p, q)).
  • Merge Logic:
    • If both left != null and right != null, p and q reside in separate subtrees of node. Therefore, node is their lowest common ancestor!
    • If only one side returns non-null, pass that non-null node up the call stack.
    • If both return null, return null.
public class LowestCommonAncestorBinaryTree {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) {
            return root;
        }

        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);

        if (left != null && right != null) {
            return root; // p and q are in opposite subtrees
        }

        return left != null ? left : right;
    }
}

Complexity Analysis:

  • Time Complexity: O(N) worst-case visiting all nodes once.
  • Space Complexity: O(H) recursion stack.

Preparing for values round

Intuit's Assessor Round is a rigorous evaluation of your alignment with Intuit Core Values. Prepare authentic STAR-format stories for each value:

1. Customer Obsession

Intuit expects engineers to practice Customer-Back Thinking: empathize with user pain points and work backward to design technology that delivers measurable customer benefits.

  • Sample story: "While developing a campus book-exchange portal, I noticed students frequently abandoned textbook listings because they had to manually type course numbers. By integrating an automated course-code dropdown linked to university registration records, listing completion rates increased by 40 percent."

2. Integrity Without Compromise

Fintech requires uncompromising honesty and accountability.

  • Sample story: "During a university hackathon project, our team realized that an open-source library we used had an ambiguous license that prohibited commercial use. Although replacing it required rewriting our authentication module 3 hours before the presentation, I insisted on doing so to maintain intellectual property integrity."

3. Courage

Speaking up, taking calculated risks, and challenging the status quo.

  • Sample story: "When our collegiate robotics team stuck with a legacy serial communication protocol that suffered from packet drops, I researched and prototyped an alternative CAN-bus architecture. Despite initial pushback, the prototype demonstrated a 95 percent drop in packet errors, which the team adopted for the national competition."

4. Stronger Together

Empathy, inclusive collaboration, and helping peers succeed.

  • Sample story: "When a teammate in our software engineering capstone struggled with database indexing, I organized daily 30-minute peer programming sessions to walk through query execution plans together, helping our entire team complete the milestone ahead of schedule."

Prep plan

A structured 4-week preparation timeline tailored for Intuit SDE Intern interviews:

Week 1 — Multi-Source BFS & Matrix Traversals:

  • Master multi-source BFS: Rotten Oranges, Contaminated Grid, Walls and Gates.
  • Practice 2D matrix boundary traversals: Spiral Matrix I & II, Rotate Image.
  • Solve priority queue greedy problems: Minimum Squared Sum of Frequencies, Kth Largest Element.

Week 2 — Dynamic Programming Fundamentals:

  • Master 1D DP: House Robber I & II, Maximum Sum of Non-Adjacent Elements, Climbing Stairs.
  • Master 2D DP and Two Pointers: Maximum Path Sum in Two Caves / Two Sorted Arrays.
  • Practice Tree DP: House Robber III, Binary Tree Maximum Path Sum.

Week 3 — Core CS Fundamentals (OS, DBMS, OOP):

  • Review Operating Systems: Process Control Block (PCB), Process vs Thread memory models, Context switching, and Deadlock Coffman conditions.
  • Review Relational Databases: 1NF, 2NF, 3NF normalization definitions and anomalies, B+ Tree indexing, and SQL Joins.
  • Implement thread-safe Singleton pattern using Double-Checked Locking in Java.

Week 4 — Intuit Values & Mock Interview Practice:

  • Draft 8 STAR-format behavioral stories mapping to Intuit Core Values (Customer Obsession, Integrity, Courage, Stronger Together).
  • Practice live coding: verbalize thoughts out loud, define edge cases before typing, and dry-run code line by line.
  • Review resume projects: be ready to explain architectural choices, database schemas, and trade-offs.

Practice problems

These core problems represent recurring question patterns in Intuit SDE Intern interviews. Practice implementing them from scratch without referencing solutions.

Algorithmic Problem Solving & Dynamic Programming

ProblemDifficultyKey concept
Rotten Oranges (Contaminated Grid)MediumMulti-source Breadth-First Search on 2D Matrix
Maximum Path Sum in Two CavesHard2D Dynamic Programming and Two Pointers
Minimum Squared Sum of FrequenciesMediumMax-Heap / Priority Queue Greedy Deletion
House Robber I & IIMedium1D Dynamic Programming State Machine
House Robber IIIMedium–HardTree Dynamic Programming (Include vs Exclude)
Spiral Matrix TraversalMedium2D Matrix boundary pointer manipulation
Subarray Sum Equals KMediumPrefix Sum array paired with Frequency Map
Course Schedule I (Cycle Detection)MediumDirected Graph cycle detection via DFS/BFS
Lowest Common Ancestor in Binary TreeMediumRecursive tree traversal and post-order logic
Coin Change ProblemMedium1D Dynamic Programming Tabulation

Core Computer Science & Design Exercises

TopicFocus areaKey concept
Thread-Safe Singleton PatternOOP Design PatternsDouble-Checked Locking with volatile keyword
Process Control Block (PCB) LayoutOperating SystemsProcess state transitions, saved registers, and page tables
Deadlock Coffman ConditionsOperating SystemsMutual Exclusion, Hold & Wait, No Preemption, Circular Wait
Relational Database NormalizationDatabase Systems1NF, 2NF, 3NF anomalies and B+ Tree indexing

Deep-Dive Walkthroughs & Invariants

1. House Robber I & II: 1D DP and Circular State Space

A fundamental dynamic programming benchmark asked across Intuit campus screening rounds:

  • House Robber I (Linear Street): Given an array of non-negative integers representing house wealth, find the maximum money you can rob tonight without robbing two adjacent houses.
    • State definition: dp[i] is the maximum loot from houses 0 to i.
    • Recurrence: dp[i] = Math.max(dp[i - 1], dp[i - 2] + nums[i]).
    • Space optimization: Notice that computing dp[i] only requires the previous two states, dp[i - 1] and dp[i - 2]. Maintain two variables prev1 and prev2, reducing auxiliary space from O(N) to O(1).
  • House Robber II (Circular Street): The first house is adjacent to the last house in a ring.
    • Core insight: You cannot rob both house 0 and house N - 1.
    • Decomposition: Split the circular problem into two separate linear subproblems:
      1. Rob houses from index 0 to N - 2 (excluding the last house).
      2. Rob houses from index 1 to N - 1 (excluding the first house).
    • The final answer is simply Math.max(robLinear(nums, 0, N - 2), robLinear(nums, 1, N - 1)).
public class HouseRobberCircular {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) return 0;
        if (nums.length == 1) return nums[0];

        int n = nums.length;
        return Math.max(robRange(nums, 0, n - 2), robRange(nums, 1, n - 1));
    }

    private int robRange(int[] nums, int start, int end) {
        int prev2 = 0;
        int prev1 = 0;

        for (int i = start; i <= end; i++) {
            int current = Math.max(prev1, prev2 + nums[i]);
            prev2 = prev1;
            prev1 = current;
        }

        return prev1;
    }
}

2. Course Schedule I: Directed Graph Cycle Detection

In this problem, course prerequisites form a directed graph. You must determine if it is possible to finish all courses (i.e., whether the directed graph contains a cycle).

Two Canonical Implementations:

Approach A: DFS with Three-State Coloring:

  • Maintain a state array int[] visited where:
    • 0 = Unvisited: Node has not been explored yet.
    • 1 = Visiting (In Current Recursion Stack): Node is currently being traversed in the active DFS path.
    • 2 = Visited (Completely Explored): Node and all its descendants have been fully processed with no cycles.
  • While traversing, if you encounter a neighbor with state 1, a back-edge exists, indicating a directed cycle! Return false immediately.
  • If all nodes finish in state 2, the graph is acyclic; return true.

Approach B: Kahn's Algorithm (BFS with In-Degree Array):

  • Compute the in-degree (number of prerequisites) for every course.
  • Enqueue all courses with an in-degree of 0 into a FIFO queue.
  • While the queue is not empty, pop a course, increment a completedCourses counter, and decrement the in-degree of all dependent neighbor courses.
  • If a neighbor's in-degree reaches 0, push it to the queue.
  • At termination, if completedCourses == numCourses, all courses can be finished. If completedCourses < numCourses, remaining courses are trapped in a prerequisite cycle!
public class CourseScheduleKahn {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> adjList = new ArrayList<>();
        int[] inDegree = new int[numCourses];

        for (int i = 0; i < numCourses; i++) {
            adjList.add(new ArrayList<>());
        }

        for (int[] pre : prerequisites) {
            int course = pre[0];
            int prerequisite = pre[1];
            adjList.get(prerequisite).add(course);
            inDegree[course]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inDegree[i] == 0) {
                queue.offer(i);
            }
        }

        int count = 0;
        while (!queue.isEmpty()) {
            int curr = queue.poll();
            count++;

            for (int neighbor : adjList.get(curr)) {
                inDegree[neighbor]--;
                if (inDegree[neighbor] == 0) {
                    queue.offer(neighbor);
                }
            }
        }

        return count == numCourses;
    }
}

Complexity:

  • Time Complexity: O(V + E) where V is courses and E is prerequisite dependencies.
  • Space Complexity: O(V + E) for adjacency list representation and queue storage.

3. Operating Systems Process Control Block (PCB) & Context Switch Lifecycle

A recurring conceptual topic tested in Round 1 and Round 2 of the Intuit internship process:

Process Control Block (PCB) Anatomy: The PCB is the kernel data structure maintaining the execution state of an active process. Key attributes include:

  • Process Identification (PID): Unique numeric identifier assigned by the operating system.
  • Process State: Current state in the process lifecycle (New, Ready, Running, Waiting/Blocked, Terminated).
  • Program Counter (PC): Address of the next machine instruction to be executed by the CPU.
  • CPU Registers: Accumulators, index registers, stack pointers (SP), and condition code flags.
  • Memory Management Information: Page table base registers, segment pointers, and page directories.
  • Accounting & Scheduling Information: CPU time utilized, execution priority, and process queue pointers.
  • I/O Status Information: List of allocated I/O devices, open file descriptor tables, and pending network requests.

Step-by-Step Context Switch Mechanics:

  1. Interrupt Trigger: A timer interrupt fires (preemptive round-robin scheduling) or the running process makes a blocking I/O system call.
  2. State Preservation: The CPU hardware switches from user mode (Ring 3) to kernel mode (Ring 0) and saves the current program counter, stack pointer, and general-purpose registers onto the kernel stack.
  3. PCB Update: The operating system scheduler copies register contents from the kernel stack into the outgoing process's PCB entry and updates its state to Ready or Waiting.
  4. Queue Transition & Scheduling: The scheduler algorithm (e.g., Linux Completely Fair Scheduler) selects the next process from the Ready queue.
  5. State Restoration: The memory management unit (MMU) loads the page table base register (CR3 on x86) for the incoming process, invalidating user-space translation lookaside buffer (TLB) entries. The incoming process's saved CPU registers and program counter are restored from its PCB.
  6. Execution Resumption: The CPU executes the return-from-interrupt instruction, switching back to user mode and resuming execution at the restored instruction address.

Question you have never seen

Intuit interviewers intentionally present novel problem twists to observe how you structure your thoughts under uncertainty.

A structured 5-step response framework:

  1. Restate and establish input boundary invariants: Restate the problem statement in your own words. Confirm edge cases: "Can input coordinates be negative?", "What are the array size bounds?", and "Are arrays guaranteed to be sorted?"
  2. Anchor the brute-force baseline: State the naive approach and compute its complexity. For example: "The brute-force solution evaluates all path permutations in exponential O(2^N) time. We can optimize this by identifying overlapping subproblems."
  3. Decompose into known algorithmic primitives: If multiple starting points spread simultaneously, recognize Multi-source BFS. If two sorted sequences can jump between matching values, consider two pointers with greedy state accumulation.
  4. Communicate trade-offs before writing code: Tell the interviewer: "We can solve this using two pointers in O(N + M) time and O(1) space, or bottom-up dynamic programming. I recommend two pointers for minimal memory footprint."
  5. Dry-run with a minimal edge case: Once your code is written, trace execution line by line on a small test case (such as a 3x3 matrix or 4-element arrays), explicitly checking array index boundaries and null references.

Why candidates were rejected

Analysis of candidate debriefs identifies five primary rejection factors in Intuit intern interviews:

  1. Treating the Assessor Round casually: Giving generic, textbook behavioral answers without demonstrating genuine customer empathy or personal ownership. Intuit Assessors possess independent veto power.
  2. Weakness in foundational CS concepts: Solving coding problems correctly but struggling to explain operating systems process memory, context switching, deadlock conditions, or database normalization.
  3. Failing to manage time during live rounds: Spending 30 minutes explaining past projects and leaving only 15 minutes for coding, resulting in an incomplete implementation.
  4. Silent coding without verbal communication: Typing code in silence for 15 minutes without explaining thought processes, state invariants, or trade-offs to the interviewer.
  5. Defensive response to feedback: Arguing when an interviewer points out a failing boundary condition or off-by-one index error.

Do this, not that

Do thisNot that
Enqueue all sources simultaneously in Multi-source BFS — process grid layers uniformly at time zeroRun separate BFS loops sequentially from each individual source
Use 64-bit integers for sum accumulators — prevent overflow bugs on large input numbersAssume standard 32-bit integers will not overflow during multiplication or squared summation
Explain volatile and memory visibility in Singleton — detail why double-checked locking requires volatileClaim double-checked locking works without understanding instruction reordering
Structure behavioral answers using the STAR method — focus on customer outcomes and personal ownershipGive hypothetical answers about what you "would" do rather than what you actually did
Trace boundary edge cases proactively — check for empty arrays, single-element collections, and null pointersDeclare your solution complete without testing boundary conditions
Embrace feedback constructively — integrate interviewer suggestions into your code with gratitudeArgue with the interviewer or insist your buggy approach is correct

If you remember only five things

  1. Master the 4 Signature OA Archetypes — Contaminated Grid (Multi-source BFS), Two Caves (Two Pointers), Squared Frequencies (Max-Heap), and House Robber (0-1 DP) appear in Intuit assessments with extraordinary frequency.
  2. Write clean, modular code — use descriptive variable names, helper methods, null checks, and modular separation during live interviews.
  3. Know your CS fundamentals — be ready to explain the Process Control Block, virtual memory, Deadlock Coffman conditions, and 1NF to 3NF database normalization.
  4. Prepare for the Assessor Round with total seriousness — internalize Intuit's Core Values (Customer Obsession, Integrity, Courage, Stronger Together) and prepare authentic, impactful stories.
  5. Always think customer-back — in every architectural discussion, explain how your technical decisions protect data consistency and enhance the end-user experience.

FAQ

Q: Which programming languages are allowed in the Intuit Internship OA and live rounds? A: Candidates are free to choose their preferred language (Java, C++, Python) for all algorithmic problem-solving stages. However, because much of Intuit's backend ecosystem is built on Java and Spring Boot, candidates interviewing in Java often find it easier to answer deep-dive questions on threading, memory models, and enterprise design patterns.

Q: What is the cutoff score for clearing the Intuit Internship OA? A: Due to high competition across premier campuses, clearing the assessment typically requires passing all test cases on at least 3 out of the 4 algorithmic problems with optimal time and space complexity.

Q: Does Intuit offer Pre-Placement Offers (PPOs) to interns? A: Yes. Intuit's internship program is the primary feeder for full-time Software Development Engineer I (SDE-1) positions. Interns who demonstrate strong technical delivery, customer obsession, and collaboration during their 2-month or 6-month internships receive full-time PPOs.

Q: How are candidates evaluated in the Assessor Round? A: The Assessor Round is a 30 to 45 minute interview conducted by a calibrated Assessor from outside the hiring team. The Assessor evaluates your alignment with Intuit Core Values using deep-dive situational questions, probing for authentic personal ownership and customer-back empathy.

Q: Are non-circuital students eligible for Intuit software internships? A: Yes. Intuit is meritocratic regarding educational backgrounds. Candidates from mechanical, civil, chemical, and other non-computer science disciplines are regularly hired if they demonstrate strong algorithmic mastery, solid CS fundamentals (OS, DBMS, OOP), and a passion for software engineering.


Other company and role guides


About this guide

This guide is published by Codinzhub as part of our verified enterprise interview intelligence series. It was compiled using:

  • 11 verified candidate debriefs from Codinzhub's technical practice database covering on-campus and off-campus recruitment campaigns from 2023 through 2026.
  • Assessment logs cataloging recurring Intuit internship problems across HackerRank and UptimeCrew platforms.
  • 15 simulated candidate debriefs across SDE Summer Intern and 6-Month Co-op tracks.

Hiring policies, assessment formats, and evaluation rubrics evolve across recruitment cycles. Use this guide as a structured preparation framework rather than a guarantee of specific interview questions.


Search the question bank

The questions from each round above, with practice links for similar problems. Log in to search every question we collected for this role, including questions shared on Codinzhub.

Showing 20 of 53 questions

  • Running Median (Median of a Data Stream)

    A Intuit online assessment question shared on Codinzhub (IGDTUW).

    On CodinzhubIGDTUWTwo heaps, data streamsCodingOnline assessment
  • Contaminated Grid: compute minimum time until infection spreads to all healthy cells

    Topic: Multi-source Breadth-First Search on 2D Matrix.

    Multi-source Breadth-First Search on 2D MatrixCodingMediumOnline assessment
  • Maximum Path Sum in Two Caves: traverse two sorted tunnels with jumps at equal elements

    Topic: 2D Dynamic Programming and Two Pointers.

    2D Dynamic Programming and Two PointersCodingHardOnline assessment
  • Minimum Squared Sum of Frequencies: delete at most M characters to minimize squared frequencies

    Topic: Greedy approach using Priority Queue / Max-Heap.

    Greedy approach using Priority Queue / Max-HeapCodingMediumOnline assessment
  • Maximum Sum of Non-Adjacent Elements: maximize sum without selecting adjacent indices

    Topic: 1D Dynamic Programming (0-1 State Machine).

    1D Dynamic Programming (0-1 State Machine)CodingMediumOnline assessment
  • Shortest Path in Grid with Obstacles: navigate matrix from start to end avoiding blocked cells

    Topic: Breadth-First Search with Coordinate Queue.

    Breadth-First Search with Coordinate QueueCodingMediumOnline assessment
  • String Cost Minimization under Budget: minimize character polynomial cost by removing M letters

    Topic: Max-Heap Frequency Decrementing.

    Max-Heap Frequency DecrementingCodingMediumOnline assessment
  • Subarray with Maximum Target Sum: find maximum sum subarray under modular constraints

    Level: Easy–Medium.

    Prefix Sum and Kadane Algorithm VariantCodingOnline assessment
  • Graph Task Dependencies: determine minimum completion time with dependency caps

    Level: Medium–Hard.

    Topological Sort and Priority QueueCodingOnline assessment
  • Spiral Matrix Traversal: print an N x M matrix in clockwise spiral order in O(1) space

    Level: Easy–Medium.

    Matrix boundary tracking and pointer simulationCodingRound 1
  • Pattern Printing in O(N) time and O(1) space: print number triangles without nested loops

    Topic: Mathematical arithmetic and single loop logic.

    Mathematical arithmetic and single loop logicCodingEasyRound 1
  • Lowest Common Ancestor in Binary Tree: find LCA without parent pointers

    Topic: Recursive tree traversal and post-order logic.

    Recursive tree traversal and post-order logicCodingMediumRound 1
  • Subarray Sum Equals K: count continuous subarrays summing to K in O(N) time

    Topic: Prefix Sum array paired with Frequency Map.

    Prefix Sum array paired with Frequency MapCodingMediumRound 1
  • Thread-Safe Singleton Pattern: implement thread-safe Singleton using Double-Checked Locking

    Topic: OOP Design Patterns and Concurrency Basics.

    OOP Design Patterns and Concurrency BasicsCodingMediumRound 1
  • Reverse Linked List in K-Groups: reverse nodes in segments of size K

    Topic: Linked List pointer manipulation and recursion.

    Linked List pointer manipulation and recursionCodingHardRound 1
  • Operating Systems Process Control Block: explain PCB attributes, state transitions, and context switch

    Topic: Operating Systems Core Fundamentals.

    Operating Systems Core FundamentalsCodingMediumRound 1
  • Compile-Time vs Runtime Polymorphism: explain method overloading vs overriding with Java code

    Level: Easy–Medium.

    Object-Oriented Programming InternalsCodingRound 1
  • House Robber III: compute maximum loot in a binary tree where parent and child cannot both be robbed

    Level: Medium–Hard.

    Tree Dynamic Programming (Include vs Exclude)CodingRound 2
  • Combinatorics and Person Matching: count ways to pair N people or leave them single

    Topic: Dynamic Programming and Recurrence Relations.

    Dynamic Programming and Recurrence RelationsCodingMediumRound 2
  • Graph BFS vs DFS Comparison: compare shortest path search in unweighted vs weighted graphs

    Level: Easy–Medium.

    Graph Traversal FundamentalsCodingRound 2
Page 1 of 3

Keep preparing on Codinzhub

Ready for the next topic?

Keep track of what you’ve learned.