1000+ Software Engineer Interview Questions and Answers for Freshers

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.

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.

Iterative Waterfall model was introduced to address the limitations of the traditional Waterfall model.

• Iterative Waterfall model allows for feedback and changes during the development process.

• It breaks down the development process into smaller, more manageable stages.

• It reduces the risk of project failure by identifying and addressing issues early on.

• It allows for better collaboration between developers and stakeholders.

• Examples include Rational Unified Process (RUP) and Agil...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

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'}]

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

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

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.

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.

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.

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.

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.

Find the index of the first occurrence of string A in string B.

• Iterate through string B and check if a substring of length equal to A matches A.

• Return the index of the first occurrence of A in B, or -1 if not found.

Implement Merge Sort algorithm to sort a sequence of numbers in non-descending order.

• Use Divide and Conquer approach to recursively divide the input array into two halves.

• Merge the sorted halves to produce a completely sorted array.

• Ensure the time complexity is O(n log n) for sorting.

• Handle edge cases like empty array, single element array, etc.

Reverse words in a string word by word, removing leading/trailing spaces and extra spaces between words.

• 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

Implement a Sudoku solver to fill empty slots in a 9x9 grid with numbers 1-9 satisfying constraints.

• Create a recursive function to solve the Sudoku puzzle by trying out different numbers in empty slots.

• Use backtracking to backtrack and try a different number if a conflict is encountered.

• Ensure each number appears only once per row, column, and 3x3 grid.

• Return the completed Sudoku grid as the output.

The Water Jug Problem involves determining if a specific amount of water can be measured using two jugs of different capacities.

• Start by considering the constraints and limitations of the problem.

• Think about how the operations allowed can be used to reach the target measurement.

• Consider different scenarios and test cases to come up with a solution.

• Implement a function that takes the capacities of the jugs and the target measurement as input and returns True or False based on ...read more

Generate and print all possible permutations of a given input string.

• Use recursion to generate all permutations by swapping characters in the string.

• Maintain a visited array to keep track of characters already used in a particular permutation.

• Print each permutation as it is generated.

• Handle duplicate characters by skipping swapping if the character is already in the current position.

Generate all possible valid parentheses configurations with N pairs.

• Use backtracking to generate all possible combinations of parentheses.

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

• Add '(' if there are remaining open parentheses, and add ')' if there are remaining close parentheses.

Bubble Sort is used to sort an array of non-negative integers in non-decreasing order.

• Iterate through the array and compare adjacent elements, swapping them if they are in the wrong order.

• Repeat this process until the array is sorted.

• Time complexity of Bubble Sort is O(n^2) in worst case.

• Space complexity of Bubble Sort is O(1) as it sorts the array in place.

Find the maximum difference between any two elements in an array and determine if it is even or odd.

• Iterate through the array to find the maximum and minimum elements.

• Calculate the difference between the maximum and minimum elements.

• Check if the difference is even or odd and return the result.

Identify all prime numbers less than or equal to a given positive integer N.

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

• Use the Sieve of Eratosthenes algorithm for efficient prime number identification

• Optimize by only checking up to the square root of N for divisors

The task is to determine the total number of ways to make change for a specified value using given denominations.

• Create a dynamic programming table to store the number of ways to make change for each value up to the target value.

• Iterate through each denomination and update the table accordingly based on the current denomination.

• The final value in the table will represent the total number of ways to make change for the target value.

• Consider edge cases such as when the target v...read more

The task is to find the length of the longest consecutive sequence in an unsorted array of integers.

• Sort the array to bring consecutive numbers together

• Iterate through the sorted array and keep track of the current consecutive sequence length

• Update the maximum length if a longer sequence is found

The task is to determine the minimum number of platforms needed at a railway station based on arrival and departure times of trains.

• Sort the arrival and departure times in ascending order.

• Use two pointers to track overlapping schedules.

• Increment platform count when a new train arrives before the previous one departs.

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 F(N) efficiently.

• Time complexity can be optimized to O(N) using dynamic programming.

• Example: For N = 5, the 5th Fibonacci number is 5.

Reverse a given stack of integers using recursion without using extra space or loops.

• Use recursion to pop all elements from the original stack and store them in function call stack

• Once the stack is empty, push the elements back in reverse order using recursion

• Use the top(), pop(), and push() methods to manipulate the stack

Program for Fibonacci series for n terms with user input.

• Take user input for n

• Initialize variables for first two terms of Fibonacci series

• Use a loop to generate the series up to n terms

• Print the series

4 people with different crossing times need to cross a bridge with one torch. Only 2 can cross at a time. What's the minimum time?

• The person with the longest time should always be accompanied by someone else

• The two fastest people should cross together to save time

• The torch needs to be brought back to the starting side every time two people cross

• The total time taken will be the sum of all individual crossing times

Print the left view of a binary tree given in level order form.

• Traverse the tree level by level and print the first node of each level (leftmost node).

• Use a queue to keep track of nodes at each level.

• Time complexity should be O(n) where n is the number of nodes in the tree.

Modify a boolean matrix such that if any element is 1, set its entire row and column to 1.

• Iterate through the matrix and mark rows and columns to be modified

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

• Update the matrix in-place based on the marked rows and columns

Identify the missing integer in an array of binary strings and return its binary representation without leading zeros.

• Iterate through the binary strings to convert them to integers and find the missing number using the formula for sum of integers from 0 to N.

• Calculate the sum of all integers from 0 to N using the formula (N*(N+1))/2 and subtract the sum of the integers in the array to find the missing number.

• Convert the missing integer to binary representation and return it a...read more

Given an arithmetic expression, place parentheses to maximize the value of the expression.

• Identify the operators in the expression ('+', '-', '*').

• Consider the precedence of operators to determine where to place parentheses.

• Calculate the value of the expression with different placements of parentheses to find the maximum value.

Reverse a singly linked list of integers.

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

• Keep track of the current, previous, and next nodes while traversing the list.

• Update the head of the linked list to be the last node encountered during traversal.