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.

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.

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.

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.

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.

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.

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

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

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.

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

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

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

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

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.

• Use a custom comparator function to sort the strings according to the new alphabetical order.

• Return the sorted array of strings.

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

Given an array of integers and a target sum, find all pairs of elements that add up to the target sum.

• Use a hashmap to store the difference between the target sum and each element as keys and their indices as values.

• Iterate through the array and check if the current element's complement exists in the hashmap.

• Return the pairs of elements that add up to the target sum in sorted order.

Check if a given string is a palindrome considering only alphanumeric characters.

• Remove non-alphanumeric characters from the input string.

• Compare the string with its reverse to check for palindrome.

• Handle edge cases like empty string or single character input.

Determine if a robot's movement path is circular on a 2D grid based on a given sequence of moves.

• Iterate through the sequence of moves and keep track of the robot's position and direction.

• Check if the robot returns to the starting position after completing the moves.

• Use a counter-clockwise rotation (L) and clockwise rotation (R) to update the direction of the robot.

• Use 'G' to move the robot one unit in the current direction.

Check if a string contains any permutation of another string as a substring.

• Iterate through str2 with a sliding window of length str1, check if any permutation of str1 is present.

• Use a hashmap to store the frequency of characters in str1 and str2 for comparison.

• If the frequencies of characters in the sliding window match the frequencies of characters in str1, return True.

Find all possible paths for a rat in a maze from start to finish, moving in 'U', 'D', 'L', 'R' directions.

• Use backtracking to explore all possible paths in the maze.

• Keep track of visited cells to avoid loops.

• Recursively try moving in all directions and backtrack when reaching dead ends.

• Return the valid paths in alphabetical order as an array of strings.

Account Statements Transcription is a full stack application for converting Excel sheets to SQL tables, fetching data in UI, and allowing downloads in various formats.

• Create a front-end interface for users to upload Excel sheets

• Develop a back-end system to convert Excel data into SQL tables

• Implement a query system to fetch data based on user needs in the UI

• Provide options for users to download data in Excel or Word formats