Avantor Interview Questions and Answers

Calculate the total number of distinct paths from a given source node to all other nodes in a directed graph.

• Use dynamic programming to keep track of the number of paths from the source node to each node in the graph.

• Consider using modular arithmetic to handle large numbers and prevent overflow.

• Start by initializing the number of paths from the source node to itself as 1.

• Iterate through the edges of the graph and update the number of paths for each destination node.

• Return the...read more

Find the length of the longest path from a source cell to a destination cell in a binary matrix.

• Use depth-first search (DFS) to explore all possible paths from source to destination.

• Keep track of visited cells to avoid revisiting them.

• Return the length of the longest path found, or -1 if no path exists.

Given courses with prerequisites, determine a valid order to complete all courses.

• Use topological sorting to find a valid order of courses.

• Create a graph with courses as nodes and prerequisites as edges.

• Start with courses that have no prerequisites and remove them from the graph.

• Continue this process until all courses are taken or there are no valid courses left.

• If there is a cycle in the graph, it is impossible to complete all courses.

Merge overlapping intervals and return sorted list of merged intervals.

• Sort the intervals based on start times.

• Iterate through intervals and merge overlapping intervals.

• Return the merged intervals in sorted order.

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

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

• Then perform 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.

Given an array and an index, find the number of elements smaller than the element at that index appearing before it in the array.

• Iterate through the array up to index K and count the number of elements smaller than ARR[K].

• Return the count as the rank of ARR[K].

• Handle edge cases like empty array or invalid index K.

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with capacity constraint.

• Implement a doubly linked list to maintain the order of recently used keys.

• Use a hashmap to store key-value pairs for quick access.

• Update the order of keys in the linked list on get and put operations.

• Evict the least recently used key when the cache reaches its capacity.