900+ Software Developer Intern Interview Questions and Answers for Freshers

Implement a function to delete a specific key from a Circular Linked List of integers.

• Traverse the Circular Linked List to find the key to be deleted.

• Update the pointers of the previous and next nodes to skip the node with the key.

• Handle the case where the Circular Linked List becomes empty after deletion.

• Return -1 if the Circular Linked List is empty after deletion.

Determine the state of asteroids after collisions occur.

• Iterate through the array of asteroids and simulate collisions between adjacent asteroids.

• Use a stack to keep track of remaining asteroids after collisions.

• Handle cases where asteroids moving in opposite directions collide and destroy each other.

• Handle cases where asteroids moving in the same direction do not collide.

Given an array of 0s and 1s, find the maximum count of 1s by flipping a sub-array at most once.

• Iterate through the array and keep track of the maximum count of 1s obtained by flipping a sub-array.

• Consider flipping a sub-array only when it results in increasing the count of 1s.

• Update the maximum count of 1s as you iterate through the array.

• Return the maximum count of 1s obtained after considering all possible sub-arrays.

Given an array, remove K elements from beginning or end to maximize sum of remaining elements.

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

• Calculate sum of remaining elements for each combination

• Return the maximum sum obtained

Design and implement a Least Frequently Used (LFU) Cache with put and get functionalities, handling capacity and frequency of use.

• Implement a LFU cache with put and get functions

• Handle capacity and frequency of use for eviction

• Return the value of key if present, -1 otherwise

• Consider multiple elements with least frequency, remove least recently used

• Example: Insert, update, and retrieve values based on operations

Assign subjects to friends to minimize maximum workload, find minimum time for most loaded friend.

• Sort subjects in descending order

• Assign subjects to friends one by one until all subjects are assigned

• The maximum workload will be the sum of problems assigned to the friend with the most problems

• Return the maximum workload as the minimum time required

Find the time it takes for a signal to travel from a given source node to all other nodes in a network.

• Use Dijkstra's algorithm to find the shortest path from the source node to all other nodes.

• Keep track of the minimum time taken to reach each node.

• If it is impossible for the signal to reach all nodes, return -1.

The problem involves determining if a ninja can reach the destination in a maze by moving in four directions until hitting a wall.

• Create a function that takes in the maze, starting point, and destination coordinates as input.

• Implement a recursive algorithm to explore all possible paths in the maze.

• Check if the destination can be reached from the starting point by moving in four directions.

• Return 'True' if a path exists, otherwise return 'False'.

The task is to find the total number of palindromic substrings in a given string.

• Iterate through each character in the string and consider it as the center of a potential palindrome

• Expand outwards from the center to check if the substring is a palindrome

• Count the number of palindromic substrings found

The task is to find all distinct triplets in an array that add up to zero.

• Iterate through the array and fix the first element of the triplet.

• Use two pointers approach to find the other two elements that sum up to the negative of the fixed element.

• Skip duplicate elements to avoid duplicate triplets.

• Return the list of triplets found.

Implement a queue using two stacks with enqueue and dequeue operations.

• Use two stacks to simulate a queue - one for enqueue and one for dequeue.

• For enqueue operation, push elements onto the enqueue stack.

• For dequeue operation, if dequeue stack is empty, pop all elements from enqueue stack and push onto dequeue stack.

• Return true for successful enqueue and -1 for empty dequeue.

• Example: Enqueue 10, enqueue 20, dequeue (returns 10), enqueue 30, dequeue (returns 20).

Given a jar with 'N' candies, determine the number of candies left after providing 'K' candies to a customer.

• Check if 'K' is greater than 'N', return -1 if invalid

• Subtract 'K' from 'N' to get the remaining candies

• Output the remaining candies for each test case

The task is to find the missing number in a string of consecutive nonnegative integers.

• Iterate through the string and check if each substring can form a valid number

• If a substring forms a valid number, check if it is consecutive with the previous number

• If a substring does not form a valid number or is not consecutive, it is the missing number

• Handle edge cases such as multiple missing numbers or all numbers already present

Compute the value of X raised to the power of N for given integers X and N.

• Read the number of test cases T

• For each test case, read the values of X and N

• Calculate X^N for each test case

• Print the result of X^N for each test case

