Intuit Interview Questions

Preparing for a job interview can be intimidating, particularly if you are unfamiliar with the process and don't know what to expect. Here is an overview of the typical Intuit recruitment process and everything you need to do to be prepared for each stage of the interview process in order to increase your odds of success. The interview process may change under certain circumstances. If you are seeking to be an Intuit software engineer, please ensure that you are fully prepared for each round of the interview.

The technical interview typically consists of a combination of situational and behavioural questions, as well as coding challenges, in order to measure an individual's degree of technical proficiency. The Intuit Recruitment process involves candidates going through four-five rounds of assessments that assess their technical, analytical, and behavioural abilities.

• Round 1: Online Test (Aptitude)
• Round 2: Technical Interview (1st)
• Round 3: Technical Interview (2nd)
• Round 3: HR Interview

Note: Candidates should be prepared to deal with any interview round that they might encounter. Depending on your experience, how you performed in previous rounds, and other considerations, there may be more or fewer rounds of technical interviews. Likewise, different types of questions may be asked. Therefore, it would be prudent to prepare yourself accordingly. When in doubt about any question, inform the interviewer politely. A candidate must pass all rounds in order to be considered for a position at Intuit.

• Aptitude: In the hiring process, aptitude tests are a great way to determine a candidate's suitability for a particular job position. Most companies conduct aptitude tests online, although some of them may also conduct in-person tests. In particular, this round includes multiple-choice questions (MCQs) and coding questions designed to test an individual's reasoning and logical abilities. Among the other important skills are problem-solving ability, prioritization skills, and numerical proficiency. As you write the code, be sure to include all boundary cases since these are the critical test cases that the interviewer is looking for.
• Technical Interviews (Round 2 + Round 3): After the aptitude round, those shortlisted will be invited to the Intuit Technical Interviews. In technical interviews, the interviewer evaluates both your technical abilities, which are generally linked to the position for which you are applying, as well as your ability to resolve conflicts and handle challenging situations. Technical questions will probe into your technical skills and experience as a software engineer. You will be asked both conceptual and programming questions, mostly in the areas of OOP, CS, DSA, SDLC, DBMS, OS, front-end/back-end, networking, automation frameworks, and web services like REST and SOAP, programming languages, updated technology like data mining, etc. Likewise, you can expect questions about your resume - questions about your projects, challenges faced, and how you overcame them. In this round, you may be asked to solve puzzles. During this round, you may ask questions about your team and responsibilities to determine whether you are a good fit for the job.
• HR Interview: Intuit's interview process ends with this round, so you need to prepare well. Candidate evaluations are based upon personality, communication skills, aptitudes, strengths, weaknesses, reasoning abilities, and fit for the position. Hiring managers ask you questions about your past experiences and your personal goals. It is likely that you will be asked some advanced questions concerning your role, as well as a few behavioural questions. A hiring manager may also ask you about previous internships and other matters related to your resume. When preparing for an HR interview, it is advisable to familiarize yourself with the organization's vision, technology stack, leadership principles, work-life balance, etc.

Let's move on to the most popular technical interview questions.

In order to make sure that you're building robust, maintainable tools, code reviews are integral to the development process. Code reviews enhance the visibility of a project, facilitate knowledge sharing among team members, improve maintainability, as well as help detect bugs. Whenever a developer submits their code for review, they hope for constructive feedback. The emphasis of a code review should not be on style, line spacing, or naming, but rather on giving constructive suggestions that will improve readability, maintainability, and bug-free code. Here are some of the points to keep an eye out for during every code review.

• Check if the code is working as intended by the developer.
• Look for repeated codes, if any.
• Does the code have an error handling method?
• Consider the run-time of algorithms
  • Is there any operation that is unnecessary? Remove unnecessary operations.
  • Is the algorithm performing repeated work? To prevent running the same computation more than once, can we use memoization to cache the data?
  • Look for nested loops. Can the operation be simplified without using them?
  • How much does it cost to access data? Does there exist a data structure that can reduce it?
• Which design patterns are employed in the new code?
  • Is the new code compatible with the overall architecture?
  • Is the code compliant with SOLID principles, Domain-Driven Design, and/or any other design paradigms being used by the team?
• Does this code conform to regulatory requirements?

When a string is the same from left to right as it is from right to left, then it is a palindrome. Consider the string "str". We need to find out whether its reverse string is the same as its current one.

