1500+ Software Developer Interview Questions and Answers for Freshers

Check if a given integer is a member of the Fibonacci series.

• Implement a function to check if the given number is a perfect square.

• Check if 5*N^2 + 4 or 5*N^2 - 4 is a perfect square to determine Fibonacci membership.

• Return true if the number is a perfect square of 5*N^2 + 4 or 5*N^2 - 4, otherwise false.

The maximum number of balanced binary trees possible with a given height is to be counted and printed.

• A balanced binary tree is one in which the difference between the left and right subtree heights is less than or equal to 1.

• The number of balanced binary trees can be calculated using dynamic programming.

• The number of balanced binary trees with height 'H' can be obtained by summing the product of the number of balanced binary trees for each possible left and right subtree hei...read more

The task is to find the actual order of people in a queue based on their heights and the number of taller people in front of them.

• Iterate through the given arrays and create a list of tuples containing the height and number of taller people for each person.

• Sort the list of tuples in descending order of height and ascending order of the number of taller people.

• Create an empty result list and insert each tuple into the result list at the index specified by the number of taller ...read more

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.

Calculate the minimum number of left shift operations needed to achieve the longest common prefix between two strings.

• Apply left shift operations to string B to find the longest common prefix with string A

• Count the number of left shifts needed to achieve the longest common prefix

• Return the minimum number of left shift operations for each test case

Given N meetings with start and end times, find the maximum number of meetings that can be organized in a single room without overlap.

• Sort the meetings based on their end times.

• Iterate through the sorted meetings and select the next meeting that does not overlap with the current meeting.

• Keep track of the selected meetings and return their indices in the order they are organized.

Count distinct pairs in an array whose sum equals a given target.

• Use two pointers approach to iterate through the array and find pairs with sum equal to target.

• Keep track of visited pairs to avoid counting duplicates.

• Return -1 if no such pair exists with the given target.

Generate all possible combinations of balanced parentheses for a given number of pairs.

• Use backtracking to generate all possible combinations of balanced parentheses.

• Keep track of the number of open and close parentheses used in each combination.

• Recursively generate combinations by adding open parentheses if there are remaining, and close parentheses if the number of open parentheses is greater than the number of close parentheses.

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.

• Time complexity can be optimized to O(N) using Floyd's Tortoise and Hare algorithm.

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

Implement a function to find the index of a given integer in a singly linked list.

• Traverse the linked list while keeping track of the index of each element.

• Compare each element with the target integer 'N'.

• Return the index if 'N' is found, otherwise return -1.

• Handle cases where the list is empty or 'N' is not found.

• Consider the constraints on the number of test cases and the length of the linked list.

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.

Design a seating arrangement for a high-security meeting with specific table assignments for security personnel and guests.

• Create a loop to iterate through each row from 1 to N.

• Assign tables on either end of each row to security personnel.

• For rows with only one table, assign it to security personnel.

• Display the seating arrangement with the number of people at each table.

• Example: For 4 rows, the output pattern is 1, 11, 121, 1221.

Calculate uneaten carrots by rabbits with specific jumping factors.

• Iterate through each carrot and check if any rabbit jumps on it.

• Use the jumping factors to determine which carrots will be eaten.

• Subtract the eaten carrots from the total to get the uneaten carrots.

Reverse the order of elements in an array and display the reversed array.

• Iterate through the array from both ends and swap the elements until the middle is reached.

• Use a temporary variable to store the element being swapped.

• Print the reversed array after all elements have been swapped.

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.

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

Implement a GUI to display a file structure using a linked list of nodes representing files and directories.

• Each node has properties: ID, parent ID, name, and number of children.

• The linked list maintains the order: parent directories appear before their children.

• To display children, traverse the linked list and check for matching parent IDs.

• Example: For a parent node with ID 1, find all nodes with parent ID 1 to display its children.

• Use a recursive function to handle expandin...read more

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

Determine the minimum number of conference rooms needed to schedule meetings without overlap.

• Sort the meetings by start time.

• Iterate through the meetings and keep track of the rooms in use.

• If a meeting starts after another ends, it can reuse the same room.

• If a meeting starts before another ends, a new room is needed.

• Return the maximum number of rooms in use at any point.

The task is to determine the number of possible ways to roll all the dice such that the sum of the face-up numbers equals the given 'target' sum.

• Use dynamic programming to solve the problem efficiently.

• Create a 2D array to store the number of ways to achieve each sum with the given number of dice.

• Iterate through the dice and faces to calculate the number of ways to reach each sum.

• Return the result modulo 10^9 + 7.

• Optimize the solution to use no more than O(S) extra space by u...read more

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

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.

The given string needs to be reversed word wise, keeping the individual words intact.

• Split the string into an array of words using a space as the delimiter.

• Reverse the array of words.

• Join the reversed array of words using a space as the separator to form the final reversed string.

Sort an array of 0s, 1s, and 2s in linear time complexity.

• Use three pointers to keep track of the positions of 0s, 1s, and 2s in the array.

• Iterate through the array and swap elements based on the values encountered.

• Maintain left pointer for 0s, right pointer for 2s, and current pointer for traversal.

• Example: If current element is 0, swap it with element at left pointer and increment both pointers.

Implement a program to compress a string by replacing consecutive duplicates with the count of repetitions.

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

• Replace consecutive duplicates with the count of repetitions.

• Ensure the count of repetitions is ≤ 9.

• Return the compressed string.

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.

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