7000+ Software Developer Interview Questions and Answers

Calculate the integer square root of a given number.

• Use binary search to find the square root of the number.

• Start with a range from 0 to N, and iteratively narrow down the range until you find the integer square root.

• Return the integer part of the square root as the output.

The task is to find a string of minimal length that includes every possible string of N digits with digits ranging from 0 to K as substrings.

• Generate all possible strings of N digits with digits from 0 to K

• Concatenate these strings in a way that all are substrings of the final string

• Return 1 if the final string contains all possible strings, else return 0

Remove alternate nodes from a singly linked list of integers.

• Traverse the linked list and skip every alternate node while updating the next pointers.

• Make sure to handle cases where there are less than 3 nodes in the list.

• Update the next pointers accordingly to remove alternate nodes.

• Example: Input: 10 20 30 40 50 60 -1, Output: 10 30 50

The problem is to find the maximum number of fruits the Ninja can put in both baskets after satisfying given conditions.

• The Ninja can start at any tree and end at any tree, but cannot skip a tree.

• He can pick one fruit from each tree until he cannot, i.e., when he has to pick a fruit of the third type.

• The restriction is that each basket can have only one type of fruit.

• We need to find the maximum number of fruits that can be put in both baskets.

This question is about finding the weight of the last stone after repeatedly smashing the two heaviest stones together.

• Sort the array of stone weights in descending order.

• Repeatedly smash the two heaviest stones together until there is at most 1 stone left.

• If there is 1 stone left, return its weight. Otherwise, return 0.

Yes, the 0/1 Knapsack problem can be solved using dynamic programming with a space complexity of not more than O(W).

• Use a 1D array to store the maximum value that can be stolen for each weight from 0 to W.

• Iterate through each item and update the array based on whether including the item would increase the total value.

• The final value in the array at index W will be the maximum value that can be stolen.

Code to calculate number of bounces a ball goes through until it comes to rest.

• Use a loop to simulate the bounces until the ball stops bouncing

• Calculate the height of each bounce using the given formula

• Keep track of the number of bounces in a counter variable

The problem involves determining if a cab with a certain capacity can successfully pick up and drop off passengers at specified points for multiple trips.

• Create a function that takes in the car's capacity, number of trips, and trip details as input

• Iterate through each trip and check if the total number of passengers picked up and dropped off is within the car's capacity

• Return 'True' if all trips can be successfully completed, 'False' otherwise

Assign rooms to chess players to maximize overall focus level by minimizing distance between rooms.

• Sort the positions of rooms in ascending order.

• Calculate the distances between adjacent rooms.

• Select rooms with minimum distances to maximize overall focus level.

Count the total number of inversions in an integer array.

• Iterate through the array and for each pair of indices i and j, check if ARR[i] > ARR[j] and i < j.

• Use a nested loop to compare all pairs of elements in the array.

• Keep a count of the inversions found and return the total count at the end.

Given a string of lowercase English letters, find the first non-repeating character at each point in the stream.

• Create a hashmap to store the frequency of each character as it appears in the stream.

• Iterate through the stream and check the frequency of each character to find the first non-repeating character.

• Output the first non-repeating character at each point in the stream.

Find the sum of numbers divisible by 2 or 3 from a given list of numbers.

• Iterate through the list of numbers and check if each number is divisible by 2 or 3.

• If a number is divisible by 2 or 3, add it to the sum.

• Return the final sum as the output.

Calculate the time in minutes required to completely burn a binary tree starting from a given node.

• Traverse the tree to find the start node and calculate the time for fire to spread to all nodes.

• Use a queue to keep track of nodes to be burnt next.

• Increment time for each level of nodes burnt until the entire tree is burnt.

The Weighted Job Scheduling problem involves maximizing profit by scheduling non-overlapping jobs with start time, end time, and profit given.

• Sort the jobs based on their end times in ascending order.

• Initialize an array 'dp' to store the maximum profit that can be earned by scheduling jobs up to that index.

• For each job, find the maximum profit by either including or excluding the current job based on non-overlapping condition.

• Return the maximum profit from the 'dp' array.

• Exam...read more

Count the number of pairs in an array that satisfy a given equation.

• Iterate through all pairs of indices in the array and check if the equation is satisfied.

• Use a hashmap to store the frequency of values that can be used to form pairs.

• Optimize the solution by using two pointers approach to find pairs efficiently.

