7000+ Software Engineer Interview Questions and Answers

Four people with different crossing times need to cross a bridge with a torch. Only two can cross at a time. What is the least time taken?

• Person A and B cross first, taking 2 minutes

• A goes back with the torch, taking 1 minute

• C and D cross together, taking 10 minutes

• B goes back with the torch, taking 2 minutes

• A and B cross together, taking 2 minutes

• Total time taken is 17 minutes

You need to take 36 turns to find a perfect pair.

• You need to pick 19 gloves to ensure a perfect pair.

• The worst case scenario is picking 18 white gloves and then the 19th glove is black.

• In that case, you need to pick 17 more gloves to find a black one and complete the pair.

Given an array of size N containing numbers from 0 to (N-2), find and return the duplicate number.

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

• Return the number with a frequency of 2.

The interview questions cover topics like encapsulation, inheritance, constructors, method overloading, overriding, exception handling, and hobbies.

• Encapsulation is the process of hiding the internal details of an object and providing access through methods.

• Inheritance is a mechanism in which one class inherits the properties and behaviors of another class.

• A constructor is a special method used to initialize objects.

• Method overloading is the ability to define multiple methods...read more

Cut the cake in half horizontally, then vertically, and finally cut each half diagonally.

• Cut the cake horizontally through the middle.

• Cut the cake vertically through the middle.

• Cut each half diagonally from corner to corner.

• Ensure each cut is made symmetrically to get 8 equal pieces.

• Example: https://www.youtube.com/watch?v=ZdGmuCJzQFo

The task is to split a binary string into beautiful substrings with equal number of 0's and 1's.

• Count the number of 0's and 1's in the string.

• Iterate through the string and split it into beautiful substrings whenever the count of 0's and 1's becomes equal.

• Return the maximum number of beautiful substrings that can be formed.

• If it is not possible to split the string into beautiful substrings, return -1.

The task is to find the Nth Fibonacci number using matrix exponentiation and return the answer modulo 10^9 + 7.

• Implement a function to find the Nth Fibonacci number using matrix exponentiation.

• Return the answer modulo 10^9 + 7 to handle large values.

• Use the formula F(n) = F(n-1) + F(n-2) with initial values F(1) = F(2) = 1.

• Optimize the solution to achieve better than O(N) time complexity.

• Consider solving the problem using dynamic programming or matrix exponentiation technique...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

The task is to find the second largest element in an array of integers.

• Iterate through the array and keep track of the largest and second largest elements.

• Initialize the largest and second largest variables with the first two elements of the array.

• Compare each element with the largest and second largest variables and update them accordingly.

• Return the second largest element at the end.

• Handle the case where no second largest element exists.

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.

• Consider using dynamic programming to optimize factorial calculation.

• Ensure to handle large values of N to prevent overflow issues.

The Knapsack Problem involves maximizing profit by choosing which items to make with limited resources.

• Understand the problem statement and constraints provided.

• Implement a dynamic programming solution to solve the Knapsack Problem efficiently.

• Iterate through the items and clay units to calculate the maximum profit that can be achieved.

• Consider both the clay requirement and profit of each item while making decisions.

• Ensure the solution runs within the given time limit of 1 se...read more

Calculate the Nth element of a modified Fibonacci series given the first two numbers and N, with the result modulo 10^9 + 7.

• Implement a function to calculate the Nth element of the series using the Fibonacci rule f(x) = f(x - 1) + f(x - 2)

• Return the answer modulo 10^9 + 7 due to the possibility of a very large result

• The series starts with the first two numbers X and Y, and the position N in the series

Determine if it is possible to divide a string into three non-empty substrings where one is a substring of the other two.

• Check if any substring of the string is a substring of the other two substrings.

• Iterate through all possible divisions of the string into three non-empty substrings.

• Use two pointers to find all possible substrings efficiently.

The problem is to find the number of ways to form a group of people such that the overall happiness of the group falls within a given range.

• Iterate through all possible subsets of the given array/list

• Calculate the sum of happiness values for each subset

• Count the number of subsets whose sum falls within the given range

Find all pairs of elements in an array that add up to a given target.

• Iterate through the array and use a hashmap to store the difference between the target and current element.

• Check if the current element exists in the hashmap, if so, print the pair.

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

Sort a list of people by their cities and states.

• Use a sorting algorithm like quicksort or mergesort.

• Create a custom comparator function that compares the city and state of each person.

• If two people belong to the same city and state, sort them by their names.

• Example: [{name: 'John', city: 'New York', state: 'NY'}, {name: 'Jane', city: 'Boston', state: 'MA'}]

• Example output: [{name: 'Jane', city: 'Boston', state: 'MA'}, {name: 'John', city: 'New York', state: 'NY'}]