The task is to simplify a given Unix-style directory path and determine the final destination.

• Replace multiple slashes with a single slash

• Handle dot (.) by ignoring it

• Handle double dot (..) by removing the previous directory from the path

• Ensure the simplified path starts with a slash and does not have a trailing slash

External CSS and JS files can be linked to HTML using the <link> and <script> tags respectively.

• Use the <link> tag with the 'rel' attribute set to 'stylesheet' to link external CSS files.

• Use the <script> tag with the 'src' attribute to link external JS files.

• Place the <link> and <script> tags within the <head> section of the HTML document.

Determine if it is possible to handle all passenger trips within the car capacity without exceeding it at any point.

• Iterate through each trip and keep track of the total number of passengers in the car at each point.

• Check if the total number of passengers exceeds the car capacity at any point, return 'False'. Otherwise, return 'True'.

Find the minimum number of elements to remove from an array to satisfy a given condition.

• Calculate the initial difference between the maximum and minimum elements in the array.

• Iterate through the array and remove elements to minimize the difference.

• Return the count of elements removed as the answer.

Given a palindrome number 'N' as a string, find the largest palindrome number strictly less than 'N'.

• Iterate from the middle towards the start and end of the number to find the next smaller palindrome.

• Handle cases where the middle digit is 0 by borrowing from adjacent digits.

• Ensure the resulting number does not have leading zeros, except when the answer is 0.

The function checks if any two intervals overlap with each other.

• Iterate through the intervals and compare the end time of one interval with the start time of the next interval.

• If the end time is greater than or equal to the start time, the intervals overlap.

• Return true if any overlapping intervals are found, otherwise return false.

Reverse a given string containing alphabets, numbers, and special characters.

• Iterate through the string from the end to the beginning and append each character to a new string.

• Use built-in functions like reverse() or slicing to reverse the string.

• Handle special characters and numbers while reversing the string.

• Ensure to consider the constraints on the input string length and number of test cases.

Given 'N' types of umbrellas with different capacities, find the minimum number of umbrellas required to shelter exactly 'M' people.

• Iterate through the umbrella capacities and try to cover 'M' people using the minimum number of umbrellas.

• Keep track of the total number of people covered and the number of umbrellas used.

• If it is not possible to cover 'M' people exactly, return -1.

• Return the minimum number of umbrellas required to shelter exactly 'M' people.

Find duplicates in an array of integers within a specified range.

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

• Return elements with count greater than 1 as duplicates.

• Time complexity can be optimized to O(N) using a HashSet to store seen elements.

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.

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

• Use dynamic programming to keep track of the number of ways to make change for each value up to the target value.

• Iterate through each denomination and update the number of ways to make change for each value based on the current denomination.

• The final answer will be the number of ways to make change for the target value.

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

Add two numbers represented by linked lists and return the head of the sum list.

• Traverse both linked lists simultaneously while keeping track of carry from previous sum

• Create a new linked list to store the sum of the two numbers

• Handle cases where one linked list is longer than the other by padding with zeros

• Update the sum and carry values accordingly while iterating through the linked lists

The task is to determine whether two given strings form an anagram pair or not.

• Anagrams are words or names that can be formed by rearranging the letters of another word

• Check if the two strings have the same characters with the same frequency

• Convert the strings to character arrays and sort them

• Compare the sorted arrays to check if they are equal

Count the number of leaf nodes in a binary tree where each node has at most two children.

• Traverse the binary tree and count nodes with both children as NULL.

• Use recursion to check each node in the tree.

• Leaf nodes have no child nodes.

• Example: For input 20 10 35 5 15 30 42 -1 13 -1 -1 -1 -1 -1 -1 -1, output should be 4.

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

• A subsequence is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.

• We can solve this problem using dynamic programming.

• Create a 2D array to store the lengths of the longest common subsequences for all possible prefixes of the two strings.

• Iterate through the strings and fill the array based on the fol...read more

Given an array of four digits, form the maximum valid 24-hour time. Return -1 if not possible.

• Iterate through all permutations of the digits to find the maximum valid time.

• Check if the time is valid (between 00:00 and 23:59) before returning.

• Handle cases where no valid time can be generated by returning -1.

Implement functions to calculate mean, median, and mode of an array of integers.

