20+ Intuit Interview Questions and Answers for Freshers

Check if a given word is present in a sentence as a complete word.

• Split the sentence into words using spaces as delimiter.

• Check if the given word matches any of the words in the sentence.

• Ensure the word is not just a substring of another word in the sentence.

To detect the first node of a loop in a singly linked list, we can use Floyd's Cycle Detection Algorithm.

• Use Floyd's Cycle Detection Algorithm to detect the cycle in the linked list.

• Once the cycle is detected, find the starting node of the cycle using two pointers approach.

• The first pointer moves one step at a time while the second pointer moves two steps at a time until they meet at the starting node of the cycle.

Reverse a singly linked list of integers and return the head of the reversed linked list.

• Iterate through the linked list and reverse the pointers to point to the previous node instead of the next node.

• Use three pointers to keep track of the current, previous, and next nodes while reversing the linked list.

• Update the head of the reversed linked list as the last node encountered during the reversal process.

The N Queens Problem involves finding all possible placements of N queens on an N x N chessboard without threatening each other.

• Use backtracking algorithm to explore all possible configurations.

• Keep track of rows, columns, and diagonals to ensure queens do not threaten each other.

• Generate all valid configurations and print them out.

Sort an array of 0s, 1s, and 2s in linear time complexity using a single scan.

• Use three pointers to keep track of the positions of 0s, 1s, and 2s in the array.

• Iterate through the array and swap elements based on their values and the pointers.

• After a single scan, the array will be sorted in-place with 0s, 1s, and 2s in order.

Find the inorder successor of a given node in a binary tree.

• Perform an inorder traversal of the binary tree to find the successor node

• If the given node has a right child, the successor is the leftmost node in the right subtree

• If the given node does not have a right child, backtrack to find the ancestor whose left child is the given node

Add two numbers represented as linked lists and return the sum as a linked list.

• Traverse both linked lists simultaneously while keeping track of carry from previous sum

• Handle cases where one linked list is longer than the other by padding with zeros

• Create a new linked list to store the sum of the two numbers

Sort a stack in descending order using recursion without using loop constructs.

• Implement a recursive function to sort the stack in descending order.

• Use the provided stack operations to manipulate the stack.

• Recursively pop elements from the stack, sort them, and push them back in descending order.

• Handle base cases such as an empty stack or a single element stack.

• Ensure the stack is sorted in descending order after the recursive calls.

• Avoid using loop constructs like while or f...read more

The problem requires returning an array where each element is the product of all elements in the input array except itself.

• Iterate through the array twice to calculate the product of all elements to the left and right of each element.

• Use two arrays to store the products to the left and right of each element.

• Multiply the corresponding elements from the left and right arrays to get the final product array.

• Handle integer overflow by taking modulo MOD = 10^9 + 7.

