1000+ Software Engineer Interview Questions and Answers for Freshers

Merge nodes between zeroes in a linked list to store the sum of included nodes.

• Traverse the linked list and keep track of sum between zeroes

• Merge nodes between zeroes by updating the sum in the merged node

• Handle edge cases like empty list or single node between zeroes

• Ensure the list starts and ends with a zero

Given a 2D array, find elements where sum of cube of digits equals element itself and return (i * i + j * j) value.

• Iterate through the 2D array and check if the sum of cube of digits equals the element itself.

• Calculate (i * i + j * j) for such elements and return the values.

• If no such element exists, return -1.

Implement a function to multiply two sparse matrices and return the resulting matrix.

• Create a function that takes two sparse matrices as input and returns the resulting matrix after multiplication.

• Iterate through the non-zero elements of the matrices to perform the multiplication efficiently.

• Ensure to handle the sparse nature of the matrices to optimize the multiplication process.

• Consider the constraints provided to ensure the function works within the specified limits.

• Test t...read more

Find the maximum sum path in a matrix from top row to bottom row by moving down or diagonally.

• Use dynamic programming to keep track of maximum sum at each cell.

• At each cell, consider the maximum sum from the cell above, left diagonal, and right diagonal.

• Add the current cell value to the maximum of the three possibilities.

• Repeat this process for all cells in the matrix to find the maximum sum path.

Detect if a singly linked list forms a cycle by checking if a node's next points back to a previous node.

• Traverse the linked list using two pointers, one moving one step at a time and the other moving two steps at a time.

• If the two pointers meet at any point, it indicates the presence of a cycle in the linked list.

• If one of the pointers reaches the end of the list (null), it means there is no cycle.

Check if two binary trees are mirrors of each other based on specific criteria.

• Compare the roots of both trees.

• Check if the left subtree of the first tree is the mirror of the right subtree of the second tree.

• Verify if the right subtree of the first tree is the mirror of the left subtree of the second tree.

Perform left rotations on an array based on given queries.

• Create a function that takes the array, number of elements, number of queries, and the queries as input.

• For each query, rotate the array by the specified number of elements to the left.

• Return the final array after each rotation query.

Calculate Pythagoras' coordinates to form a parallelogram with Euclid, Pascal, and Monte.

• Calculate the midpoint of the line segment between Euclid and Monte to get the coordinates of Pythagoras.

• Use the formula: x = x3 + (x2 - x1), y = y3 + (y2 - y1) to find Pythagoras' coordinates.

• Ensure that the coordinates of Pythagoras satisfy the conditions for forming a parallelogram.

Yes, it is possible to get the accurate result from the given data.

• The coordinates (i,j,k) where metallic balls are present can be determined by finding the set elements in both matrix1 and matrix2.

• Additional data is not required as the given data is sufficient to determine the coordinates.

• The coordinates can be obtained by iterating through the elements of matrix1 and matrix2 and checking for set elements.

Given 'N' ropes of varying lengths, find the minimum cost to connect all ropes into one single rope.

• Sort the lengths of ropes in ascending order.

• Keep connecting the two shortest ropes at each step.

• Add the cost of connecting the two ropes to the total cost.

• Repeat until all ropes are connected.

• Return the total cost as the minimum cost to connect all ropes.

The task is to find the Kth largest element from a given list of numbers for each test case.

• Read the number of test cases 'T'

• For each test case, read the number of elements 'N' and the Kth largest number to find 'K'

• Sort the array in descending order and output the Kth element

Find the minimum cost to purchase a specific weight of oranges given the cost of different weight packets.

• Iterate through the list of costs and find the minimum cost to achieve the desired weight

• Keep track of the total cost while considering available packet weights

• Return -1 if it is not possible to buy exactly the desired weight

The problem involves determining the minimum number of umbrellas required to shelter a specific number of people based on the capacity of each umbrella.

• Iterate through the array of umbrella capacities to find the combination that covers exactly 'M' people.

• Keep track of the minimum number of umbrellas used to cover 'M' people.

• If it is not possible to cover 'M' people exactly, return -1.

