40+ Bounteous x Accolite Interview Questions and Answers for Freshers

Determine the maximum amount of money a thief can steal from houses without looting two consecutive houses.

• Create an array 'dp' to store the maximum money that can be stolen up to the i-th house.

• Iterate through the houses and update 'dp' based on whether the current house is stolen or not.

• Return the maximum value in 'dp' as the answer.

• Example: For input N=4 and values=[6, 7, 1, 30], the output should be 36.

Implement a function to perform topological sorting on a directed acyclic graph (DAG) and return any valid ordering.

• Create a graph representation using adjacency list or matrix

• Perform depth-first search (DFS) to find the topological ordering

• Use a stack to keep track of the ordering

• Return the ordering as an array of integers

Finally is a block of code that executes after try-catch block. It will not execute if System.exit() is called.

• Finally block is used to execute a block of code after try-catch block

• It will execute even if an exception is thrown

• Finally block will not execute if the JVM exits before the block is executed

• System.exit() terminates the JVM and finally block will not execute

Program to find all palindromic strings in a given string.

• Iterate through the string and check for palindromic substrings using two pointers.

• Add the palindromic substrings to an array of strings.

• Return the array of palindromic strings.

Use tree traversal to find the minimum number in a tree structure.

• Start at the root node and compare it with its children to find the minimum value.

• Use depth-first search or breadth-first search to traverse the tree.

• Keep track of the minimum value found so far as you traverse the tree.

• Consider implementing a recursive function to traverse the tree efficiently.

SQL query to find the 2nd highest salary in a table.

• Use ORDER BY and LIMIT to sort and select the 2nd highest salary.

• Use subquery to avoid duplicates if necessary.

The task is to find the subarray with the maximum sum in a given array.

• Iterate through the array and keep track of the current sum and maximum sum seen so far.

• If the current sum becomes negative, reset it to 0 as it won't contribute to the maximum sum.

• Compare the maximum sum with the sum of the current subarray to update the result.

• Handle cases where all elements are negative by returning the maximum element in the array.

• Consider edge cases like empty array or array with only...read more

Find the minimum time required to rot all fresh oranges in a grid.

• Use Breadth First Search (BFS) to simulate the rotting process

• Track the time taken to rot all oranges and return -1 if any fresh oranges remain

• Handle edge cases like no fresh oranges or all oranges already rotten

• Consider using a queue to efficiently process adjacent oranges

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 by the difference in lengths

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

Reverse a singly linked list by altering the links between nodes.

• Iterate through the linked list and reverse the links between nodes

• Use three pointers to keep track of the current, previous, and next nodes

• Update the links between nodes to reverse the list

• Return the head of the reversed linked list

Merge K sorted arrays into one sorted array in ascending order.

• Iterate through all arrays/lists and merge them into one sorted array using a priority queue or merge sort algorithm.

• Ensure to handle edge cases like empty arrays/lists or arrays/lists with different sizes.

• Time complexity can be optimized by using a min-heap or priority queue to efficiently merge the arrays/lists.

Print the left view of a binary tree given in level order form.

• Traverse the tree level by level and print the first node of each level (leftmost node).

• Use a queue to perform level order traversal.

• Keep track of the current level and print the first node encountered at each level.

Find the maximum path sum between two leaf nodes in a binary tree.

• Traverse the tree to find the maximum path sum between two leaf nodes.

• Keep track of the maximum sum found so far.

• Consider all possible paths between leaf nodes.

• Handle cases where the tree has only a single leaf node.

• Implement a recursive function to calculate the maximum path sum.

Find the majority element in an array, return -1 if no majority element exists.

• Iterate through the array and keep track of the count of each element using a hashmap.

• Check if any element's count is greater than floor(N/2) to determine the majority element.

• Return the majority element or -1 if no majority element exists.

Find the N-th node from the end of a Singly Linked List of integers.

• Traverse the list to find the length L of the list.

• Calculate the position of the N-th node from the beginning as L - N + 1.

• Traverse the list again to reach the calculated position and return the node's value.

Find the Lowest Common Ancestor (LCA) of two nodes in a binary tree.

• Traverse the binary tree to find the paths from the root to nodes X and Y.

• Compare the paths to find the last common node, which is the LCA.

• Handle cases where one node is an ancestor of the other or when one node is the LCA itself.

Reverse words in a string while handling leading/trailing spaces and multiple spaces between words.

• Split the input string by spaces to get individual words

• Reverse the list of words

• Join the reversed words with a single space in between