Code:

// Java program to check whether a string is a Palindrome
import java.util.*;
public class Main
{
   public static void main(String args[])
   {
       String str1, str2 = "";
       Scanner sc = new Scanner(System.in);
       System.out.print("Enter the string: ");
       str1 = sc.nextLine();
       int n = str1.length();
       for(int i = n - 1; i >= 0; i--)
       {
           str2 = str2 + str1.charAt(i);
       }
       if(str1.equalsIgnoreCase(str2))
       {
           System.out.println("\nThe string is a palindrome.");
       }
       else
       {
           System.out.println("The string is not a palindrome.");
       }
   }
}

Sample Output1:

Enter the string: Radar
The string is a palindrome.

Sample Output2:

Enter the string: Scaler
The string is not a palindrome.

Suppose we are given two integers n1 and n2. Specifically, we will calculate the GCD of two numbers (whether they are positive or negative). The GCD of two integers is the greatest integer that divides both numbers exactly without a remainder.

Example: Here is a program that uses a while loop and an if-else statement to calculate GCD. This is a better approach. This approach involves subtracting the smaller integer from the larger integer and storing the result in the variable containing the larger integer. This is performed repeatedly until n1 and n2 are equal.

Code:

#include <stdio.h>
int main()
{
   int num1, num2;
   printf("Enter two integers: ");
   scanf("%d %d",&num1,&num2);
   // When a negative number is entered, its sign is turned into a positive
   num1 = ( num1 > 0) ? num1 : -num1;
   num2 = ( num2 > 0) ? num2 : -num2;
   while(num1!=num2)
   {
       if(num1 > num2)
           num1 -= num2;
       else
           num2 -= num1;
   }
   printf("GCD = %d", num1);
   return 0;
}

Output:

Enter two integers: 27
-34
GCD = 1

