30+ Infosys BPM Interview Questions and Answers

Implement a function to determine the 'Count and Say' sequence after N iterations.

• Iterate through each term in the sequence, describing the previous term to generate the next term.

• Use a count to keep track of consecutive digits and append the count and digit to the result string.

• Repeat this process for N iterations to get the sequence after N iterations.

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

Reformat dates from 'Day Month Year' format to 'YYYY-MM-DD' format.

• Parse the input string to extract day, month, and year.

• Convert month to its numerical equivalent (e.g., 'Jan' to '01').

• Format the date in 'YYYY-MM-DD' format and output.

Count the number of distinct islands in a 2D array of 0s and 1s.

• Identify connected groups of 1s to form islands

• Check if islands can be translated to overlap without rotation or reflection

• Count the number of distinct islands based on the above criteria

The problem involves counting the number of distinct ways to climb N stairs by taking 1 or 2 steps at a time.

• Use dynamic programming to solve the problem efficiently.

• Define a recursive function to calculate the number of ways to reach each stair.

• Consider base cases for 0 and 1 stairs.

• Use memoization to store intermediate results and avoid redundant calculations.

• Return the result modulo 10^9+7 to handle large values.

The problem involves transforming an array into specific elements using given operations. Find the minimum number of steps required.

• Iterate through the array and calculate the number of steps needed to transform each element into the desired value

• For each element, calculate the difference between the current value and the desired value, then determine the minimum number of steps required to reach that value

• Keep track of the total number of steps needed for each test case and ...read more

Search for integers in a rotated sorted array efficiently.

• Implement binary search to find the target integer in the rotated array.

• Handle the rotation while performing binary search.

• Return the index of the target integer if found, else return -1.

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

• Use a hashmap to store the difference between the target sum and each element in the array.

• Iterate through the array and check if the current element's complement exists in the hashmap.

• Sort the pairs based on the first element and then the second element.

• Return the list of pairs that satisfy the sum condition.

Compare two version numbers to determine the latest version.

• Split the version numbers by '.' and compare each part from left to right.

• If a part in Version2 is greater than the corresponding part in Version1, Version2 is the latest.

• Handle cases where one version number has more parts than the other.

• Return 1 if Version1 is the latest, -1 if Version2 is the latest, and 0 if they are the same.

The problem involves determining the number of ways to partition a number into non-empty groups with specific constraints.

• Use dynamic programming to solve the problem efficiently.

• Consider the base cases when N = 0 or K = 0.

• Keep track of the number of ways to partition N into K groups satisfying the given conditions.

• Apply modulo 1e9 + 7 to the final result.

• Example: For input 5 3, the output is 2 as there are 2 ways to partition 5 into 3 groups.

Given an array of candidate names and their votes, find the candidate with the maximum votes, with tiebreaker based on lexicographical order.

• Iterate through the array of candidate names and keep track of the count of each candidate's votes.

• Find the candidate with the maximum votes. If there is a tie, return the lexicographically smaller name.

• Handle multiple test cases by repeating the process for each test case.

• Output the name of the winning candidate for each test case.

Find the third largest element in an array of distinct integers.

• Sort the array in descending order and return the element at index 2.

• Alternatively, keep track of the three largest elements while iterating through the array.

• Handle cases where there are less than 3 elements in the array.

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.

• Adjust the pointers to remove the node containing 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 problem involves determining the number of page faults using the Least Recently Used (LRU) replacement algorithm.

• Page faults occur when a process accesses a memory page not currently mapped by the memory management unit.

• Page replacement algorithm like LRU is used to decide which existing page should be replaced.

• The goal is to calculate the number of page faults based on the given input sequences and memory capacity.

• Constraints include the number of test cases, number of p...read more

Find three integers in an array whose sum is closest to a given target, return the smallest sum if there are two closest sums.

• Iterate through all possible triplets in the array to find the sum closest to the target.

• Keep track of the closest sum found so far and update it if a closer sum is found.

• Return the closest sum at the end of the iteration.

Find the position of the rightmost set bit in a given number's binary representation.

• Convert the number to binary representation.

• Find the position of the rightmost set bit by counting from right to left.

• Return the position of the rightmost set bit.

Count the number of substrings consisting of only vowels in a given string.

• Iterate through all substrings of the input string.

• Check if each substring consists only of vowels.

• Increment a counter for each valid substring found.

• Return the final count as the output.

Detect if a singly linked list forms a cycle by checking if a node's next points back to a previous node.

• Traverse the linked list using two pointers, one moving one step at a time and the other moving two steps at a time.

• If the two pointers meet at any point, it indicates the presence of a cycle in the linked list.

• Use Floyd's Cycle Detection Algorithm for efficient detection of cycles in a linked list.

Calculate the number of ways to distribute items among three people with constraints.

• Start by distributing one item to each person, then distribute the remaining items to one person.

• Use combinatorics to calculate the number of ways to distribute the remaining items to one person.

• Consider edge cases like when N is less than 3 or when N is equal to 3.

• Example: For N=7, distribute 1 item to each person and then distribute the remaining 4 items to one person in 4 ways.

Count the number of islands in a 2D matrix of 1s and 0s.

• Use Depth First Search (DFS) or Breadth First Search (BFS) to traverse the matrix and identify connected groups of 1s.

• Maintain a visited array to keep track of visited cells to avoid redundant traversal.

• Increment the island count each time a new island is encountered.

• Consider edge cases like boundary conditions and handling of diagonals while traversing.

• Handle the input matrix efficiently to optimize the solution.

• Example...read more

Given N boxes with integer labels, remove M boxes to minimize distinct labels left.

• Iterate through the array and count the frequency of each label

• Sort the frequencies in descending order

• Remove M boxes with the highest frequencies to minimize distinct labels

To find and correct a bug in code, analyze problem statement, review code, use debugging tools, and test different scenarios.

• Understand the problem statement thoroughly to identify the expected behavior of the code.

• Review the code line by line to identify any syntax errors, logical errors, or potential bugs.

• Use debugging tools like breakpoints, print statements, or IDE debuggers to trace the flow of code execution.

• Test the code with different input scenarios to reproduce the ...read more

Create subarrays with sum = 0 from given array of integers.

• Iterate through the array and keep track of the running sum.

• Store the running sum in a hashmap and check if the current sum - any previous sum equals 0.

• If yes, then the subarray between those two indices has a sum of 0.

The question involves finding the pivot in a rotated sorted array using combinatorics and count sort.

• To find the pivot in a rotated sorted array, we can use a modified binary search algorithm.

• First, we compare the middle element with the first element to determine if the pivot is in the left or right half.

• Then, we continue dividing the array in half and adjusting the search range based on the pivot's location.

• Count sort is a sorting algorithm that works well when the range of...read more

The question involves finding the sum of right leaf nodes and swapping nodes in groups of k.

• The sum of right leaf nodes can be found by traversing the tree and checking if a node is a right leaf node.

• Swapping nodes in groups of k can be done by iterating through the linked list and swapping the nodes in each group.

• Examples: For the sum of right leaf nodes, consider a binary tree with nodes 1, 2, 3, 4, 5. The sum would be 5. For swapping nodes in groups of k, consider a linked...read more

The question involves reversing nodes in groups of k and finding the sum of right leaf nodes.

• Implement a function to reverse nodes in groups of k

• Traverse the reversed linked list and find the sum of right leaf nodes

• Handle edge cases like when the number of nodes is not a multiple of k