10+ Bounteous x Accolite Software Developer Intern Interview Questions and Answers

The problem involves determining if a ninja can reach the destination in a maze by moving in four directions until hitting a wall.

• Create a function that takes in the maze, starting point, and destination coordinates as input.

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

• Check if the destination can be reached from the starting point by moving in four directions.

• Return 'True' if a path exists, otherwise return 'False'.

Topological sort of a Directed Acyclic Graph (DAG) is found by ordering the vertices in such a way that for every directed edge u -> v, u comes before v in the ordering.

• Use Depth First Search (DFS) to find the topological ordering of the vertices.

• Start by visiting a vertex and recursively visit its neighbors before adding it to the result array.

• Maintain a visited array to keep track of visited vertices and a stack to store the topological ordering.

• Once all neighbors of a vert...read more

Find the Kth largest element in an array of distinct positive integers.

• Sort the array in non-increasing order and return the Kth element.

• Use a priority queue or quick select algorithm for efficient solution.

• Ensure the array contains distinct positive integers for accurate result.

Rotate an array left by a specified number of elements for each query.

• Iterate through each query and rotate the array left by the specified number of elements using array slicing.

• Handle cases where the number of rotations exceeds the length of the array by taking the modulo of the rotations.

• Return the modified array after each query.

Calculate the total amount of rainwater that can be trapped between given elevations in an array.

• Iterate through the array and calculate the maximum height on the left and right of each bar.

• Calculate the amount of water that can be trapped at each bar by taking the minimum of the maximum heights on the left and right.

• Sum up the trapped water at each bar to get the total trapped water for the entire array.

Count the number of distinct occurrences of one string as a subsequence in another string.

• Iterate through string A and string B to find all occurrences of B as a subsequence in A.

• Use dynamic programming to keep track of the number of distinct occurrences.

• Handle edge cases such as empty strings or strings of different lengths.

• Example: For strings A='aabbcc' and B='abc', there are 3 distinct occurrences of B in A.

Find the median of two sorted arrays by merging them and calculating the median of the combined array.

• Merge the two sorted arrays into one sorted array.

• Calculate the median of the merged array based on the total number of elements.

• If the total number of elements is even, take the mean of the two middle elements as the median.

Calculate the distance between two nodes in a binary tree.

• Traverse the tree to find the paths from the root to each node

• Find the lowest common ancestor of the two nodes

• Calculate the distance by summing the distances from each node to the common ancestor

Find the node where two linked lists merge, return -1 if no merging occurs.

• Traverse both lists to find their lengths and the difference in lengths

• Move the pointer of the longer list ahead by the difference

• Traverse both lists simultaneously until they meet at the merging point

Sort an array of 0s, 1s, and 2s in linear time complexity.

• Use three pointers to keep track of 0s, 1s, and 2s while iterating through the array.

• Swap elements based on the values encountered to sort the array in-place.

• Time complexity should be O(N) and space complexity should be O(1).

There are 3 levels of normalization in database management systems.

• First Normal Form (1NF) - Eliminate duplicate data and ensure data is stored in a tabular format.

• Second Normal Form (2NF) - Meet 1NF requirements and ensure all non-key attributes are fully functional dependent on the primary key.

• Third Normal Form (3NF) - Meet 2NF requirements and ensure that there are no transitive dependencies between non-key attributes.

The sub-parts or phases of the analysis part in compiler design include lexical analysis, syntax analysis, and semantic analysis.

• Lexical analysis involves breaking the input into tokens such as keywords, identifiers, and operators.

• Syntax analysis checks the structure of the tokens to ensure they conform to the grammar rules of the language.

• Semantic analysis verifies the meaning of the program by checking for type compatibility and other semantic rules.

• Examples include lexing ...read more