4000+ Senior Software Engineer Interview Questions and Answers

The interview questions cover a wide range of topics including software engineering, technology, design patterns, databases, web development, and more.

• The questions cover topics such as technology used, collections, streams, design patterns, dependency injection, microservices, database communication, annotations in Spring, React and JavaScript, Redux, API development, SOAP-based web services, Jenkins, Docker, production support, and more.

• Some specific questions include the d...read more

The question asks to implement a data structure called 'MapSum' with functions to initialize, insert key-value pairs, and find the sum of values with a given prefix.

• Implement a class called 'MapSum' with a constructor to initialize the data structure.

• Implement the 'insert' function to insert key-value pairs into the 'MapSum'. If a key is already present, replace its value with the new one.

• Implement the 'sum' function to find the sum of values whose key has a prefix equal to t...read more

The task is to find the Nth prime number given a number N.

• A prime number is a number greater than 1 that is not a product of two smaller natural numbers.

• Prime numbers have only two factors - 1 and the number itself.

• Start with a counter at 0 and a number at 2.

• Increment the number by 1 and check if it is prime.

• If it is prime, increment the counter.

• Repeat until the counter reaches N.

• Return the last prime number found.

Generate Pascal's triangle up to the Nth row using a 2-D list.

• Iterate through each row up to N, starting with [1] as the first row.

• Calculate each element in a row by summing the two elements directly above from the previous row.

• Append each row to the 2-D list until reaching the Nth row.

• Example: For N = 4, the output would be [ [1], [1, 1], [1, 2, 1], [1, 3, 3, 1] ]

The task is to reverse a given string containing alphanumeric and special characters.

• Iterate through the string from the last character to the first character

• Append each character to a new string to get the reversed string

• Return the reversed string as the output

Identify the duplicate integer in an array containing numbers between 1 and N-1.

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

• Return the element with a frequency greater than 1 as the duplicate integer.

• Ensure the constraints are met and a duplicate number is guaranteed to be present.

The problem involves decoding a numeric sequence into a valid string using a given mapping of characters to numbers.

• Use dynamic programming to count the number of ways to decode the sequence.

• Consider different cases for decoding single digits and pairs of digits.

• Keep track of the number of ways to decode at each position in the sequence.

• Return the final count modulo 10^9 + 7 as the answer.

Convert Excel column title to corresponding column number.

• Iterate through the characters in the input string from right to left

• Calculate the corresponding value of each character based on its position and multiply by 26^position

• Sum up all the values to get the final column number

Generate and print all prime numbers between 2 and N, inclusive.

• Iterate from 2 to N and check if each number is prime

• A prime number is only divisible by 1 and itself

• Print each prime number on a new line

SOLID principles ensure maintainable and scalable code. Dependency Injection helps in achieving loose coupling and testability.

• SOLID principles are Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion

• Dependency Injection is a design pattern that allows objects to be loosely coupled and easily testable

• Use Dependency Injection to reduce tight coupling between classes and make them more modular

• Use SOLID principles to ensure mai...read more

Given a string STR and a non-empty string PTR, find all starting indices of anagrams of PTR within STR.

• Create a frequency map of characters in PTR.

• Use sliding window technique to check anagrams in STR.

• Return the starting indices of anagrams found.

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with capacity constraint.

• 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 order of keys in the linked list whenever a key is accessed or updated.

Given an integer, find the final single-digit value after summing its digits iteratively.

• Iteratively sum the digits of the input integer until the result is a single-digit number

• Output the final single-digit integer for each test case

• Handle multiple test cases as input

Return the boundary nodes of a binary tree in Anti-Clockwise direction starting from the root node.

• Traverse the left boundary nodes in top-down order

• Traverse the leaf nodes in left-right order

• Traverse the right boundary nodes in bottom-up order

• Handle cases where duplicates occur in boundary nodes

Count the number of ways to reach target from source in a grid with 0s and 1s.

• Use dynamic programming to solve the problem efficiently.

• Traverse the grid using DFS or BFS to count the number of ways.

• Consider edge cases like when source and target are the same or when there is no path.

• Example: Given grid = [[0,0,0],[0,1,0],[0,0,0]], source = (0,0), target = (2,2), answer is 2.

• Example: Given grid = [[0,1],[0,0]], source = (0,0), target = (1,1), answer is 1.

The problem involves decoding a numeric sequence back into a valid string based on a given mapping of characters to numeric values.

• Use dynamic programming to keep track of the number of ways to decode the sequence at each position.

• Consider edge cases such as '0' and '00' which do not have valid decodings.

• Handle cases where two digits can be combined to form a valid character (e.g., '12' corresponds to 'L').

Calculate the number of bit flips required to convert one number to another in binary representation.

• Convert both numbers to binary representation

• Count the number of differing bits between the two numbers

• Output the count of differing bits as the number of bit flips required

• Example: A = 13 (1101), B = 7 (0111) -> 2 bit flips required

Create a program to count 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

Implement a function to find all starting indices of anagram substrings of a given string in another string.

• Create a frequency map of characters in the 'PTR' string.

• Use a sliding window approach to check for anagrams in 'STR'.

• Return the starting indices of anagram substrings found.

• Example: For input 'BACDGABCD' and 'ABCD', output should be [0, 5].

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.

• Keep track of the sum of each triplet and compare it with the target sum.

• Print the triplet if the sum matches the target sum, else print -1.

Implement a search function to find a specified integer in a rotated sorted array with O(logN) time complexity.

• Implement a binary search algorithm to efficiently search for the target integer.

• Handle the rotation of the array by finding the pivot point first.

• Return the index of the target integer if found, else return -1.

• Ensure the time complexity of the search function is O(logN) for each query.

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

• Remove non-alphanumeric characters from the input string before checking for palindrome.

• Use two pointers approach to compare characters from start and end of the string.

• Convert all characters to lowercase for case-insensitive comparison.

• Return true if the string is a palindrome, false otherwise.

Program to find the Nth term in an infinite series

• The series has a repeating pattern

• Use modulo operator to find the index of the repeating pattern

• Calculate the value of Nth term based on the pattern

Find the K-th largest element in a BST.

• Perform reverse in-order traversal of the BST to find the K-th largest element.

• Keep track of the count of visited nodes to determine the K-th largest element.

• Return -1 if there is no K-th largest element in the BST.

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

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.

Reverse a linked list in groups of size K by reversing nodes in each group.

• Iterate through the linked list in groups of size K

• Reverse each group of nodes

• Handle cases where the number of elements in the last group is less than K

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

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 total amount of rainwater that can be trapped in given elevation map.

• Iterate through the array to find the maximum height on the left and right of each bar.

• Calculate the amount of water that can be trapped above each bar by taking the minimum of the maximum heights on the left and right.

• Sum up the trapped water above each bar to get the total trapped water for the entire elevation map.

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.

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

• Use dynamic programming to solve this problem efficiently.

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

• Handle modulo 10^9+7 to avoid overflow issues.

• Consider base cases for 0th and 1st stair.

• Optimize the solution by using constant space instead of an array.

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

Verify if two strings are anagrams of each other by rearranging their letters.

• 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 frequencies match, else return 'False'.

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

Assigning another value to a string reference creates a new string object in memory.

• Assigning a new value to a string reference creates a new string object in memory

• The original string object remains unchanged

• The new value is stored in a different memory location

• The old value may be garbage collected if there are no other references to it

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

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

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