700+ Full Stack Developer Interview Questions and Answers

Detect if an undirected graph contains a cycle by exploring all possible paths.

• Use Depth First Search (DFS) to traverse the graph and detect cycles.

• Maintain a visited set to keep track of visited vertices and a parent pointer to avoid revisiting the same vertex.

• If a visited vertex is encountered that is not the parent of the current vertex, a cycle is present.

• Check for cycles in each connected component of the graph.

• Example: For input N=3, Edges=[[1, 2], [2, 3], [1, 3]], the ...read more

Find the longest common prefix among an array of strings.

• Iterate through the strings character by character to find the longest common prefix

• Use a loop to compare characters of all strings at the same index

• Return the prefix once a character mismatch is found

Find the minimum number of arrows needed to burst all balloons by shooting arrows from left to right.

• Sort the array in ascending order to make it easier to determine the minimum number of arrows needed.

• Iterate through the sorted array and count the number of times the height decreases.

• The count of height decreases plus 1 gives the minimum number of arrows needed to burst all balloons.

The task is to determine the number of distinct islands in a grid of 0s and 1s connected horizontally, vertically, or diagonally.

• Iterate through the grid and perform depth-first search (DFS) to find connected '1's forming islands.

• Use a set to keep track of visited cells to avoid counting the same island multiple times.

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

• Consider edge cases such as grid boundaries and handling '0's as water.

• Implement a recursive DF...read more

Implement a queue using stacks following FIFO principle.

• Use two stacks to simulate a queue - one for enqueue and one for dequeue operations.

• For enQueue operation, push elements onto the enqueue stack.

• For deQueue operation, if the dequeue stack is empty, pop all elements from enqueue stack to dequeue stack.

• For peek operation, return the top element of the dequeue stack.

• For isEmpty operation, check if both stacks are empty.

