700+ Full Stack Developer Interview Questions and Answers

Given a binary matrix, perform queries to flip elements in rows/columns and count zeros in rows/columns.

• Iterate through each query and update the matrix accordingly

• For type 1 queries, flip the elements in the specified row/column

• For type 2 queries, count the number of zeros in the specified row/column

• Return the count of zeros for type 2 queries

The task is to find all duplicate elements in an array of integers.

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

• Return all elements from the hashmap with count greater than 1 as the duplicate elements.

Tower of Hanoi problem involves moving 'N' disks from one rod to another following specific rules in less than 2^N moves.

• Implement a recursive function to move disks from one rod to another while following the rules.

• Use the concept of recursion and backtracking to solve the Tower of Hanoi problem efficiently.

• Maintain a count of moves and track the movement of disks in a 2-D array/list.

• Ensure that larger disks are not placed on top of smaller disks during the movement.

• The solu...read more

Find the maximum difference between any two elements in an array and determine if it is even or odd.

• Iterate through the array to find the maximum and minimum elements

• Calculate the difference between the maximum and minimum elements

• Check if the difference is even or odd and return the result

Count the total number of set bits in the binary representation of numbers from 1 to N modulo 1e9+7.

• Iterate through numbers from 1 to N and count the set bits in their binary representation

• Use bitwise operations to count the set bits efficiently

• Return the count modulo 1e9+7 for each test case

Convert Excel sheet column title to corresponding column number.

• Iterate through the characters in the string from right to left, starting with a result of 0.

• For each character, calculate its value by subtracting 'A' and adding 1, then multiply by 26 raised to the power of its position from the right.

• Add up all the calculated values to get the final column number.

• Example: For input 'AB', A=1, B=2, so result = (1 * 26^1) + (2 * 26^0) = 28.

Determine the number of unique strings in an array by applying swapping operations on odd and even indices.

• Iterate through each string in the array and check if it can be transformed into another string by swapping characters at odd and even indices.

• Keep track of unique strings by comparing them with all other strings in the array.

• Return the count of unique strings found in the array.

Determine if it is possible to reach the destination point from the source point using specified moves.

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

• Keep track of visited points to avoid infinite loops.

• Check if the destination point is reachable by following the valid moves.

• Return true if destination is reachable, false otherwise.

Calculate the rank of a matrix based on linearly independent column or row vectors.

• Determine the number of linearly independent column vectors or row vectors in the matrix.

• Use Gaussian elimination or row reduction to simplify the matrix and find the rank.

• The rank of a matrix is the maximum number of linearly independent vectors it contains.

Find all pairs of elements in an array that add up to a given target.

• Iterate through the array and store each element in a hashmap along with its index.

• For each element, check if the target minus the element exists in the hashmap.

• If found, print the pair of elements. If not found, print (-1, -1).

Minimum number of operations to make all elements in an array equal by performing addition, subtraction, multiplication, or division.

• Iterate through the array to find the maximum and minimum elements.

• Calculate the difference between the maximum and minimum elements.

• The minimum number of operations needed is the difference between the maximum and minimum elements.

Rearrange a list of numbers such that every second element is greater than its adjacent elements.

• Iterate through the array and swap elements if needed to satisfy the condition

• Keep track of the current and next elements to compare and swap

• Ensure that the swapped elements maintain the desired order

Program to compute factorial of a given integer 'n', with error handling for negative values.

• Create a function to calculate factorial using a loop or recursion

• Check if input is negative, return 'Error' if true

• Handle edge cases like 0 and 1 separately

• Return the calculated factorial value

The task is to reverse a 32-bit signed integer and handle overflow cases.

• Create a function that takes a 32-bit signed integer as input

• Reverse the integer while handling overflow cases

• Return the reversed integer or -1 if overflow occurs

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

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

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

• Update the current node with the sum of corresponding nodes from both lists and carry

Find the maximum distance between two elements in an array where the element at the first index is less than or equal to the element at the second index.

• Iterate through the array and keep track of the minimum element encountered so far along with its index.

• Calculate the maximum distance by subtracting the current index from the index of the minimum element.

• Update the maximum distance if a greater distance is found while iterating.

• Return the maximum distance calculated.

Count substrings with exactly K distinct characters in a given lowercase string.

• Iterate through all substrings of length K and count distinct characters.

