1000+ Full Stack Developer Interview Questions and Answers

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.

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

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

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.

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

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

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.

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

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.

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

Given a binary tree, a target node, and an integer K, find all nodes at distance K from the target node.

• Traverse the binary tree to find the target node.

• Use BFS to traverse the tree and find nodes at distance K from the target node.

• Keep track of the distance of each node from the target node while traversing.

• Return the values of nodes at distance K in any order.

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

Rotate a square matrix by 90 degrees in an anti-clockwise direction using constant extra space.

• Iterate through each layer of the matrix from outer to inner layers

• Swap elements in groups of 4 to rotate the matrix

• Handle odd-sized matrices by adjusting the center element if needed

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