Developing a real-time chat application with high scalability and low latency.

• Designing a distributed architecture to handle a large number of concurrent users.

• Implementing efficient data synchronization between multiple servers.

• Optimizing network communication to minimize latency.

• Ensuring data consistency and reliability in a distributed environment.

The error handling function copies elements from q2 back to q1 in case of an error.

• Use q_len() to get the length of the queues

• Use q_insert() and q_remove() to manipulate the queues

• Iterate through q2 and use q_insert() to copy elements back to q1

Given two numbers represented as arrays, calculate their sum and return the result as an array.

• Iterate through the arrays from right to left, adding digits and carrying over if necessary

• Handle cases where one array is longer than the other by considering the remaining digits

• Ensure the final sum array does not have any leading zeros

Reverse a given integer while excluding trailing zeros.

• Create a program to reverse the given integer by converting it to a string and then reversing it.

• Remove any trailing zeros from the reversed string before converting it back to an integer.

• Handle the constraints of the input integer being between 0 and 10^8.

• Example: For input 1230, the output should be 321.

Implement a function to compress a string by replacing consecutive characters with the character followed by the count of repetitions.

• Iterate through the input string and keep track of consecutive characters and their counts

• Replace consecutive characters with the character followed by the count of repetitions if count is greater than 1

• Return the compressed string

To solve the Set Matrix Zeros problem, we can use O(1) space by utilizing the first row and column to store information about zeros in the rest of the matrix.

• Iterate through the matrix and use the first row and column to mark rows and columns that need to be zeroed out.

• After marking, iterate through the matrix again and zero out the rows and columns based on the marks in the first row and column.

• Remember to handle the special case of the first row and column separately.

• Exampl...read more

Implement a function to return elements of a matrix in spiral order.

• Iterate through the matrix in a spiral order by adjusting boundaries as you move along.

• Keep track of the direction of movement (right, down, left, up) to traverse the matrix correctly.

• Handle edge cases like when the matrix is a single row or column separately.

Stored procedures are precompiled SQL statements that can be executed on demand, while triggers are automatically executed in response to specific events.

• Stored procedures are explicitly called by the user, while triggers are automatically invoked by the database system.

• Stored procedures can accept parameters and return values, while triggers cannot.

• Stored procedures can be executed independently, while triggers are always associated with a specific table or view.

• Stored proce...read more

Given an array of integers, remove K elements from either end to maximize sum of remaining elements.

• Iterate through all possible combinations of removing K elements from start and end

• Calculate sum of remaining elements for each combination

• Return the maximum sum obtained

Find the maximum sum of any contiguous subarray within an array in O(N) time complexity.

• Use Kadane's algorithm to find the maximum sum subarray in O(N) time complexity

• Initialize max_sum and current_sum to the first element of the array

• Iterate through the array, updating current_sum and max_sum as needed

• Return max_sum as the maximum sum of any contiguous subarray

The seven layers of networking refer to the OSI model which defines how data is transmitted over a network.

• The seven layers are: Physical, Data Link, Network, Transport, Session, Presentation, and Application.

• Each layer has a specific function and communicates with the layers above and below it.

• For example, the Physical layer deals with the physical transmission of data, while the Application layer deals with user interfaces and applications.

• Understanding the OSI model is imp...read more

Reverse a singly linked list of integers and return the head of the reversed linked list.

• Iterate through the linked list and reverse the pointers to point to the previous node instead of the next node.

• Use three pointers to keep track of the current, previous, and next nodes while reversing the linked list.

• Update the head of the reversed linked list as the last node encountered during the reversal process.

Generate all binary strings of length 'K' with no consecutive '1's in lexicographically increasing order.

• Use backtracking to generate all possible binary strings without consecutive '1's.

• Start with an empty string and recursively add '0' or '1' based on the condition.

• Keep track of the current string and its length to ensure no consecutive '1's are added.

• Sort the generated strings in lexicographically increasing order before outputting.

Merge two sorted linked lists into a single sorted linked list with constant space complexity and linear time complexity.

• Create a dummy node to start the merged list

• Compare the values of the two linked lists and append the smaller value to the merged list

• Move the pointer of the merged list and the pointer of the smaller value's linked list

• Continue this process until one of the linked lists is fully traversed

• Append the remaining elements of the other linked list to the merged ...read more

Modify a matrix by setting entire row and column to 1 if an element is 1, then count the number of 1s.

• Iterate through the matrix to find elements with value 1

• Use two arrays to keep track of rows and columns to be modified

• Update the matrix by setting entire row and column to 1 if an element is 1

• Count the number of 1s in the modified matrix

Check if a given array contains a valid triplet where two elements sum up to the third.

