1000+ Software Developer Intern Interview Questions and Answers for Freshers

Find the minimum cost to reach the destination via train using given ticket costs for each pair of stations.

• Create a 2D array to store the costs from each station to the final destination.

• Use dynamic programming to calculate the minimum cost to reach each station.

• Iterate through the stations and update the minimum cost based on the previous stations.

• Return the minimum cost to reach the final station.

The task is to find the Kth permutation of the sequence of first N natural numbers.

• Generate all possible permutations of the sequence of first N natural numbers

• Sort the permutations in lexicographical order

• Return the Kth permutation from the sorted list

Find the Kth smallest and largest elements in an array.

• Sort the array and return the Kth element for smallest and (N-K+1)th element for largest.

• Use a priority queue to efficiently find the Kth smallest and largest elements.

• Handle edge cases where K is equal to 1 or N.

The task is to find the minimum number of deletions needed in a string to ensure each character appears a unique number of times.

• Iterate through the string and count the frequency of each character

• Track the frequencies in a hashmap

• Identify the characters with duplicate frequencies and calculate the minimum deletions needed

• Return the minimum number of deletions for each test case

Find the minimum distance Santa must travel to distribute 'K' gifts to 'K' different children standing in a straight line.

• Sort the array 'distance' in ascending order to simplify the problem.

• Calculate the distance between each adjacent child and find the minimum sum of distances for 'K' gifts.

• Keep track of the minimum sum of distances as you iterate through the array.

The task is to find the length of the longest increasing subsequence in a given array.

• Iterate through the array and keep track of the longest increasing subsequence length at each index.

• Use dynamic programming to store the lengths of increasing subsequences ending at each index.

• Return the maximum length from the dynamic programming array.

Given a sequence of non-negative integers representing the height of lines on a cartesian plane, find two lines that form a container with the maximum area of water.

• Use two pointers approach to find the maximum area

• Start with the widest container and gradually move the pointers towards each other

• Calculate the area at each step and update the maximum area

• The area is calculated as the minimum height of the two lines multiplied by the distance between them

The task is to determine the number of ways to paint a fence with 'N' posts using 'K' different colors, with the constraint that not more than two adjacent posts have the same color.

• Use dynamic programming to solve the problem efficiently.

• Consider the cases where the last two posts have the same color and different colors separately.

• Keep track of the number of ways to paint the fence at each post using a 2D array.

• Apply modulo 10^9 + 7 to avoid overflow issues.

• Return the final...read more

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.

The task is to determine if a given 9x9 matrix can be filled with digits 1-9 to form a valid Sudoku solution.

• Iterate through each cell in the matrix.

• For each empty cell, try filling it with a digit from 1-9 and check if it satisfies the Sudoku conditions.

• Use helper functions to check if the digit is valid in the current row, column, and sub-matrix.

• If a valid digit is found, recursively fill the next empty cell.

• If all cells are filled and the Sudoku conditions are satisfied, r...read more

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.

The problem involves finding the K maximum sum combinations from two arrays by adding one element from each array.

• Iterate through all possible sum combinations of elements from arrays A and B.

• Store the sums in a max heap to keep track of the K maximum sums.

• Pop the top K elements from the max heap to get the K maximum sum combinations.

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

The task is to count the number of inversions in an array.

• Iterate through the array and for each element, compare it with all the elements that come after it.

• If the current element is greater than any of the elements that come after it, increment the inversion count.

• Return the inversion count as the result.

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

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

Design a constant time data structure for key-value mappings with operations like INSERT, DELETE, SEARCH, GET, GET_SIZE, and IS_EMPTY.

• Use a hash table to store key-value pairs for constant time operations.

• Implement INSERT by hashing the key and storing the value at the corresponding index.

• For DELETE, simply remove the key-value pair from the hash table.

• SEARCH can be done by checking if the key exists in the hash table.

• GET retrieves the value associated with the key, returning...read more

The task is to find the lowest positive integer that does not exist in the given array of integers.

• Iterate through the array and mark the positive integers as visited using the array indices.

• Iterate through the marked array and return the index of the first unmarked element.

• If all positive integers are marked, return the length of the array + 1 as the missing positive integer.

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