4500+ Senior Software Engineer Interview Questions and Answers

Reverse the given string word-wise while keeping the individual words unchanged.

• Split the input string by space to get individual words

• Reverse the array of words

• Join the reversed array of words back into a single string

Implementing tumbling window in Azure Data Factory without using the feature

• Create a pipeline with a trigger that runs at the desired interval

• Use a lookup activity to retrieve the data for the current window

• Use a foreach activity to iterate over the retrieved data

• Perform the required operations on the data within the foreach activity

• Write the output to the desired destination

Design a data structure to find the kth largest number in a continuous stream of integers.

• Design a specialized data structure to handle an indefinite number of integers from the stream.

• Implement 'add(DATA)' to incorporate integers into the stream's pool.

• Implement 'getKthLargest()' to retrieve the kth largest number from the pool.

• Maintain the pool of numbers and return the kth largest number for each query.

• Ensure efficient implementation to handle large input sizes.

Calculate the Nth Fibonacci number efficiently using dynamic programming.

• Use dynamic programming to store previously calculated Fibonacci numbers to avoid redundant calculations.

• Start with base cases F(1) and F(2) as 1, then iterate to calculate subsequent Fibonacci numbers.

• Optimize the solution to have a time complexity of O(N) by storing and reusing calculated values.

Count the number of trailing zeros in the factorial of a given number.

• Calculate the number of 5's in the prime factorization of N to find the number of trailing zeros.

• Divide N by 5, then by 25, then by 125, and so on, and sum up the quotients to get the answer.

• Example: For N=10, 10/5=2, so there are 2 trailing zeros in 10!.

The task is to modify a singly linked list by reversing every alternate 'K' nodes of the linked list.

• Iterate through the linked list in groups of size K, reverse every alternate group

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

• Update the pointers accordingly to reverse the nodes in the linked list

Count the number of islands in a 2D matrix of 1s and 0s.

• Iterate through the matrix and perform depth-first search (DFS) to find connected 1s.

• Mark visited cells to avoid redundant calculations.

• Increment island count whenever a new island is encountered.

Determine if all paths from a given source node lead to a specified destination node in a directed graph.

• Check if there is at least one path from source to destination.

• Ensure that nodes with no outgoing edges from source are the destination.

• Verify that the number of paths from source to destination is finite.

• Return True if all paths from source lead to destination, otherwise False.

Determine the state of asteroids after collisions occur in a row.

• Iterate through the array of asteroids and simulate collisions between adjacent asteroids moving in opposite directions.

• If two asteroids collide, the larger one survives while the smaller one is destroyed.

• Continue this process until no more collisions can occur.

• Return the array of remaining asteroids after all collisions have been resolved.

Implement a function to perform preorder traversal on a binary tree given the root node.

• Create a recursive function to traverse the tree in preorder fashion.

• Visit the root node, then recursively traverse left subtree, followed by right subtree.

• Store the visited nodes in an array and return the array as the result.

• Example: For the input tree [1, 2, 3, 4, -1, 5, 6, -1, 7, -1, -1, -1, -1, -1, -1], the preorder traversal output should be [1, 2, 4, 7, 3, 5, 6].

Find the maximum sum of a subsequence without choosing adjacent elements in an array.

• Use dynamic programming to keep track of the maximum sum at each index, considering whether to include the current element or not.

• At each index, the maximum sum can be either the sum of the current element and the element two positions back, or the maximum sum at the previous index.

• Iterate through the array and update the maximum sum accordingly.

• Example: For the input [3, 2, 7, 10], the maxim...read more

The task is to transform a given string by selecting the smallest character from the first K characters and appending it to a new string until the original string becomes empty.

• Iterate through the string while there are characters remaining

• For each iteration, select the smallest character from the first K characters

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

• Repeat until the original string is empty

• Return the final new string

Given an unsorted array of integers, move all zeroes to the end while maintaining the order of non-zero elements.

• Iterate through the array and maintain two pointers, one for the current position and one for the position to swap with.

• If the current element is non-zero, swap it with the element at the swap pointer and increment the swap pointer.

• After iterating through the array, fill the remaining positions with zeroes.

• Example: Input array [0, 1, -2, 3, 4, 0, 5, -27, 9, 0] shou...read more

Given a string and an array of indices, reverse substrings based on the indices to obtain the final string.

• Iterate through the array of indices and reverse the substrings accordingly

• Ensure the range specified by each index is non-empty

• Return the final string after all operations are completed

Abstract class and Interface are both used for abstraction, but with some differences.

• Abstract class can have both abstract and non-abstract methods, while Interface can only have abstract methods.

• A class can implement multiple interfaces, but can only inherit from one abstract class.

• Abstract class can have instance variables, while Interface cannot.

• Abstract class provides partial implementation, while Interface provides full abstraction.

• Example of using Abstract class: Creat...read more

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.

An interface in OOP defines a contract for classes to implement, specifying methods that must be included.

• An interface contains method signatures but no implementation details.

• Classes can implement multiple interfaces in Java.

• Interfaces allow for polymorphism and loose coupling in software design.

Answering questions on .NET Core, Razor engine, and Angular

• Implemented dependency injection in .NET Core using built-in DI container or third-party libraries like Autofac or Ninject

• Used Razor engine to build dynamic views by creating Razor views with HTML and C# code to generate dynamic content

• Built single-page applications using Angular by creating components, services, and modules to manage data and UI

The task is to find all pairs of elements in an array that add up to a given target.

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

• If it exists, print the pair (current element, target - current element).

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

The task is to find the Kth largest element in 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 value of 'K'

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

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 for which the Next Greater Element is not yet found

• Pop elements from the stack until a greater element is found or the stack is empty

Generate the first 'X' terms of a series 3 * N + 2, excluding multiples of 4.

• Iterate through numbers starting from 1 and check if 3 * N + 2 is not a multiple of 4.

• Keep track of the count of terms generated and stop when 'X' terms are found.

• Return the list of terms that meet the criteria for each test case.

The interview question covers topics like hashmap implementation in Java 8, bean lifecycle, annotations in Spring framework, HTTP methods, REST API authentication, and disabling junit test cases during deployment.

• HashMap in Java 8 uses an array of linked lists to store key-value pairs, with the hash code of the key determining the index in the array.

• Bean lifecycle in Spring framework involves initialization and destruction phases, managed by the container.

• @Component and @Serv...read more

Find duplicates in an array of integers within a specified range.

• Iterate through the array and keep track of the count of each element using a hashmap.

• Return elements with count greater than 1 as duplicates.

• Handle edge cases like empty array or no duplicates found.

• Example: For input [0, 3, 1, 2, 3], output should be [3].

Answers to questions related to software engineering concepts.

• Volatile is a keyword used to indicate that a variable's value can be changed unexpectedly.

• Constant is a keyword used to indicate that a variable's value cannot be changed once it is assigned.

• Volatile and const can be used together to indicate that a variable's value cannot be changed and that it may change unexpectedly.

• ISR stands for Interrupt Service Routine and is a function that is called when an interrupt occu...read more

Find the minimum number of elements to remove from an array to make all elements distinct.

• Iterate through the array and keep track of the frequency of each element using a hashmap.

• Count the number of elements that have a frequency greater than 1, as those need to be removed.

• Return the count of elements to be removed.

Print pairs of adjacent elements in an array

• Loop through the array and print each pair of adjacent elements

• Use a for loop and access the elements using their indices

• Example: for i in 0 until a.length-1 print (a[i], a[i+1])