As Strings are immutable, it is not possible to change their elements/contents since any change would create a new String. On the other hand, if you use a char[, you still have the option of setting all elements to zero/blank. Thus, storing passwords in a character array clearly reduces the possibility of passwords being stolen or hacked.

A scope is a JavaScript concept used to manage access to functions, objects, and variables, from different parts of the program. In JavaScript, there are 3 types of scopes: function scope, global scope, and block scope.

• Global scope: Global variables are variables declared outside of all functions and are in the global scope. These variables can be accessed anywhere in the program.
• Function scope: Local variables are variables declared inside a function and are in the function scope. They may be accessed anywhere in the function in which they were declared.
• Block scope: Variables contained within blocks {} can't be accessed outside of those blocks.  Creating an object is necessary to access the variables of that specific block.

Let arr[] and n be a sorted array and a number, respectively.  Now, we must determine which pair of values in the array has a sum close to n.

Code:

import java.io.*;
import java.util.*;
import java.lang.Math; 
class Main 
{     
   // Returns the pair with a sum close to n
   static void closestSum(int arr[], int l, int n)
   { 
       //Used to store result pair indexes
       int resleft=0, resright=0;          
       int leftin = 0, rightin = l-1, diff = Integer.MAX_VALUE;
       while (rightin > leftin)
       {
           if (Math.abs(arr[leftin] + arr[rightin] - n) < diff)
           {
              resleft = leftin;
              resright = rightin;
              diff = Math.abs(arr[leftin] + arr[rightin] - n);
           }
 
             if (arr[leftin] + arr[rightin] > n)
              rightin--;
           else 
              leftin++;
       } 
      System.out.println("\nThe closest pair is "+arr[resleft]+" and "+ arr[resright] + ".");
   }
         
   // Driver Code
   public static void main(String[] args)
   {
       Scanner sc=new Scanner(System.in); 
       System.out.println("Enter number of elements in the sorted array: "); 
       int l= sc.nextInt(); 
       System.out.println("\nEnter elements of the array: ");  
       int[] arr = new int[5];  
       for (int i = 0 ; i < l; i++ )
       {
           arr[i]= sc.nextInt();    
       } 
     System.out.println("\nEnter the element for which you want to find the closest sum of pairs: "); 
       int n = sc.nextInt(); 
       closestSum(arr, l, n);       
   }
}

Output:

Enter number of elements in the sorted array: 
5
Enter elements of the array: 
12
24
31
29
16
Enter the element for which you want to find the closest sum of pairs: 
60
The closest pair is 31 and 16.

For assessment purposes, employers ask candidates to describe difficult situations they have handled in the past. Depending on the response a candidate provides, an employer can determine whether or not they are a good fit for the organization. Answers provide a window into a candidate's integrity, communication skills, leadership capabilities, initiative, and ability to react to unexpected situations.

Tips:

• Give a brief description of the "situation" you dealt with.
• Describe your role in the situation. Tell the actions you took to overcome the challenge.
• Describe how you arrived at the choices you made, being as specific as possible.
• Explain your results. You may conclude your answer by explaining what you learned and how you intend to apply it in the future.

In React, we use JSX to embed JavaScript objects within HTML elements. As JSX is embedded in HTML elements, it is not considered valid JavaScript. Because JSX combines HTML and JavaScript, it is not supported by browsers.

As there is no inherent implementation for browser engines to read and understand JSX, browsers are unable to read it. However, JSX was not designed to be implemented or used by browsers; instead, it is meant to be used by Babel transpilers to convert the JSX into valid JavaScript code. Because of this, if any file contains JSX files, the Babel transpiler converts these files into JavaScript objects and becomes valid JavaScript code. This allows browsers to understand and execute the code.

Binary search trees also referred to as sorted or ordered binary trees, are data structures that allow us to maintain sorted lists of numbers rapidly. The following are the properties of binary search trees:

• In the left subtree, all of the nodes are smaller than the parent node (root node).
• In the right subtree, all of the nodes are greater than the parent node (root node).
• The subtrees of each node are also BSTs, which means that they possess the two properties listed above.

As you can see in the diagram above, the left binary tree follows all the properties of BST, thereby making it a Binary Search Tree.  Alternatively, the right binary tree is not a binary search tree since the right subtree of the node "10" contains a value less than it, which is "8."

Consider an unsorted array arr[] of n integers. Our task is to find the number of subarrays whose sum is exactly the same as the given number x.

Code:

import java.util.*;
class Main 
{ 
   public static void main(String[] args)
   {
       Scanner sc=new Scanner(System.in); 
       System.out.println("Enter number of elements in the unsorted array: "); 
       int n= sc.nextInt(); 
       System.out.println("\nEnter elements of the array: ");  
       int[] arr = new int[5];  
       for (int i = 0 ; i < n; i++ )
       {
           arr[i]= sc.nextInt();    
       } 
       System.out.println("\nEnter value x for which you intend to find subarrays whose sum is exactly the same as x: "); 
       int x = sc.nextInt(); 
       int res = 0;
       // calculate all subarrays
       for (int i = 0; i < n; i++) 
       {
           int sum = 0;
           for (int j = i; j < n; j++) 
           {
               // Calculate the required sum
               sum += arr[j];
               // Check if sum equals required sum
               if (sum == x)
                   res++;
           }
       }
       System.out.println("\nTotal number of subarrays whose sum is equals to " + x + "= " + res);
   }
}

Output: 

Enter number of elements in the unsorted array: 
5
Enter elements of the array: 
8
2
9
1
3
Enter value x for which you intend to find subarrays whose sum is exactly the same as x: 
10
Total number of subarrays whose sum is equals to 10= 2

A software engineer is well acquainted with the  SDLC (Software Development Life Cycle). This question enables the interviewer to discover what models you have developed in the past.

• While there is no correct or incorrect answer to this question, you should show your ability to work with different SDLC models by citing your past experiences.
• Show that you possess knowledge of various models, such as the iterative model, or waterfall model
• Also, you can use this question to find out more about Intuit by asking what SDLC model they utilize.

Given an array a[] of integers n. Determine the median of the elements read so far. 

Code:

import java.util.*;
class Main 
{
 //l=low and h=high
 static int binarySearch(int a[], int item, int l, int h)       
 {
   if (l >= h) 
   {
     return (item > a[l]) ? (l+ 1) : l;
   } 
  
   int mid = (l + h) / 2; 
   if (item == a[mid])
     return mid + 1;

   if (item > a[mid])
     return binarySearch(a, item, mid + 1, h);

   return binarySearch(a, item, l, mid - 1);
 }

 // Print the median of an array of integers
 static void Median(int a[], int n)
 {
   int i, j, position, num;
   int count = 1; 
   System.out.println("\nAs of reading element 1, the median is " + a[0]); 
   for (i = 1; i < n; i++) 
   {
     float median;
     j = i - 1;
     num = a[i];
     position = binarySearch(a, num, 0, j);

     while (j >= position) 
     {
       a[j + 1] = a[j];
       j--;
     }

     a[j + 1] = num;
     count++;

     if (count % 2 != 0) 
     {
       median = a[count / 2];
     }
     else 
     {
       median = (a[(count / 2) - 1] + a[count / 2]) / 2;
     }
   System.out.println("As of reading element " + (i + 1) + ", the median is " + (int)median);
   }
 }
 
 // Driver code
 public static void main (String[] args) 
 {
       Scanner sc=new Scanner(System.in); 
       System.out.println("Enter number of elements in the array: "); 
       int n= sc.nextInt(); 
       System.out.println("\nEnter elements of the array: ");  
       int[] a = new int[5];  
       for (int i = 0 ; i < n; i++ )
       {
           a[i]= sc.nextInt();    
       } 
   Median(a, n);
 }
}

Output:

Enter number of elements in the array: 
5
Enter elements of the array: 
5 
10
3
8
12
As of reading element 1, the median is 5
As of reading element 2, the median is 7
As of reading element 3, the median is 5
As of reading element 4, the median is 6
As of reading element 5, the median is 8

Distributed transactions involve a set of operations on data that occur across multiple data repositories (especially databases). The process is most often coordinated across a network of nodes, but it can also span multiple databases on one server. If you need to update related data that is distributed across several databases quickly, you will need distributed transactions.

Document Object Model, or DOM represents the API (application programming interface) for your web documents (HTML or XML documents). Every time an update is made to the application, the DOM receives an update as well, making it possible for the user to view or visualize the changes. This feature enables you to dynamically access and modifies the structure, content, and style of a document.

Every DOM object has a corresponding "virtual DOM object." Virtual DOM objects are lightweight copies of DOM objects, which can be updated without affecting the real DOM. Virtual DOM objects share the same properties as real DOM objects, but they do not possess the power to affect what appears on the screen as the real DOM does.

Generally, manipulating the real DOM is slower than manipulating the virtual DOM, since nothing gets drawn onscreen. Manipulation of the virtual DOM is akin to editing a blueprint instead of moving rooms within a real house. As soon as the Virtual DOM contains all the updates, it is compared with the real DOM, and the difference between the two is calculated.

Upon calculating the difference, the real DOM only updates those elements that have changed. The process is known as reconciliation.

Git is free, open-source software that allows members of different teams to collaborate and track project modifications. With Git, changes in the source code are tracked and multiple developers can collaborate on non-linear projects. Git keeps/saves files related to each version of a project in a repository. A Git repository is typically the .git/ folder within a project. In a repository, all changes made to files within a project are tracked and saved using a version control system.

Types of Git repositories

• Bare Repositories: Repositories are used to track modifications made by different developers. This repository cannot be modified by a user nor can a new version be created from the modifications made.
• Non-Bare Repositories: Unlike bare repositories, non-bare repositories are user-friendly and thus allow the user to make new modifications to files as well as create new repository versions. The cloning process produces a non-bare repository by default.

Upon copying the files from the repository into the local server of the user, the files can be modified and updated. Cloning involves copying existing content from a Git repository using various Git tools. Upon cloning, the user receives the repository on his local machine. Git clone command can be used to copy an existing repository into your system.

Syntax:

git clone [url] [directory]

Here,

• [url]: URL of the git repository for which you wish to clone.
• [directory]: The directory in which you wish to clone the repository.

Divide and conquer is a strategy used to solve large problems. The steps are as follows:

• Divide: Divide the given problem into smaller ones using recursion.
• Conquer: Solve each smaller subproblem using recursion. For small subproblems, solve them directly if possible.
• Combine: Solve the main problem by combining the solutions of the subproblems that are part of a recursive process.

In case the same subproblem cannot be solved multiple times, employ the divide and conquer strategy. Here are some algorithms that follow the Divide and Conquer approach:

• Quicksort
• Merge Sort
• Strassen’s Algorithm
• Binary Search
• Closest Pair of Points, etc.

Advantages of Divide and Conquer Algorithm

• For the naive method of multiplying two matrices, the complexity is O(n3), while the divide and conquer method (Strassen's matrix multiplication) has a complexity of O(n2.8074). Other problems, such as Hanoi's Tower, can also be solved this way.
• This approach is well suited to multiprocessing systems.
• Memory caches are efficiently used.

An anagram of a string is an equivalent string containing the same characters, but in a different order. An anagram is formed by arranging the characters of another string to form a new string. For example, Secure and Rescue. The characters in Secure can be arranged to form the word Rescue.

Code:

import java.util.*;
class Main 
{
 public static void main(String[] args) 
{
   String s1 = "Secure";
   String s2 = "Rescue";
   
   s1 = s1.toLowerCase();
   s2 = s2.toLowerCase();
   // Check if lengths are the same
   if(s1.length() == s2.length()) {
     // convert strings to char array
     char[] arr1 = s1.toCharArray();
     char[] arr2 = s2.toCharArray();
     // sort the array
     Arrays.sort(arr1);
     Arrays.sort(arr2);
     // If two sorted char arrays are alike, the string is anagram
     boolean result = Arrays.equals(arr1, arr2);
     if(result) 
    {
       System.out.println(s1 + " and " + s2 + " are anagram of each other.");
     }
     else {
       System.out.println(s1 + " and " + s2 + " are not anagram of each other.");
     }
   }
   else {
     System.out.println(s1 + " and " + s2 + " are not anagram of each other.");
   }
 }
}

Output:

secure and rescue are anagram of each other

Asymptotic notations are used to analyze and calculate the running time of a given algorithm. Engineers use asymptotic notation to evaluate the efficiency of their algorithms. Asymptotic notations fall into three main categories:

• Big-oh notation: This notation represents upper bound values.
• Theta notation: This notation represents average bound values.
• Big-Omega notation: This notation represents lower bound values.

Useful Resources

• Python Interview Questions
• Java Interview Questions
• Data Engineer Interview Questions
• Software Engineering Interview Questions
• Technical Interview Questions
• Coding Interview Questions
• Interview Resources
• DSA- Programming
• Mock Interview

The entire Intuit software engineer interview process involves plenty of preparation on your part. In order to assist you in the interview process, which can often be a challenging one, we have compiled this list of the top five tips that we believe you should be aware of.

• Developing a strong portfolio: When pursuing a career in software engineering, you should develop an impressive portfolio. The portfolio helps illustrate your knowledge of specific tech stacks. You are likely to be asked questions about your resume/portfolio during interviews.
• Diverse skill sets: Intuit software engineers must have diversified skill sets. As you can see, the above Intuit interview questions span a wide range of topics, such as DSA, OOP, DBMS, design patterns, SDLC, and automated frameworks, among others. Be familiar with programming and database languages. You must be familiar with a programming language, such as Python and R.
• Practice! Practice! Practice: The best thing you can do for your interviewing skills is to practice mock interviews for situational questions. Take the time to demonstrate your analytical and problem-solving skills when answering each situational question. Taking a look at past interviews will provide insight into what to expect and how to prepare for the interview.
• Showcasing your skills: Make sure your answers demonstrate your critical thinking skills and rational mindset. Providing examples is the most effective way to demonstrate your skills. It can help the hiring manager to see how your skills will contribute to the position for which you are applying. You should not simply boast about your skills, but rather explain how you applied them.
• Playing Team Player: One of the most important aspects is portraying yourself as an effective team member. So, before your interview, do some research about Intuit's products and values.

Intuit Eligibility Criteria for Software Engineers

Intuit's hiring process is dynamic and fast-paced. Upon completing the interview process, you can expect to hear back from the Inuit within one to six business days.

Intuit's interview process is fairly straightforward, with three-five rounds in general. Intuit may take up to three-four weeks to complete a job interview, depending on its complexity.

SDE1 salaries at Intuit range from ₹ 15 Lakhs to ₹ 35 Lakhs with an average of ₹ 21.2 Lakhs for less than 1 year of experience in India. Salary estimates are based on salaries received from various Intuit employees.

Answering this question reveals how committed you are to the company and how carefully you have researched it. This is your chance to demonstrate your true devotion to the organization.

• Show the recruiter that you are familiar with the company's mission and vision and that you are eager to contribute to its success.
• Mention what you like about the company's work culture or the employee development programs. You can also mention its safe learning environment, different opportunities to learn, the flexibility with the work hours, and the support you're provided with are unparalleled.
• You might mention that Intuit has been ranked 11th on Fortune's list of 100 best companies to work for.