1500+ Associate Software Engineer Interview Questions and Answers

The question asks to find the length of the shortest contiguous subarray that needs to be sorted in order to sort the whole array.

• Iterate through the array and find the first element that is out of order from the left side.

• Iterate through the array and find the first element that is out of order from the right side.

• Find the minimum and maximum element within the subarray from the above steps.

• Expand the subarray from both sides until all elements within the subarray are in the...read more

Yes, this can be achieved by using a two-pointer approach to rearrange the array with negative numbers at the beginning.

• Use two pointers, one starting from the beginning and one from the end of the array.

• Swap elements at the two pointers if one is negative and the other is positive, and move the pointers accordingly.

• Continue this process until the two pointers meet in the middle of the array.

• The resulting array will have all negative numbers before positive numbers, with the ...read more

The task is to identify constellations shaped like vowels within a matrix filled with characters {#, *, .}.

• Iterate through the matrix to find 3x3 constellations shaped like vowels.

• Check for vowels 'A', 'E', 'I', 'O', 'U' in each 3x3 constellation.

• Print the vowels found in each constellation for each test case.

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

• Iterate through the array and for each element, check if the target minus the element exists in a hash set.

• If it exists, print the pair (element, target-element), otherwise add the element to the hash set.

• If no pair is found, print (-1, -1).

Given a string and an integer, 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 after the...read more

Given a sorted array, find two distinct indices whose values add up to a given target.

• Use two pointers approach to find the indices that add up to the target.

• Start with one pointer at the beginning and another at the end of the array.

• Move the pointers towards each other based on the sum of their values compared to the target.

Interview questions for Associate Software Engineer position

• Be familiar with all types of database commands and their usage

• Practice writing code to reverse a given string or sentence in Java

• Be prepared to discuss major and minor projects, as well as industrial training/internship experiences

• Have a good understanding of operating system concepts such as job scheduling, deadlock, and starvation

• Know the differences between C++ and Java programming languages

• Be able to implement l...read more

The height of a binary tree is the maximum number of edges from the root to a leaf node.

• Traverse the tree recursively and keep track of the maximum height

• If the current node is null, return 0

• Otherwise, calculate the height of the left and right subtrees and return the maximum height plus 1

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

• Divide the input array into two halves recursively until each array has only one element.

• Merge the sorted halves to produce a completely sorted array.

• Time complexity of Merge Sort is O(n log n).

Remove all occurrences of a given string from a singly linked list by starting from the end of the list.

• Traverse the linked list from the end to the beginning to efficiently remove the string occurrences.

• Check for the string 'STR' in each node and remove it if found.

• Continue checking for new occurrences of 'STR' after removal to ensure all instances are removed.

• Return the head of the modified linked list after processing each test case.

Replace spaces in a string with '@40'.

• Iterate through the string and replace spaces with '@40'.

• Return the modified string for each test case.

• Handle multiple test cases by iterating through each one.

Count the number of subarrays where the number of 0s is equal to the number of 1s in a given array of 0s and 1s.

• Iterate through the array and keep track of the count of 0s and 1s encountered so far.

• Use a hashmap to store the count of 0s and 1s encountered at each index.

• For each index, check if the count of 0s and 1s encountered so far are equal. If yes, increment the total count of subarrays.

NullPointerException is a runtime exception that occurs when a program tries to access or use an object reference that is null.

• It is a common exception in Java programming.

• It is thrown when a program attempts to use an object reference that has not been initialized.

• It indicates that there is an attempt to access or invoke a method on an object that is null.

• Example: String str = null; str.length();

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

• Traverse both lists to find the lengths and the last nodes

• Align the starting points of the lists by adjusting the pointers

• Traverse again to find the merging point

The question asks to print the DFS traversal of an undirected and disconnected graph.

• Implement a Depth First Search (DFS) algorithm to traverse the graph.

• Use a visited array to keep track of visited vertices.

• For each unvisited vertex, start a DFS traversal and print the connected component.

• Sort the vertices of each connected component in ascending order before printing.

The task is to merge two sorted arrays into one sorted array.

• Create a new array with size M + N to store the merged array

• Use two pointers to iterate through the elements of ARR1 and ARR2

• Compare the elements at the current pointers and add the smaller element to the new array

• Move the pointer of the array from which the element was added

• Repeat the process until all elements are merged

• If there are remaining elements in ARR2, add them to the new array

• Return the merged array

Calculate total area covered by two overlapping rectangles on a 2-D plane.

• Calculate the area of each rectangle separately using the given coordinates.

• Find the overlapping region by determining the intersection of the two rectangles.

• Calculate the area of the overlapping region by multiplying its width and height.

• Add the areas of the two rectangles and subtract the area of the overlapping region to get the total area covered.

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.

The goal is to fill a knapsack with exactly 'M' stones, one of each color, minimizing unused capacity.

• Iterate through stones, keeping track of weights for each color

• Sort stones by weight and color, then select one stone of each color

• Calculate total weight for each combination and minimize unused capacity

• If knapsack cannot be filled, return -1

Given a singly linked list of integers, determine if a specified value exists within the list.

• Iterate through the linked list to check if the specified value exists.

• Return 1 if the value is found, else return 0.

• Handle multiple test cases by looping through each one separately.

Find the maximum sum achievable by a simple path between any two nodes in a binary tree.

• Traverse the binary tree to find all possible paths and calculate their sums.

• Keep track of the maximum sum encountered during traversal.

• Consider paths that may include the same node twice.

• Implement a recursive function to explore all paths in the tree.

• Optimize the solution to avoid redundant calculations.

Remove all vowels from a given string and return the modified string.

• Iterate through each character in the string and check if it is a vowel (a, e, i, o, u or A, E, I, O, U).

• If the character is not a vowel, add it to the modified string.

• Return the modified string after processing all characters.

The problem involves settling debts among friends by minimizing total cash flow.

• Create a graph where nodes represent friends and edges represent debts.

• Calculate the net amount each friend owes or is owed by summing up the debts and credits.

• Use a recursive algorithm to settle debts by finding the maximum and minimum amounts owed.

• Repeat the process until all debts are settled.

• Output the total cash flow required to settle all debts.

Delete a specific node from a singly linked list given the reference to the node.

• Traverse the linked list to find the node to be deleted.

• Update the pointers to skip over the node to be deleted.

• Print the modified linked list after deletion.

Implement a queue using stacks with enQueue, deQueue, peek, and isEmpty operations.

• Use two stacks to simulate a queue - one for enqueueing and one for dequeueing.

• For enQueue operation, push elements onto the enqueue stack.

• For deQueue operation, if the dequeue stack is empty, transfer 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)...read more

Swap two numbers 'a' and 'b' and output the swapped values.

• Create a temporary variable to store one of the numbers before swapping

• Swap the values of 'a' and 'b' using the temporary variable

• Output the swapped values as 'b' followed by 'a'

• Example: If 'a' = 3 and 'b' = 4, after swapping 'a' will be 4 and 'b' will be 3

Given a matrix and a non-negative integer K, find the minimum possible sum of all elements in each submatrix after performing at most K decrements.

• Iterate through all submatrices and find the minimum possible sum after performing decrements

• Keep track of the number of decrements performed on each element

• Use dynamic programming to optimize the solution

• Ensure not to decrease any number below 0

• Return the minimum possible sum modulo 10^9 + 7