100+ Full Stack Developer Interview Questions and Answers for Freshers

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

Find the Lowest Common Ancestor of two nodes in a binary tree.

• Traverse the binary tree to find the paths from the root to nodes X and Y.

• Compare the paths to find the last common node, which is the Lowest Common Ancestor.

• Implement a recursive function to find the LCA efficiently.

• Handle edge cases such as when X or Y is the root node or when X or Y is not present in the tree.

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

Find the most frequent word in a paragraph that is not in a list of banned words.

• Split the paragraph into words and convert them to uppercase for case-insensitivity.

• Count the frequency of each word, excluding banned words.

• Return the word with the highest frequency in uppercase.

Implement a function to find the index of a given integer in a singly linked list.

• Traverse the linked list while keeping track of the index of each element.

• Compare each element with the target integer 'N'.

• Return the index if the element is found, otherwise return -1.

• Handle cases where the target integer is not found in the linked list.

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.

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.

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.

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.

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.

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 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.

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 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.

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.

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

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

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.

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.

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

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