JiBe Development Services Senior Technical Support Officer Interview Questions and Answers

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