• Handle leading/trailing spaces by stripping them before and after reversing

Assign subjects to friends to minimize maximum workload, find minimum time for most loaded friend.

• Sort subjects in descending order

• Assign subjects to friends one by one until all subjects are assigned

• The maximum workload will be the sum of problems assigned to the friend with the most problems

• Return the maximum workload as the minimum time required

Find the total sum of all root to leaf paths in a binary tree formed by concatenating node values.

• Traverse the binary tree from root to leaf nodes, keeping track of the current path sum

• Add the current path sum to the total sum when reaching a leaf node

• Use modulo (10^9 + 7) to handle large outputs

Grammar in compiler design defines the syntax and structure of a programming language.

• Grammar specifies the rules for forming valid statements in a programming language.

• It consists of a set of production rules that define how valid programs can be constructed.

• There are different types of grammars such as context-free grammar, regular grammar, etc.

• Example: In C programming language, the grammar specifies that a for loop should have a specific syntax like 'for(initialization; c...read more

Code to split an array of integers into two subarrays with equal sum.

• Iterate through the array and calculate the total sum.

• Divide the sum by 2 to get the target sum for each subarray.

• Use dynamic programming to find a subset of the array that adds up to the target sum.

• Return the two subarrays.

• Example: [1, 2, 3, 4, 5, 6] -> [1, 2, 3, 6], [4, 5]

• Example: [1, 2, 3, 4, 5] -> [1, 4, 5], [2, 3]

Implementing a binary search tree and its traversal methods.

• Start by defining a Node class with left and right child pointers.

• Implement insert() method to add nodes to the tree.

• Implement inorder(), preorder(), and postorder() traversal methods.

• Implement search() method to find a node in the tree.

• Implement delete() method to remove a node from the tree.

• Consider edge cases like empty tree, duplicate nodes, etc.

NP problems are decision problems that can be verified in polynomial time, while NP-Hard problems are at least as hard as the hardest problems in NP.

• NP problems can be verified in polynomial time but not necessarily solved in polynomial time.

• NP-Hard problems are at least as hard as the hardest problems in NP, but may not be in NP themselves.

• Examples of NP problems include the subset sum problem and the traveling salesman problem.

• Examples of NP-Hard problems include the travel...read more

A token in compiler design is a basic unit of syntax that the compiler can understand and process.

• Tokens are the smallest units of a program that are meaningful to the compiler.

• Examples of tokens include keywords, identifiers, operators, and punctuation symbols.

• Tokens are generated by the lexical analysis phase of the compiler.

• Tokens are used by the parser to build the abstract syntax tree of the program.

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'.

Find unique characters in a window of k size in a string.

• Use a sliding window approach.

• Maintain a hash table to keep track of character frequency.

• Remove characters from hash table as the window slides.

Convert given no to corresponding excel no.

• Excel no starts from 1 and goes up to 16384

• Excel no is calculated using column and row numbers

• For example, 1 corresponds to A, 27 corresponds to AA, 28 corresponds to AB, and so on

A regular language is a language that can be recognized by a finite automaton.

• Regular languages can be described by regular expressions.

• Regular languages are closed under union, concatenation, and Kleene star operations.

• Examples of regular languages include the set of all strings over an alphabet that contain an even number of 'a's.

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

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

Segmentation in operating systems is a memory management technique where memory is divided into segments of variable sizes.

• Segments are logical units of a program such as code, data, stack, etc.

• Each segment has its own base address and length.

• Segmentation allows for more efficient memory management and protection.

• Examples include Intel x86 architecture with segment registers like CS, DS, SS, etc.

Use binary search to find the first and last occurrence of the character, then calculate the frequency.

• Use binary search to find the first occurrence of the character in the string.

• Use binary search to find the last occurrence of the character in the string.

• Calculate the frequency by subtracting the indices of the last and first occurrences and adding 1.

OOPs concepts and pillars. Design a Vehicle class based on requirements.

• OOPs concepts: Abstraction, Encapsulation, Inheritance, Polymorphism

• Vehicle class requirements: attributes like make, model, year, methods like start, stop, accelerate

Factorial of n and sum of n numbers using recursion

• Create a recursive function to calculate factorial of n

• Use a recursive function to calculate the sum of all n numbers

• Handle base cases for both factorial and sum calculations

• Example: Factorial of 5 = 5 * 4 * 3 * 2 * 1 = 120, Sum of first 5 numbers = 1 + 2 + 3 + 4 + 5 = 15