20+ Zydus Lifesciences Interview Questions and Answers

Given a string with only '{' and '}', find the minimum cost to make it valid by converting brackets.

• Iterate through the string and keep track of the opening and closing brackets

• If there are more closing brackets than opening brackets, convert the excess closing brackets to opening brackets

• If there are more opening brackets than closing brackets, convert the excess opening brackets to closing brackets

• Return the total cost of conversions needed to make the string valid

Determine if each number in the array has exactly 3 factors.

• Iterate through each number in the array and check if it has exactly 3 factors.

• Factors of a number can be found by iterating from 1 to the square root of the number.

• Count the number of factors and return 1 if it is exactly 3, else return 0.

Count distinct substrings of a given string using trie data structure.

• Implement a trie data structure to store all substrings of the given string.

• Count the number of nodes in the trie to get the distinct substrings count.

• Handle empty string case separately.

• Example: For 'ab', distinct substrings are: '', 'a', 'b', 'ab'.

Implement a wildcard pattern matching algorithm to determine if a given wildcard pattern matches a text string completely.

• Create a recursive function to match the pattern with the text character by character.

• Handle cases for '?' and '*' characters separately.

• Use dynamic programming to optimize the solution.

• Check for edge cases like empty pattern or text.

Find the number with the maximum frequency in an array of integers.

• Iterate through the array and keep track of the frequency of each number using a hashmap.

• Find the number with the maximum frequency and return it.

• If multiple elements have the same maximum frequency, return the one that appears first in the array.

Find all possible paths for a rat in a maze to reach its destination.

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

• Keep track of the current path and mark visited cells to avoid loops.

• Return the paths that lead from the start position to the destination.

• Example: [[1, 0, 0], [1, 1, 0], [0, 1, 1]]

Santa needs to find the quickest path to deliver gifts in Ninja town by jumping over buildings with least travel time.

• Santa can jump to (x+1, y+1), (x+1, y), or (x, y+1) from any cell (x, y) within grid boundaries.

• The travel time between two buildings equals the absolute difference in their heights.

• Find the shortest path from (0, 0) to (N-1, M-1) using dynamic programming or Dijkstra's algorithm.

• Consider all possible paths and choose the one with the minimum total travel time...read more

Zigzag level order traversal of a binary tree alternating direction at each level.

• Use a queue to perform level order traversal of the binary tree.

• Maintain a flag to alternate the direction of traversal at each level.

• Store nodes at each level in separate lists and reverse the list if traversal direction is right to left.

Count occurrences of a digit in a given range.

• Iterate through the range [A, B] and count occurrences of digit K.

• Convert integers to strings for easier digit comparison.

• Handle edge cases like when A or B is equal to K.

Determine if a binary tree is symmetric by checking if its left and right subtrees are mirror images of each other.

• Check if the left and right subtrees of the root node are mirror images of each other

• Recursively check if the left subtree of the left child is a mirror image of the right subtree of the right child, and vice versa

• Base case: If both nodes are null, return true; If one node is null and the other is not, return false

• Example: For the input tree 1 2 2 3 4 4 3, the tr...read more

The task is to represent a binary tree in a 2-D array of strings with specific formatting rules.

• Create a 2-D array of strings with 'H' rows and odd number of columns.

• Fill in the array based on the given binary tree, following the specified formatting rules.

• Leave empty strings for unfilled cells and adjust spacing for empty subtrees.

• Ensure the output matches the example provided in the question.

The task is to identify and print every path in a binary tree whose node values sum up to a specified number 'K'.

• Traverse the binary tree to find paths with sum equal to 'K'.

• Print each valid path in the order encountered in the tree.

• Handle cases where nodes may have missing children (-1).

Given a rotated sorted array, find the index of a given integer 'K'.

• Perform binary search to find the pivot point where the array is rotated.

• Based on the pivot point, apply binary search on the appropriate half of the array to find 'K'.

• Handle cases where 'K' is not present in the array by returning -1.

The Unbounded Knapsack Problem involves maximizing profit by filling a knapsack with items of specific profit and weight.

• Iterate through each item and calculate the maximum profit that can be obtained by including or excluding the item in the knapsack.

• Use dynamic programming to store and reuse subproblem solutions to optimize the solution.

• The final answer will be the maximum profit that can be obtained by filling the knapsack with the given items.

Identify missing numbers within the range of smallest and largest elements in an array.

• Find the smallest and largest elements in the array.

• Generate a list of numbers within this range.

• Remove numbers that are present in the array.

• Sort and return the missing numbers.

Count the number of subarrays containing only 1s and 0s in a given array of 0s and 1s.

• Iterate through the array and count consecutive 1s and 0s separately.

• Use two variables to keep track of the count of 1s and 0s subarrays.

• Add the counts of 1s and 0s subarrays to get the final result.

Heap sort is a comparison-based sorting algorithm that uses a binary heap data structure to sort elements in ascending or descending order.

• Heap sort works by first building a max heap from the input array, then repeatedly removing the largest element from the heap and placing it at the end of the array.

• The complexity of heap sort is O(n log n) for both time and space, making it efficient for large datasets.

• Example: Given an array [4, 2, 7, 1, 5], after applying heap sort, the...read more