• Iterate through all possible triplets in the array and check if any of the conditions are satisfied.

• Use nested loops to compare each element with every other element in the array.

• Handle cases where the elements are not distinct by ensuring i != j, j != k, and i != k.

C program to find P and Q (P>Q) such that A[P] - A[Q] is maximum

• Iterate through array and keep track of maximum difference and corresponding indices

• Initialize P and Q to first two elements and update as necessary

• Time complexity: O(n)

Determine the maximum amount of money a thief can steal from houses without looting two consecutive houses.

• Create an array 'dp' to store the maximum money that can be stolen up to the i-th house.

• Iterate through the houses and update 'dp' based on whether the current house is stolen or not.

• Return the maximum value in 'dp' as the answer.

• Example: For input N=4 and values=[6, 7, 1, 30], the output should be 36.

Merge overlapping intervals and return sorted list of merged intervals.

• Identify overlapping intervals based on start and end times

• Merge overlapping intervals to form new intervals

• Sort the merged intervals in ascending order of start times

The task is to implement a wildcard pattern matching algorithm that checks if a given wildcard pattern matches a given text.

• The wildcard pattern can include the characters '?' and '*'

• '?' matches any single character

• '*' matches any sequence of characters (sequence can be of length 0 or more)

• The matching should cover the entire text, not partial text

• Implement a function that takes the wildcard pattern and the text as input and returns True if the text matches the pattern, False...read more

Check if a given matrix is idempotent by verifying if M * M equals M.

• Calculate the product of the matrix with itself and compare it with the original matrix.

• If the product equals the original matrix, then it is idempotent.

• Iterate through the matrix elements to perform the necessary calculations.

To make the red fishes 98%, 50 fishes have to be removed from the aquarium.

• Calculate 1% of 200 fishes to find out how many fishes represent 1%.

• Multiply the result by 2 to find out how many fishes represent 2%.

• Subtract the result from 200 to find out how many fishes represent 98%.

Find the maximum profit by buying and selling a stock once based on given prices.

• Iterate through the prices array and keep track of the minimum price seen so far and the maximum profit achievable.

• Calculate the profit by subtracting the current price from the minimum price and update the maximum profit if needed.

• Return the maximum profit, ensuring it is not negative.

• Example: prices = [2, 100, 150, 120], Buy at 2, sell at 150, profit = 150 - 2 = 148.

Given two arrays of strings, find and return the common elements in the order they appear in the second array.

• Iterate through the strings in the second array and check if they exist in the first array.

• Maintain a set to keep track of common elements to avoid duplicates.

• Return the common elements as a single space-separated string in the order they appear in the second array.

The question is about calculating the number of distinct ways to reach the Nth stair by climbing one or two steps at a time.

• Use dynamic programming to solve this problem efficiently.

• Define a recursive function to calculate the number of ways to reach each stair.

• Consider base cases for 0 and 1 stairs.

• Use memoization to store intermediate results and avoid redundant calculations.

• Handle large values of N by taking modulo 10^9+7 of the final result.

• Example: For N = 3, the number ...read more

Given constraints and rules, maximize vaccines administered on a specific day during a vaccination drive.

• Iterate through each test case and calculate the maximum number of vaccines administered on the specified day.

• Distribute the available vaccines evenly across the days while adhering to the rules.

• Ensure that the sum of vaccines administered does not exceed the maximum allowed.

• Maximize the vaccines administered on the specified day to meet the requirements.

Implement a function to perform topological sorting on a directed acyclic graph (DAG) and return any valid ordering.

• Create a graph representation using adjacency list or matrix

• Perform depth-first search (DFS) to find the topological ordering

• Use a stack to keep track of the ordering

• Return the ordering as an array of integers

Count the number of consonants in a given string containing uppercase and lowercase characters and spaces.

• Iterate through each character in the string and check if it is a consonant (not a vowel).

• Keep a count of the consonants encountered while iterating through the string.

• Return the total count of consonants at the end.

Detect cycle in an undirected graph by checking for a path that begins and ends at the same vertex.

• 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 visiting the same vertex twice.

• If a visited vertex is encountered that is not the parent of the current vertex, a cycle is detected.

• Return 'Yes' if a cycle is found, 'No' otherwise.

Find the row with the maximum number of 1's in a sorted 2D matrix.

• Iterate through each row of the matrix 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.

• If multiple rows have the same number of 1's, return the row with the smallest index.

The task is to find the length of the longest common subsequence between two given strings.

• Use dynamic programming to solve this problem efficiently.

• Create a 2D array to store the lengths of longest common subsequences of substrings.

• Iterate through the strings to fill the array and find the length of the longest common subsequence.

• Example: For strings 'abcde' and 'ace', the longest common subsequence is 'ace' with length 3.