• Use a set to keep track of distinct characters in each substring.

• Increment count if number of distinct characters equals K.

The task is to find and return the indices of local minima and local maxima in the given array.

• Iterate through the array and compare each element with its neighbors to determine if it is a local minima or maxima.

• Consider corner elements separately by comparing them with only one neighbor.

• Store the indices of local minima and maxima in separate lists.

• If there are no local minima or maxima, return -1 as the only row element in the 2-D list.

The task is to find the number of distinct ways to climb from the 0th step to the Nth step, where each time you can climb either one step or two steps.

• Use dynamic programming to solve this problem

• Create an array to store the number of ways to reach each step

• Initialize the first two elements of the array as 1 and 2

• For each subsequent step, the number of ways to reach that step is the sum of the number of ways to reach the previous two steps

• Return the number of ways to reach th...read more

Determine the length of the shortest contiguous subarray that needs to be sorted to make the entire array sorted in ascending order.

• Iterate from left to right to find the first element out of order.

• Iterate from right to left to find the last element out of order.

• Calculate the length of the subarray between the two out of order elements.

Calculate the sum of all elements in an array of length N.

• Read the size of the array N and then read N integers as elements of the array.

• Iterate through the array and add each element to a running total to calculate the sum.

• Return the final sum as the output.

Find the minimum cost to make all elements of an array equal by changing them to the same value.

• Calculate the median of the array and find the sum of absolute differences between each element and the median.

• Sort the array and find the median element, then calculate the sum of absolute differences between each element and the median.

• If the array has an even number of elements, consider the average of the two middle elements as the median.

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 task is to check if one string can be converted into another string by cyclically rotating it to the right any number of times.

• Check if the lengths of the two strings are equal. If not, return 0.

• Concatenate the first string with itself and check if the second string is a substring of the concatenated string.

• If the second string is a substring, return 1. Otherwise, return 0.

To ensure accurate project estimates, I follow a structured approach that includes analyzing requirements, breaking down tasks, and considering potential risks.

• Analyze project requirements thoroughly

• Break down tasks into smaller, manageable chunks

• Consider potential risks and challenges

• Use historical data to inform estimates

• Collaborate with team members to validate estimates

Count the total number of inversions in an integer array.

• Iterate through the array and for each pair of elements, check if the inversion condition is met.

• Use a nested loop to compare each pair of elements efficiently.

• Keep a count of the inversions found and return the total count at the end.

Ceil value of a key in a Binary Search Tree (BST) is the smallest integer greater than or equal to the given number.

• Traverse the BST to find the closest integer greater than or equal to the given key.

• Compare the key with the current node value and update the ceil value accordingly.

• Recursively traverse left or right subtree based on the key value to find the ceil value.

• Return the ceil value once found for each test case.

Given a matrix with coins and empty cells, collect maximum coins from boundary cells and adjacent cells.

• Iterate through the boundary cells and collect coins from them and their adjacent cells

• Keep track of visited cells to avoid collecting the same coin multiple times

• Use depth-first search or breadth-first search to explore adjacent cells

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with a given capacity.

• Implement a doubly linked list to keep track of the order of keys based on their recent usage.

• Use a hashmap to store key-value pairs for quick access and updates.

• When capacity is reached, evict the least recently used item before inserting a new item.

• Update the position of a key in the linked list whenever it is accessed or updated.

Sort an integer array containing only 0s, 1s, and 2s in linear time complexity.

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

• Swap elements based on the values encountered to sort the array in-place.

• Time complexity should be O(N) to solve the problem efficiently.

The task is to find the total number of ways to make change for a specified value using given denominations.

• Use dynamic programming to solve this problem efficiently.

• Create a 2D array to store the number of ways to make change for each value up to the specified value.

• Iterate through the denominations and update the array based on the current denomination.

• Return the value at the last cell of the array as the final result.

Find the maximum length of a sequence of 1's by converting at most K zeroes into ones in a binary array.

• Iterate through the array and keep track of the current window of 1's and zeroes.

• Use a sliding window approach to find the maximum length of the sequence.

• Update the window by flipping zeroes to ones within the limit of K flips.

• Return the maximum length of the sequence obtained.

The N Queens Problem involves finding all possible placements of N queens on an N x N chessboard where no two queens threaten 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 valid configurations recursively and backtrack when a solution is not possible.