Count pairs in an array with a specific absolute difference.

• Iterate through the array and for each element, check if the element + K or element - K exists in the array.

• Use a hash set to store elements for constant time lookups.

• Keep track of the count of valid pairs found.

Calculate and return the median of all subarrays of a specified size in an integer array.

• Iterate through the array and for each subarray of size M, calculate the median.

• If the size of the subarray is even, take the average of the two middle numbers as the median.

• Return the list of medians for all subarrays of size M.

Reverse words in a string while handling leading, trailing, and multiple spaces.

• Split the input string by spaces to get individual words

• Reverse the order of the words

• Join the reversed words with a single space in between

Sort an array of 0s and 1s in linear time without using additional arrays.

• Iterate through the array and maintain two pointers, one for 0s and one for 1s.

• Swap elements at the two pointers based on the current element being 0 or 1.

• Continue this process until the entire array is sorted in place.

Minimize maximum error by splitting photos into batches of size at least 'K'.

• Sort the array of resolutions in ascending order.

• Iterate through the array and calculate the error for each possible batch.

• Return the minimum possible maximum error found.

Count the number of distinct ways to climb a staircase with a certain number of steps using either one or two steps at a time.

• Use dynamic programming to solve this problem efficiently.

• Keep track of the number of ways to reach each step by considering the number of ways to reach the previous two steps.

• Return the result modulo 10^9+7 to handle large outputs.

• Example: For N=4, the distinct ways to climb are {(0,1,2,3,4)}, {(0,1,2,4)}, {(0,2,3,4)}, {(0,1,3,4)}, and {(0,2,4)} total...read more

Create a function to determine the day of the week for any given date.

• Parse the input integers to create a date object

• Use a library or algorithm to calculate the day of the week for the given date

• Return the corresponding day of the week as a string

Find total distinct card types and common card types between two packs of cards.

• Create a set to store distinct card types when combining both packs.

• Iterate through each pack and add card types to the set.

• Find the intersection of card types between the two packs to get common card types.

Find the maximum sum of non-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 skip it.

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

• Iterate through the array and update the maximum sum at each index accordingly.

• Return the maximum sum obtained at the last index as the final resul...read more

Calculate the N-th term of a Geometric Progression series given the first term, common ratio, and term position.

• Use the formula A * R^(N-1) to find the N-th term of the GP series.

• Remember to return the result modulo 10^9 + 7 as the term can be very large.

• Handle multiple test cases efficiently by iterating through each case.

Determine if an array can be transformed into a non-decreasing array by modifying at most one element.

• Iterate through the array and check if there are more than one decreasing elements.

• If there is only one decreasing element, check if modifying it can make the array non-decreasing.

• Return true if the array can be made non-decreasing by modifying at most one element, otherwise false.

The task is to sort the elements of ARR in such a way that the relative order among the elements will be the same as those are in BRR. For the elements not present in BRR, append them in the last in sorted order.

• Create a frequency map of elements in ARR

• Iterate through BRR and for each element, append it to the result array the number of times it appears in ARR

• Iterate through the frequency map and for each element not present in BRR, append it to the result array

• Sort the resul...read more

Find a pair of indices in an array with given difference and distance constraints.

• Iterate through the array and check all possible pairs of indices to satisfy the conditions

• Use nested loops to compare each pair of indices and their corresponding elements

• Return 'valid' if a pair of indices is found that meets the conditions, otherwise return 'invalid'

The problem involves determining if there exists a triplet in an array such that the sums of specific subarrays are equal.

• Iterate through all possible triplets (i, j, k) satisfying the given conditions.

• Calculate the sum of subarrays [0, i - 1], [i + 1, j - 1], [j + 1, k - 1], [k + 1, N - 1] for each triplet.

• Check if any triplet has equal sums for the subarrays, return True if found, else False.

Calculate the total volume of water that can be trapped in a 2-D elevation map after rain.

• Iterate over the matrix and find the maximum height on the borders.

• Calculate the water trapped at each cell by finding the difference between the cell's height and the minimum of its neighboring maximum heights.

• Sum up the trapped water for all cells to get the total volume of water trapped.

What is the difference between abstract class and interface?

• 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 extend one abstract class.

• Abstract classes can have constructors, while interfaces cannot.

• Interfaces are used to achieve multiple inheritance in Java.

• Example: Abstract class - Animal, Interface - Flyable

• Example: Abstract class - Shape, Interface - Drawa...read more

