Mentor Graphics Interview Questions, Process, and Tips

To check if a directed graph is cyclic or not

• Use Depth First Search (DFS) algorithm to traverse the graph

• Maintain a visited set to keep track of visited nodes

• Maintain a recursion stack to keep track of nodes in the current DFS traversal

• If a node is visited and is already in the recursion stack, then the graph is cyclic

• If DFS traversal completes without finding a cycle, then the graph is acyclic

Return a random byte from a stream of bytes with equal probability.

• Create a variable to store the count of bytes read

• Create a variable to store the current random byte

• For each byte read, generate a random number between 0 and the count of bytes read

• If the random number is 0, store the current byte as the random byte

• Return the random byte

Check if a binary tree is a binary search tree or not.

• Traverse the tree in-order and check if the values are in ascending order.

• For each node, check if its value is greater than the maximum value of its left subtree and less than the minimum value of its right subtree.

• Use recursion to check if all nodes in the tree satisfy the above condition.

Algorithm to find Nth-to-Last element in a singly linked list of unknown length

• Traverse the list and maintain two pointers, one at the beginning and one at Nth node from beginning

• Move both pointers simultaneously until the second pointer reaches the end of the list

• The first pointer will be pointing to the Nth-to-Last element

• If N=0, return the last element

• Parse the list only once

Print all possible permutations of an array of integers

• Use recursion to swap elements and generate permutations

• Start with the first element and swap it with each subsequent element

• Repeat the process for the remaining elements

• Stop when all elements have been swapped with the first element

• Print each permutation as it is generated

Design a stack that prints the minimum element pushed in O(1)

• Use two stacks, one for storing elements and another for storing minimums

• When pushing an element, compare it with the top of minimum stack and push the smaller one

• When popping an element, pop from both stacks

• To get the minimum element, just return the top of minimum stack

To find the starting point of a loop in a linked list, use Floyd's cycle-finding algorithm.

• Use two pointers, one moving at twice the speed of the other.

• When they meet, move one pointer to the head of the list and keep the other at the meeting point.

• Move both pointers one step at a time until they meet again, which is the starting point of the loop.

To find a number in a matrix where all rows and columns are sorted non-decreasingly. Complexity of the solution.

• Use binary search to find the number in each row and column

• Start from the top-right corner or bottom-left corner to optimize search

• Time complexity: O(m log n) or O(n log m) depending on the starting corner

SPI and I2C are communication protocols used for connecting devices, while latch and FF are different types of sequential logic elements.

• SPI (Serial Peripheral Interface) and I2C (Inter-Integrated Circuit) are both serial communication protocols used for connecting devices in embedded systems.

• SPI uses separate lines for data input and output, while I2C uses a shared bus for both input and output.

• SPI supports higher dat...read more

To find the average speed for the whole trip, we need to know the distance and the time taken for the trip.

• Average speed = Total distance / Total time

• If the distance and time for the trip are known, the average speed can be calculated.

• If only the average speed while going is known, we cannot determine the speed of the whole trip without additional information.

The probability of getting heads maximum two times in a series of coin flips.

• To calculate the probability, divide the number of favorable outcomes by the total number of possible outcomes.

• In this case, the favorable outcomes are 0, 1, or 2 heads, and the total possible outcomes are 2^n, where n is the number of coin flips.

• For example, if we flip a coin 3 times, the favorable outcomes are HHT, HTH, THH, HHH, TTH, THT, a...read more