500+ Associate Software Engineer Interview Questions and Answers for Freshers

The task is to find all distinct triplets in an array that sum up to a specified number.

• Iterate through the array and use nested loops to find all possible triplets.

• Keep track of the triplets that sum up to the target number.

• Handle cases where no triplet exists for a given target sum.

Find the intersection of two integer arrays in the order they appear in the first array.

• Iterate through the first array and store elements in a hashmap with their frequencies.

• Iterate through the second array and check if the element exists in the hashmap, decrement frequency if found.

• Return the elements that have non-zero frequencies as the intersection.

Valid password must have at least 4 characters, one numeric digit, one capital letter, no space or slash, and cannot start with a number.

• Password must be at least 4 characters long

• Password must contain at least one numeric digit

• Password must contain at least one capital letter

• Password cannot have space or slash (/)

• Password cannot start with a number

The problem is to connect N ropes of different lengths into one rope with minimum cost.

• Sort the array of rope lengths in ascending order.

• Initialize a variable to keep track of the total cost.

• While there are more than one rope remaining, take the two shortest ropes and connect them.

• Add the cost of connecting the two ropes to the total cost.

• Replace the two shortest ropes with the connected rope.

• Repeat the above steps until only one rope remains.

• Return the total cost as the mini...read more

Use a 3-way encryption method to securely send a box and key from Kolkata to Delhi.

• 1. Split the message into three parts: A, B, and C.

• 2. Encrypt part A with the recipient's public key.

• 3. Encrypt part B with the sender's public key.

• 4. Send parts A and B separately to the recipient.

• 5. Send part C unencrypted, as it contains no sensitive information.

• 6. The recipient can decrypt parts A and B using their private key and the sender's public key.

Find the smallest number whose factorial has at least N trailing zeros.

• Calculate the number of 5's in the prime factorization of the factorial to determine the trailing zeros.

• Use binary search to find the smallest number with at least N trailing zeros.

• Consider edge cases like N = 0 or N = 1 for factorial trailing zeros problem.

The task is to rearrange the given array such that every second element is greater than its left and right element.

• Read the number of test cases

• For each test case, read the number of elements in the array and the array elements

• Iterate through the array and swap elements at odd indices with their adjacent elements if necessary

• Check if the rearranged array satisfies the conditions and print 1 if it does, else print 0

Car A's speed is 90kmph

• Use the formula: Speed = Distance/Time

• Assume the distance to be the same for both cars

• Calculate Car A's time using the given information

• Substitute the values in the formula to get Car A's speed

Generate all possible combinations of balanced parentheses given the number of pairs.

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

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

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

• Example: For N = 2, valid combination...read more

Distribute chocolates among students to minimize the difference between the largest and smallest number of chocolates.

• Sort the array of chocolates packets.

• Use sliding window technique to find the minimum difference between the largest and smallest packets distributed to students.

• Return the minimum difference as the output.

Find pairs of elements in an array that sum up to a given value, sorted in a specific order.

• Iterate through the array and for each element, check if the complement (S - current element) exists in a hash set.

• If the complement exists, add the pair to the result list.

• Sort the result list based on the criteria mentioned in the problem statement.

An Armstrong number is a number that is equal to the sum of its own digits raised to the power of the number of digits.

• Iterate through each digit of the number and calculate the sum of each digit raised to the power of the total number of digits.

• Compare the calculated sum with the original number to determine if it is an Armstrong number.

• Return 'YES' if the number is an Armstrong number, 'NO' otherwise.

Calculate the sum of all numbers that can be formed using the digits 3, 4, and 5 with given constraints.

• Iterate through all possible combinations of 3, 4, and 5 based on the given constraints.

• Calculate the sum of each combination and add them up.

• Return the final sum modulo 10^9 + 7.

The question asks to find the minimum number of left shift operations required to obtain the longest common prefix of two given strings.

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

• Count the number of left shift operations required to obtain the longest common prefix

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

Find the equilibrium index of an array where sum of elements on left equals sum on right.

• Iterate through the array and calculate the total sum of all elements.

• For each index, calculate the left sum and right sum and check if they are equal.

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

To reverse a singly linked list of integers, return the head of the reversed linked list.

• Iterate through the linked list, reversing the pointers to point to the previous node instead of the next node.

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

• Update the head of the reversed linked list to be the last element of the original list.

Convert a given infix expression to postfix expression.

• Use a stack to keep track of operators and operands.

• Follow the rules of precedence for operators (*, / have higher precedence than +, -).

• Handle parentheses by pushing them onto the stack and popping when closing parenthesis is encountered.

The problem involves finding the number of distinct ways to completely cover a 2xN board using 2x1 tiles.

• Use dynamic programming to solve the tiling problem efficiently.

• Define a recursive function to calculate the number of ways to tile the board.

• Consider both horizontal and vertical placements of tiles.

• Implement the function to handle large values of N by using modulo arithmetic.

• Optimize the solution to avoid redundant calculations.

The task is to decode an encoded string back to its original form by repeating the encoded string 'count' times.

• Parse the input string to extract the count and the encoded string within the brackets

• Use recursion to decode the encoded string by repeating it 'count' times

• Handle nested encoded strings by recursively decoding them

• Output the decoded string for each test case

Return the middle node of a singly linked list, selecting the one farther from the head node in case of even number of elements.

• Traverse the linked list using two pointers, one moving twice as fast as the other.

• When the fast pointer reaches the end, the slow pointer will be at the middle node.

• Return the node pointed by the slow pointer as the middle node.

Yes, by using the super() method in the derived class.

• super() method calls the base class method

• Derived class must inherit from the base class

• Example: class Derived(Base): def method(self): super().method()

Find sum of numbers in range 1 to m (both inclusive) not divisible by n. Return difference between sum of non-divisible and divisible numbers.

• Iterate through range 1 to m and check if number is divisible by n.

• If not divisible, add to sum of non-divisible numbers.

• If divisible, add to sum of divisible numbers.

• Return difference between sum of non-divisible and divisible numbers.

The task is to find the longest distances from a source node to all nodes in a weighted directed acyclic graph.

• Implement a function that takes the number of nodes, edges, source node, and edge weights as input.

• Use a topological sorting algorithm to traverse the graph and calculate the longest distances.

• Return an array of integers where each element represents the longest distance from the source node to the corresponding node.

Calculate the N-th term of a Geometric Progression series given the first term, common ratio, and term position.

• Iterate through each test case and apply the formula A * R^(N-1) to find the N-th term

• Use modular arithmetic to handle large calculated terms by returning the result modulo 10^9 + 7

The task is to find all the different possible substrings of size two that appear in a given string as contiguous substrings.

• Iterate through the string and extract substrings of size two

• Store the substrings in an array

• Return the array of substrings

The task is to find the first repeated character in a given string of lowercase English letters.

• Iterate through the string and keep track of characters seen so far in a set.

• If a character is already in the set, return it as the first repeated character.

• If no repeated character is found, return '%'.

The problem involves finding the size of the largest subtree that is also a Binary Search Tree in a given binary tree.

• Traverse the binary tree in a bottom-up manner to check if each subtree is a BST.

• Keep track of the size of the largest BST subtree encountered so far.

• Use recursion to solve the problem efficiently.

• Consider edge cases like empty tree or single node tree.

• Example: For input 1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1, the largest BST subtree has size 3.