• Implement a function mean() to calculate the mean of the array by summing all elements and dividing by the total count.

• Implement a function median() to calculate the median of the array by sorting the array and finding the middle element(s).

• Implement a function mode() to find the mode of the array by counting frequencies and returning the smallest element with the highest frequency.

Find the number of starting indices from which a Ninja can reach the last stone by following specific jump rules.

• Iterate through the array and keep track of the possible jumps for each index based on the rules provided.

• Use dynamic programming or a stack to efficiently calculate the number of starting indices.

• Consider edge cases where some indices may have no possible jumps.

• Example: For the input [10, 13, 12, 14, 15], the Ninja can start from indices 0 and 1 to reach the last ...read more

Calculate and print the sum of least common multiples (LCM) for each integer from 1 to N with N.

• Iterate from 1 to N and calculate LCM of each number with N

• Sum up all the calculated LCMs to get the final result

• Implement a function to calculate LCM of two numbers

Count the number of distinct ways to climb stairs by moving either one step or two steps at a time.

• Use dynamic programming to solve the 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, ways to climb are {0,1,2,3,4}, {0,1,3,4}, {0,2,4}. Total 3 ways.

Check if a binary tree is a Partial Binary Search Tree (BST) based on specific properties.

• Traverse the tree in level order and check if each node satisfies the properties of a Partial BST.

• Use recursion to check if the left and right subtrees are also Partial BSTs.

• Compare the data of each node with its children to ensure the BST properties are maintained.

• Example: For input 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, the output should be true.

Count the number of subarrays whose combined strength matches the given enemy strength.

• Iterate through all subarrays and calculate their sum to check if it matches the enemy strength.

• Use two pointers technique to efficiently find subarrays with sum equal to the enemy strength.

• Consider edge cases like when the enemy strength is 0 or when all elements in the array are equal to the enemy strength.

Generate all possible subsequences of a given string.

• Use recursion to generate all possible subsequences by including or excluding each character in the string.

• Maintain the order of characters while generating subsequences.

• Handle base cases where the string is empty or has only one character.

• Store the generated subsequences in an array of strings.

Determine if one array is a valid stack permutation of another given array by performing push and pop operations.

• Check if the elements in the 'FIRST' array can be obtained by performing push and pop operations on the 'OTHER' array.

• Maintain a stack to simulate the push and pop operations.

• If the 'FIRST' array can be obtained, output 'YES'; otherwise, output 'NO'.

Given an array of water buckets, find the minimum liters of water to remove to make all buckets equal.

• Iterate through the array to find the maximum frequency of a water amount

• Calculate the total liters to be removed by subtracting the maximum frequency from the total number of buckets

• Return the total liters to be removed as the answer

Cloning a linked list with random pointers by creating new nodes rather than copying references.

• Create a deep copy of the linked list by iterating through the original list and creating new nodes with the same values.

• Update the random pointers of the new nodes by mapping the original node's random pointer index to the corresponding new node.

• Ensure the cloned linked list is an exact copy of the original by validating the values and random pointers.

• The cloning process can be ac...read more

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

• Use dynamic programming to check for palindromes within the string.

• Start by checking for palindromes of length 1 and 2, then expand to longer substrings.

• Keep track of the longest palindromic substring found so far and return the rightmost one if multiple substrings are of the same length.

Given a grid with type A and B people, maximize satisfaction based on neighbors.

• Start with type A people for maximum satisfaction

• Optimally place people to maximize satisfaction

• Consider satisfaction levels for each type of person and their neighbors

The task is to find the largest rectangle possible in a given histogram and return its area.

• Iterate through the histogram and maintain a stack to keep track of the indices of the bars in non-decreasing order of heights.

• For each bar, calculate the area of the rectangle that can be formed using that bar as the smallest bar.

• To calculate the area, pop the bars from the stack until a bar with a smaller height is encountered.

• The width of the rectangle will be the difference between...read more

Find the length of the longest switching subarray in a given array of positive integers.

• Iterate through the array and keep track of the longest switching subarray found so far.

• Check if the numbers at even and odd positions are identical to determine a switching subarray.

• Return the length of the longest switching subarray.

• Example: For input [1, 4, 1, 4, 3, 2, 3, 0], the longest switching subarray is [1, 4, 1, 4] with length 4.