• Example: For input [2, 3, 4] and M=5, the minimum number of umbrellas required is 2 (2-capac...read more

The problem involves finding the number of distinct ways to climb N stairs by taking 1 or 2 steps at a time.

• Use dynamic programming to solve the problem efficiently.

• The number of ways to reach the Nth stair is the sum of the number of ways to reach the (N-1)th stair and the (N-2)th stair.

• Handle base cases for N=0 and N=1 separately.

• Consider using modulo operation to avoid overflow for large values of N.

Convert decimal numbers to octal representation.

• Iterate through each test case and use built-in functions to convert decimal to octal.

• Ensure the output is in base-8 system with digits ranging from 0 to 7.

• Handle constraints such as number of test cases and range of decimal numbers.

Find the Kth largest element in an array of distinct positive integers.

• Sort the array in non-increasing order and return the Kth element.

• Ensure all elements in the array are distinct.

• Handle multiple test cases efficiently.

The task is to find the Lowest Common Ancestor (LCA) of two nodes in a Binary Search Tree (BST).

• Traverse the BST from the root to find the LCA of nodes P and Q.

• Compare the values of nodes P and Q with the current node's value to determine the LCA.

• If both nodes are on the same side of the current node, move to that side; otherwise, the current node is the LCA.

• Example: For input 2 3 and BST 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, the LCA is node 1.

Generate a series of numbers by subtracting K from N until 0 or negative, then adding K back to reach N without using loops.

• Create a recursive function to generate the series.

• Subtract K from N until N is 0 or negative, then add K back until N is reached.

• Return the series as an array of integers.

The task is to identify all distinct triplets within an array that sum up to a specified number.

• Iterate through the array and use nested loops to find all possible triplets.

• Check if the sum of the triplet equals the specified number.

• Print the valid triplets or return -1 if no triplet exists.

Detect cycles in an undirected graph with given vertices and edges.

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

• Maintain a visited array to keep track of visited vertices and a parent array to keep track of the parent of each vertex.

• If while traversing, you encounter a visited vertex that is not the parent of the current vertex, then a cycle exists.

• Consider edge cases like disconnected graphs and self-loops.

The task is to determine the weight of the minimum spanning tree of a given connected undirected weighted graph.

• Implement Kruskal's algorithm to find the minimum spanning tree weight.

• Sort the edges based on their weights in non-decreasing order.

• Iterate through the sorted edges and add them to the MST if they don't form a cycle.

• Keep track of the total weight of the MST and return it as the output.

Find the sum of the subarray with the maximum sum among all subarrays in an array of integers.

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

• At each index, decide whether to include the current element in the subarray or start a new subarray.

• Update the maximum sum subarray if a new maximum is found.

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

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

Calculate total area covered by a list of rectangles on a plane.

• Iterate through each rectangle and calculate its area

• Check for overlapping areas between rectangles

• Sum up the total area covered by all rectangles

Design a stack that supports getMin() operation in O(1) time with O(1) extra space using inbuilt stack data structure.

• Use two stacks - one to store the actual data and another to store the minimum value at each level.

• When pushing a new element, check if it is smaller than the current minimum and update the minimum stack accordingly.

• When popping an element, also pop the top element from the minimum stack if it matches the popped element.

• For getMin() operation, simply return th...read more

Given a string and an integer K, create a new string by selecting the smallest character from the first K characters of the input string and repeating the process until the input string is empty.

• Iterate through the input string, selecting the smallest character from the first K characters each time.

• Remove the selected character from the input string and append it to the new string.

• Continue this process until the input string is empty.

• Return the final new string formed.

The output will be 5.

• Processor 1 initializes variable 'a' with a value of 10 and creates a pointer 'ptr' pointing to 'a'.

• Processor 1 writes the value of 'ptr' into 'file1' and then sleeps for 10 seconds.

• Processor 2 reads the contents of 'file1' and saves it in pointer 'p'.

• Processor 2 assigns the value 5 to the memory location pointed by 'p'.

• When Processor 1 wakes up and executes the printf statement, it will print the updated value of 'a', which is 5.

1. Cut cake in 8 pieces in minimum cuts. 2. Make 4 equilateral triangles using 6 matchsticks.

• 1. Cut cake in half horizontally and vertically. Cut each quarter diagonally.

• 2. Use 3 matchsticks to form a triangle. Use the other 3 to connect the centers of each triangle.

• Both puzzles require creative thinking and problem-solving skills.

Find the unique element in a sorted array where all other elements appear twice.

• Iterate through the array and XOR all elements to find the unique element.

• Use a hash set to keep track of elements and find the unique one.

• Sort the array and check adjacent elements to find the unique one.

Comparing 2 basketball game scenarios with different number of trials and baskets required to win

• Calculate the probability of winning in each game scenario using binomial distribution formula

• Compare the probabilities to determine which game scenario is preferable

• In game1, the probability of winning is p. In game2, the probability of winning is the sum of probabilities of making 2 or 3 baskets

• If p is high, game1 is preferable. If p is low, game2 is preferable

• For example, if p ...read more

Return the middle node of a singly linked list, considering odd and even number of 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

• Return the node pointed by the slow pointer

C code to delete a node from circular doubly linked list without deleting the head node.

• Start from the head node and traverse the list until the desired node is found.

• Update the next and previous pointers of the adjacent nodes to skip the node to be deleted.

• Free the memory allocated for the node to be deleted.

Verify if a string is a subsequence of another string by checking if characters are retained in order.

• Iterate through both strings simultaneously, checking if characters match in order.

• If a character in STR1 matches a character in STR2, move to the next character in STR2.

• If all characters in STR1 are found in STR2 in order, return True; otherwise, return False.

Yes, I am willing to learn front end and back end technologies and have a learning strategy in place.

• I believe in continuous learning and growth as a developer.

• I have experience in learning new technologies quickly and efficiently.

• My learning strategy involves breaking down concepts into smaller parts and practicing regularly.

• I also utilize online resources and seek guidance from experienced colleagues.

• Examples of technologies I have learned include React, Node.js, and MongoD...read more

Given a string with parentheses and letters, remove minimum invalid parentheses to make it valid and return all possible valid strings.

• Use BFS to explore all possible valid strings by removing parentheses one by one

• Keep track of visited strings to avoid duplicates

• Return all unique valid strings obtained after removing minimum number of parentheses

Reverse every alternate K nodes in a singly linked list of integers.

• Traverse the linked list in groups of K nodes and reverse every alternate group.

• Handle cases where the number of remaining nodes is less than K.

• Ensure to properly link the reversed groups to maintain the integrity of the linked list.

The task is to print all the root to leaf paths of an arbitrary binary tree.

• Traverse the binary tree using depth-first search (DFS) algorithm

• Maintain a current path list to keep track of the nodes in the current path

• When reaching a leaf node, add the current path to the result list

• Recursively explore the left and right subtrees

• Remove the last node from the current path after exploring each subtree

Count the number of diagonal paths in a binary tree with equal node values.

• Traverse the binary tree and keep track of diagonal paths with equal node values.

• Use recursion to explore all possible paths in the tree.

• Count the number of paths that meet the criteria of having equal node values on the diagonal.

Reorder a singly linked list so that all even-valued nodes appear before odd-valued nodes while preserving the original order.

• Create two separate linked lists for even and odd nodes

• Traverse the original list and move nodes to respective even or odd lists

• Merge the even and odd lists while maintaining the original order

Design a 2-player Tic-Tac-Toe game on an N x N grid where players place their marks to win by getting N marks in a row.

• Create a 2D array to represent the game board.

• Implement a function to check for a win after each move.

• Handle player moves and update the board accordingly.

• Return the result of each move (0, 1, or 2) based on the game state.

• Consider horizontal, vertical, and diagonal win conditions.

The task is to distribute chocolates among students such that the difference between the largest and smallest number of chocolates is minimized.

• Sort the array of chocolates packets

• Use sliding window technique to find the minimum difference between the largest and smallest number of chocolates distributed to students

• Return the minimum difference

Design a constant time data structure for key-value mappings with operations like INSERT, DELETE, SEARCH, GET, GET_SIZE, and IS_EMPTY.

• Use a hash table to achieve constant time complexity for operations.

• Implement INSERT, DELETE, SEARCH, GET, GET_SIZE, and IS_EMPTY functions.

• Ensure key is a string and value is a positive integer.

• Return appropriate results based on the operation type.

• Handle edge cases like key not found or data structure being empty.

Find nodes at a specific distance from a target node in a binary tree.

• Traverse the binary tree to find the target node.

• Perform a depth-first search to identify nodes at distance K from the target node.

• Return the values of nodes found at distance K in an array.

The question is about finding the minimum steps to reach from a source string to a destination string using three operations.

• BFS and DFS are graph traversal techniques that can be used to solve this problem.

• BFS is typically used when finding the shortest path or exploring all possible paths in a graph.

• DFS is useful when searching for a specific path or exploring deeply into a graph.

• In this case, BFS can be used to find the minimum steps to reach the destination string.

• Create ...read more

Find the node where two linked lists merge, return -1 if no merging occurs.

• Traverse both lists to find their lengths and the difference in lengths

• Move the pointer of the longer list by the difference in lengths

• Traverse both lists simultaneously until they meet at the merging node