1000+ Software Developer Intern Interview Questions and Answers

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

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.

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 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

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.

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

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.

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.

Identify elements in an array that appear more than floor(N/3) times using efficient counting methods.

• Use a HashMap to count occurrences of each element in the array.

• Calculate the threshold as floor(N/3) to determine majority elements.

• Iterate through the HashMap to collect elements that exceed the threshold.

• Example: For array [3, 2, 3], floor(3/3) = 1, so 3 is a majority element.

• Example: For array [1, 1, 2, 2, 3, 3], floor(6/3) = 2, so 1, 2, and 3 are majority elements.

The task is to select 'N' - 1 roads in a country with 'N' states, such that the tourist bus can travel to every state at least once at minimum cost.

• The problem can be solved using a minimum spanning tree algorithm, such as Kruskal's algorithm or Prim's algorithm.

• Create a graph representation of the country using the given roads and their costs.

• Apply the minimum spanning tree algorithm to find the minimum cost roads that connect all the states.

• Print the selected roads and thei...read more

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'.

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.

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