The task is to print two strings in an alternating sequence by indices.

• Iterate through both strings simultaneously and append characters alternately

• Handle the case where one string is longer than the other

• Use two pointers to keep track of the current index in each string

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

• Iterate through the matrix and multiply it with itself to check if it equals the original matrix.

• If the condition M * M = M is satisfied, then the matrix is idempotent.

• If the condition is not satisfied, then the matrix is not idempotent.

Find the k-th smallest element in an unsorted array of distinct integers.

• Sort the array and return the k-th element.

• Use a priority queue or quickselect algorithm for efficient solution.

• Handle edge cases like k being out of bounds or array being empty.

Find the minimum number of fountains to activate to water the entire garden.

• Iterate through the array to find the coverage of each fountain.

• Keep track of the farthest coverage reached by activating fountains.

• Activate the fountain that covers the farthest point not yet covered.

• Repeat until the entire garden is watered.

Count the total number of palindromic substrings in a given string.

• Iterate through each character in the string and expand around it to find palindromic substrings.

• Use dynamic programming to store the results of subproblems to avoid redundant calculations.

• Consider both odd and even length palindromes while counting.

• Example: For input 'abbc', the palindromic substrings are ['a', 'b', 'b', 'c', 'bb'], totaling 5.

Calculate the sum of minimum and maximum elements of all subarrays of size K in an array.

• Iterate through the array and maintain a deque to store the indices of elements in the current window of size K.

• Keep track of the minimum and maximum elements in the current window using the deque.

• Calculate the sum of minimum and maximum elements for each subarray of size K and return the total sum.

This question is about finding the XOR of all values of nodes in the sub-tree of a given node in a tree.

• Read the input values for the number of test cases, number of nodes, and number of queries.

• Construct the tree using the given edges.

• For each query, traverse the sub-tree of the given node and calculate the XOR of all node values.

• Print the XOR values for each query.

Find the duplicate number in an array of integers from 0 to N-2.

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

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

• Alternatively, use Floyd's Tortoise and Hare algorithm to find the duplicate number in O(N) time and O(1) space.

Find the longest palindromic substring in a given string, returning the rightmost one if multiple substrings are of the same length.

• Iterate through each character in the string and expand around it to find palindromic substrings

• Keep track of the longest palindromic substring found so far

• Return the rightmost longest palindromic substring

The problem is to determine if two binary trees are flip equivalent after performing flip operations on one of the trees.

• Perform a depth-first search (DFS) on both trees simultaneously

• At each node, check if the values are equal and the left and right subtrees are either both null or both not null

• If the above conditions are met, recursively check the flip equivalence of the left and right subtrees

• If any of the conditions fail at any node, the trees are not flip equivalent

Find the fourth largest element in an array, return -2147483648 if not enough distinct elements.

• Sort the array in descending order

• Return the fourth element if it exists, else return -2147483648

Sort the individual digits of a 10 digit number.

• Convert the number to a string to access individual digits

• Use a sorting algorithm to sort the digits

• Convert the sorted digits back to a number

The task is to find the length of the longest palindromic subsequence in a given string.

• A subsequence is a sequence generated from a string after deleting some or no characters of the string without changing the order of the remaining string characters.

• A string is said to be palindrome if the reverse of the string is the same as the actual string.

• Find the longest palindromic subsequence by considering all possible subsequences of the given string.

• Use dynamic programming to ef...read more

Find the length of the longest subarray with zero sum in an array of integers.

• Iterate through the array and keep track of the running sum using a hashmap.

• If the running sum is seen before, the subarray between the current index and the previous index with the same sum is a subarray with zero sum.

• Update the length of the longest subarray with zero sum as you iterate through the array.

• Example: For arr1 = [1, -1, 3, 2, -2, -3, 3], the longest subarray with zero sum is [3, 2, -2,...read more

Reschedule at most K presentations to maximize longest gap without overlap.

• Iterate through presentations and calculate the gap between each pair of presentations

• Sort the presentations by their start times and keep track of the longest gap

• Reschedule at most K presentations to maximize the longest gap without overlap

The task is to check whether a given string is a palindrome or not, considering only alphabets and numbers and ignoring symbols and whitespaces.

• Convert the string to lowercase and remove all symbols and whitespaces.

• Reverse the modified string and compare it with the original string.

• If they are equal, then the string is a palindrome.

• If not, then the string is not a palindrome.