• To solve with O(1...read more

Generate all valid parentheses combinations for N pairs.

• Use backtracking to generate all possible combinations of parentheses.

• Keep track of the number of open and close parentheses used.

• Add '(' if there are remaining open parentheses, and add ')' if there are remaining close parentheses.

• Stop when the length of the generated string is 2*N.

Given an array of integers and a target sum, find the minimum number of operations to make the sum of removed elements equal to the target.

• Iterate from both ends of the array, removing elements until the sum matches the target

• Use a two-pointer approach to efficiently find the minimum number of operations

• If achieving the target sum is not possible, return -1

Given a grid with type A and B people, maximize satisfaction based on neighbors.

• Start with type A people for maximum satisfaction

• Optimally place people to maximize satisfaction

• Consider satisfaction levels for each type of person and their neighbors

Find the number of states of cities connected by roads in a matrix.

• Identify connected cities using DFS or Union-Find algorithm

• Count the number of disjoint sets to determine the number of states

• Handle self-connections of cities by setting roads[i][i] = 1

The task is to find the diameter of a binary tree, which is the longest path between any two nodes in the tree.

• Traverse the tree to find the longest path between two nodes.

• Keep track of the maximum diameter found during traversal.

• The diameter may or may not pass through the root node.

• Consider the height of the left and right subtrees to calculate the diameter.

Identify all distinct triplets within an array that sum up to a specified number.

• Iterate through the array and use nested loops to find all possible triplets.

• Use a set to store unique triplets and check if the sum equals the target.

• Handle edge cases like duplicate elements and no valid triplets.

• Return the triplets as space-separated integers or -1 if no triplets exist.

Count the number of islands in a 2D matrix of 1s and 0s.

• Use Depth First Search (DFS) or Breadth First Search (BFS) to traverse the matrix and identify connected groups of 1s.

• Maintain a visited array to keep track of visited cells to avoid redundant traversal.

• Increment the island count each time a new island is encountered.

• Consider edge cases like boundary conditions and handling of diagonals while traversing.

• Handle the input matrix efficiently to optimize the solution.

• Example...read more

Given a string, find the longest palindromic substring, prioritizing the one with the smallest start index.

• Iterate through the string and expand around each character to find palindromes

• Keep track of the longest palindrome found and its starting index

• Return the longest palindromic substring with the smallest start index

Implement a stack using two queues to store integer values.

• Use two queues to simulate stack operations efficiently.

• Maintain the top element in one of the queues for easy access.

• Ensure proper handling of edge cases like empty stack.

• Example: Push elements onto one queue, then dequeue and enqueue to the other queue for pop operation.

• Example: Use a flag to track the top element and update it accordingly.

The objective is to minimize total penalty by selecting two numbers, summing them, and accumulating the penalty until only one number remains.

• Iteratively select two numbers, sum them, and accumulate the penalty until only one number remains.

• Choose the two smallest numbers to minimize the penalty.

• Repeat the process until only one number remains to find the minimum possible penalty.

Use sliding window technique to find smallest subarray with k distinct values.

• Use a sliding window approach to keep track of the subarray with k distinct values.

• Use a hashmap to store the frequency of each element in the window.

• Slide the window to the right until the hashmap contains k distinct elements.

• Shrink the window from the left while maintaining k distinct elements.

• Update the minimum subarray length as you slide the window.

• Return the smallest subarray length found.

• Exam...read more

Find the Kth largest element in an array of distinct positive integers.

• Sort the array in non-increasing order and return the Kth element.

• Use a priority queue or quick select algorithm for efficient solution.

• Handle constraints like array size and element values properly.

• Ensure all elements in the array are distinct for accurate results.

Rearrange the nodes of a singly linked list in a specific order without altering the data of the nodes.

• Use two pointers to split the linked list into two halves, reverse the second half, and then merge the two halves alternately.

• Ensure to handle cases where the number of nodes is odd or even separately.

• Time complexity: O(N), Space complexity: O(1)

• Example: Input: 1 -> 2 -> 3 -> 4 -> 5 -> NULL, Output: 1 -> 5 -> 2 -> 4 -> 3 -> NULL

I have worked on AWS technologies such as EC2, S3, Lambda, and RDS.

• EC2 (Elastic Compute Cloud)

• S3 (Simple Storage Service)

• Lambda

• RDS (Relational Database Service)

Polymorphism is the ability of a function or method to behave differently based on the object it is acting upon.

• Polymorphism allows objects of different classes to be treated as objects of a common superclass.

• There are two types of polymorphism: compile-time (method overloading) and runtime (method overriding).

• Example: Inheritance allows a child class to override a method from its parent class, exhibiting polymorphic behavior.

Code for stack operations in C++ using array

• Declare an array to store stack elements

• Implement push operation to add elements to the top of the stack

• Implement pop operation to remove elements from the top of the stack

• Implement peek operation to view the top element without removing it

Designed a high-level architecture for a web-based project using microservices and RESTful APIs.

• Utilized microservices architecture to break down the project into smaller, independent services.

• Implemented RESTful APIs for communication between services.

• Used a service discovery mechanism like Eureka or Consul for dynamic service registration and discovery.

• Ensured scalability and fault tolerance by incorporating load balancing and circuit breaker patterns.

• Secured communication ...read more