• Example: enQueue(5), enQueue(10), peek() -> 5, deQueue(...read more

Find the shortest path in a binary matrix from a source cell to a destination cell consisting only of 1s.

• Use Breadth First Search (BFS) algorithm to find the shortest path.

• Keep track of visited cells to avoid revisiting them.

• Calculate the path length by counting the number of 1s in the path.

• Handle edge cases such as invalid inputs and unreachable destination.

Implement a function to find the square root of a number with a given precision.

• Create a function that takes 'N' and 'D' as input parameters

• Use a mathematical algorithm like Newton's method to approximate the square root

• Iterate until the precision condition is met

• Return the square root with the required precision

Calculate and print the factorial of a given integer 'N'.

• Iterate from 1 to N and multiply each number to calculate factorial

• Handle edge cases like N=0 or N=1 separately

• Use recursion to calculate factorial efficiently

Find the maximum sum of products for array rotations.

• Iterate through all possible rotations of the array and calculate the sum of products for each rotation.

• Keep track of the maximum sum of products found so far.

• Return the maximum sum of products obtained.

Find the Lowest Common Ancestor (LCA) of two nodes in a Binary Search Tree (BST).

• Traverse the BST from the root node to find the LCA of the given nodes.

• Compare the values of the nodes with the values of P and Q to determine the LCA.

• If the values of P and Q are on opposite sides of the current node, then the current node is the LCA.

The task is to find the maximum amount of money Mr. X can rob from houses arranged in a circle without alerting the police.

• The problem can be solved using dynamic programming.

• Create two arrays to store the maximum amount of money robbed when considering the first house and when not considering the first house.

• Iterate through the array and update the maximum amount of money robbed at each house.

• The final answer will be the maximum of the last element in both arrays.

Sort elements of ARR to match relative order in BRR, append missing elements at the end in sorted order.

• Create a hashmap to store the index of elements in BRR for quick lookup.

• Sort elements in ARR based on their index in BRR, append missing elements at the end.

• Handle edge cases like empty arrays or duplicate elements in ARR and BRR.

The Word Ladder problem involves finding the shortest transformation sequence from one word to another by changing one letter at a time.

• Use breadth-first search to find the shortest transformation sequence.

• Create a graph where each word is a node and words that can be transformed into each other are connected.

• Keep track of visited words to avoid cycles and optimize the search process.

• Return -1 if no transformation sequence is possible.

• Example: For input 'hit', 'cog', and dict...read more

Insert an element into an AVL tree while maintaining balance.

• Ensure the AVL tree remains balanced after insertion by performing rotations if necessary.

• Update the height of each node after insertion to maintain the AVL property.

• Perform single or double rotations based on the balance factor of the nodes.

• Example: Inserting 7 into the AVL tree shown in the image would require a double rotation to balance the tree.

The task is to transform an integer array into a max binary heap structure.

• Create a max heap from the given array by rearranging elements

• Ensure each internal node has a value greater than or equal to its children

• Check if the transformed array represents a max-heap and output 1 if true, 0 if false

Create a program that counts lowercase alphabets, digits, and white spaces from user input until '$' is encountered.

• Read characters from input stream until '$' is encountered

• Count lowercase alphabets, digits, and white spaces separately

• Print the counts of each character type as three integers separated by spaces

Divide two integers without using multiplication, division, and modular operators, returning the floored value of the quotient.

• Implement division using bit manipulation and subtraction

• Handle edge cases like negative numbers and overflow

• Return the floored value of the quotient

Group anagrams in a list of strings together and return each group as a list of strings.

• Iterate through the list of strings and sort each string alphabetically to create a key for grouping.

• Use a hashmap to store the sorted string as key and the original string as value.

• Return the values of the hashmap as the grouped anagrams.

Find the maximum sum of a contiguous subarray within an array of integers.

• Iterate through the array and keep track of the maximum sum of subarrays seen so far.

• Use Kadane's algorithm to efficiently find the maximum subarray sum.

• Consider edge cases like all negative numbers in the array.

• Example: For input [-2, 1, -3, 4, -1], the maximum subarray sum is 4.

The minimum number of swaps required to sort a given array of distinct elements in ascending order.

• Use a hashmap to store the original indices of the elements in the array.

• Iterate through the array and swap elements to their correct positions.

• Count the number of swaps needed to sort the array.

Given a string, rearrange its characters so that no two adjacent characters are the same. Return 'Yes' if possible, 'No' otherwise.

• Iterate through the string and count the frequency of each character

• Use a priority queue to rearrange characters based on frequency

• Check if the rearranged string has no two adjacent characters the same

• Return 'Yes' if possible, 'No' otherwise

The task is to determine the maximum profit that can be achieved by performing up to two buy-and-sell transactions on a given set of stock prices.

• Iterate through the array of stock prices to find the maximum profit that can be achieved by buying and selling stocks at different points.

• Keep track of the maximum profit that can be achieved by considering all possible combinations of buy and sell transactions.

• Ensure that you sell the stock before buying again to adhere to the con...read more

Construct a binary tree from preorder traversal and leaf node information.

• Create a binary tree using preorder traversal and leaf node information

• Use recursion to build the tree

• Handle both leaf and non-leaf nodes appropriately

Find the maximum area of water that can be contained between any two lines on a plane.

• Iterate through the array of heights using two pointers approach to find the maximum area.

• Calculate the area using the formula: area = (min(height[left], height[right]) * (right - left)).

• Move the pointer pointing to the smaller height towards the center to potentially find a larger area.

Count the total number of unique pairs in an array whose elements sum up to a given value.

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

• Iterate through the array and for each element, check if (Sum - current element) exists in the hashmap.

• Increment the count of pairs if the complement exists in the hashmap.

• Divide the count by 2 to avoid counting duplicates like (arr[i], arr[j]) and (arr[j], arr[i]) separately.

Find the duplicate element in an array of integers.

• Iterate through the array and keep track of the frequency of each element using a hashmap.

• Return the element with a frequency greater than 1 as the duplicate.

• Time complexity should be O(n) and space complexity should be O(n).

Find the longest palindromic substring in a given string, returning the rightmost one if multiple exist.

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

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

• Return the substring starting from the index of the longest palindrome found

Find the row with the maximum number of 1's in a grid of 0's and 1's, returning the index of the row with the most 1's.

• Iterate through each row of the grid and count the number of 1's in each row

• Keep track of the row index with the maximum number of 1's seen so far

• Return the index of the row with the maximum number of 1's

Find the Kth smallest and largest elements in an array.

• Sort the array to easily find the Kth smallest and largest elements.

• Ensure K is within the array's size to avoid errors.

• Handle multiple test cases efficiently.

• Consider edge cases like when N is small or K is at the extremes.

Find the length of the longest duplicate substring in a given string.

• Iterate through all possible substrings of the input string.

• Use a rolling hash function to efficiently compare substrings.

• Store the lengths of duplicate substrings and return the maximum length.

Find the length of the longest substring without repeating characters in a given string.

• Use a sliding window approach to keep track of the longest substring without repeating characters.

• Use a hashmap to store the index of each character in the string.

• Update the start index of the window when a repeating character is found.

• Calculate the maximum length of the window as you iterate through the string.

• Return the maximum length of the window as the result.

Move all even numbers to the beginning and odd numbers to the end of an array.

• Iterate through the array and swap even numbers to the front and odd numbers to the back.

• Use two pointers, one starting from the beginning and one from the end, to achieve the desired arrangement.

• Return the modified array with even numbers at the start and odd numbers at the end.

Find the minimum time required to rot all fresh oranges in a grid.

• Create a queue to store the rotten oranges and their time of rotting.

• Iterate through the grid to find all rotten oranges and add them to the queue.

• Simulate the rotting process by checking adjacent cells and updating their status.

• Track the time taken to rot all fresh oranges and return the result.

• Handle edge cases like unreachable fresh oranges or already rotten oranges.

Given a sorted N * N matrix, find the position of a target integer 'X'.

• Iterate over rows and columns to search for the target integer 'X'.

• Utilize the sorted nature of the matrix to optimize the search process.

• Return the position of 'X' if found, else return '-1 -1'.

Find the smallest number whose digits multiply to a given number N.

• Iterate through possible digits to form the smallest number with product equal to N

• Use a priority queue to keep track of the smallest possible number

• Check constraints to ensure the number fits in a 32-bit signed integer

Determine if one binary tree is a subtree of another binary tree based on their structure and node values.

• Traverse through the main tree and check if any subtree matches the second tree

• Use recursion to compare nodes of both trees

• Handle edge cases like empty trees or null nodes

• Check if the root node of the second tree exists in the main tree

Compute the skyline of given rectangular buildings in a 2D city, eliminating hidden lines and forming the outer contour of the silhouette.

• Iterate through the buildings to find the critical points (start and end) of each building.

• Sort the critical points based on x-coordinate and process them to find the skyline.

• Merge consecutive horizontal segments of equal height in the output to ensure no duplicates.

Validate if a given binary tree is a Binary Search Tree (BST) or not.

• Check if the left subtree of a node contains only nodes with data less than the node's data.

• Check if the right subtree of a node contains only nodes with data greater than the node's data.

• Ensure that both the left and right subtrees are also binary search trees.

• Traverse the tree in an inorder manner and check if the elements are in sorted order.

• Recursively check each node's value against the range of values ...read more

I use multiple programming languages regularly in my work.

• I use JavaScript for front-end development

• I use Python for back-end development

• I use SQL for database management

• I use Bash for automation and scripting

• I also have experience with Java and C++

Return the middle element of a singly linked list, or the one farther from the head if there are even elements.

• Traverse the linked list with two pointers, one moving twice as fast as the other

• When the fast pointer reaches the end, the slow pointer will be at the middle

• If there are even elements, return the one pointed by the slow pointer

Find pairs of elements in an array that sum up to a given value, sorted in a specific order.

• Iterate through the array and use a hashmap to store the difference between the target sum and each element.

• Check if the difference exists in the hashmap, if so, add the pair to the result list.

• Sort the result list based on the criteria mentioned in the problem statement.

Perform vertical order traversal of a binary tree based on decreasing 'Y' coordinates.

• Traverse the binary tree level by level and maintain the position of each node

• Use a map to store nodes at each position and sort them based on 'Y' coordinates

• Print the nodes in sorted order for each position to get the vertical order traversal

Modify a singly linked list to make the Kth node from the end the starting node.

• Traverse the linked list to find the length and the Kth node from the end

• Update the pointers to make the Kth node the new head of the linked list

• Adjust the pointers to maintain the integrity of the linked list

Implement a function to delete a node from a Binary Search Tree and return the inorder traversal of the modified BST.

• Understand the properties of a Binary Search Tree (BST) - left subtree contains nodes with data less than the node, right subtree contains nodes with data greater than the node.

• Implement a function to delete the given node from the BST while maintaining the BST properties.

• Perform inorder traversal of the modified BST to get the desired output.

• Handle cases where...read more

The problem involves finding the minimum time to travel from a source junction to a destination junction in a city with specified travel times and green light periods.

• Input consists of the number of test cases, number of junctions and roads, green light periods, road connections with travel times, and source/destination junctions.

• Output should be the minimum time needed from source to destination, or -1 if destination is unreachable.

• Constraints include limits on test cases, j...read more

Determine if it is possible to complete all tasks considering prerequisites.

• Create a graph representation of the tasks and dependencies.

• Use topological sorting to check if there is a cycle in the graph.

• Return 'Yes' if no cycle is found, 'No' otherwise.

Given a binary tree, print all root-to-leaf paths in order.

• Traverse the binary tree from root to leaf nodes, keeping track of the path nodes.

• Use depth-first search (DFS) to explore all possible paths.

• Return each path as a string of nodes separated by spaces.

• Handle cases where nodes have NULL values by skipping them in the path.

• Ensure the order of nodes in each path is maintained.