The task is to determine the number of islands present on a 2D grid after each query of converting water to land.

• Create a function that takes the grid dimensions, number of queries, and query coordinates as input.

• For each query, convert the water at the given coordinates to land and then count the number of islands on the grid.

• Use depth-first search (DFS) or breadth-first search (BFS) to identify connected land cells forming islands.

• Return the number of islands after each que...read more

Determine if two nodes in a binary tree are cousins based on level and parent nodes.

• Traverse the binary tree to find the levels and parents of the given nodes.

• Check if the nodes are at the same level and have different parents to determine if they are cousins.

• Return 'YES' if the nodes are cousins, 'NO' otherwise.

• Example: For input '1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1' and nodes 4 7, output is 'YES'.

The task is to determine the total number of ways to pair up 'N' friends or leave some of them single.

• Use dynamic programming to solve the problem efficiently.

• Consider the base cases when N is 1, 2, and 3 to derive the general formula.

• The result should be computed modulo 10^9 + 7 to handle large outputs.

The task is to find the Next Greater Element for each element in a list of integers.

• Iterate through the list of integers from right to left

• Use a stack to keep track of elements whose NGE is yet to be found

• Pop elements from the stack until a greater element is found or the stack is empty

• Assign the NGE as the top element of the stack or -1 if the stack is empty

This question asks for the minimum number of trampoline jumps a person needs to make in order to reach the last shop in a mall.

• The shops in the mall are laid out in a straight line and each shop has a constant value representing the maximum distance it can be jumped to.

• The person starts at shop 0 and wants to reach the last shop, shop N-1.

• If it is impossible to reach the last shop, the function should return -1.

• The function should take the number of test cases, the number of ...read more

Topological sort of a Directed Acyclic Graph (DAG) is finding an ordering of vertices where for every directed edge u -> v, u comes before v.

• Use Depth First Search (DFS) to find the topological ordering of vertices in a DAG.

• Start by visiting a vertex and recursively visit its neighbors, adding the vertex to the result after visiting all neighbors.

• Maintain a visited array to keep track of visited vertices and a stack to store the topological ordering.

• Once all vertices are visi...read more

Determine if two strings are anagrams of each other by checking if they contain the same characters.

• Create character frequency maps for both strings

• Compare the frequency of characters in both maps to check if they are anagrams

• Return True if the strings are anagrams, False otherwise

Find the third largest element in an array of distinct integers.

• Sort the array in descending order and return the element at index 2.

• Handle cases where the array has less than 3 elements separately.

• Consider edge cases like negative numbers and duplicates.

The task is to find the minimum number of characters needed to be added to the front of a string to make it a palindrome.

• Iterate through the string from both ends and count the number of characters that need to be added to make it a palindrome.

• Use two pointers approach to compare characters from start and end of the string.

• Keep track of the count of characters needed to be added to form a palindrome.

The task is to compute the modulus of the difference between the sum of nodes at odd levels and the sum of nodes at even levels in a binary tree.

• Traverse the binary tree level by level and calculate the sum of nodes at odd and even levels separately.

• Find the absolute difference between the sums and return the modulus of this difference.

• Handle null nodes by skipping them during the sum calculation.

Maximize memory usage by pairing downloads and games within memory limit 'K'.

• Sort the downloads and games in descending order.

• Iterate through the downloads and games to find the pairs within memory limit 'K'.

• Return the pairs that maximize memory usage.

Sort an array of strings based on a new alphabetical order starting with a given character.

• Iterate through the array of strings and compare each string based on the new alphabetical order starting with the given character.

• Implement a custom sorting function that considers the new alphabetical order.

• Return the sorted array of strings.

Implement Merge Sort algorithm to sort a sequence of numbers in non-descending order.

• Understand the Merge Sort algorithm which involves dividing the array into two halves, sorting each half, and then merging them back together.

• Recursively apply the Merge Sort algorithm until the size of each array is 1.

• Merge the sorted halves to produce the final sorted array.

• Ensure to handle the input constraints such as the number of test cases, elements in the array, and the range of eleme...read more

Check if two strings are permutations of each other.

• Create a character frequency map for both strings and compare them.

• If the frequency of characters in both maps is the same, return true.

• Handle edge cases like empty strings or strings of different lengths.