60+ Global Computer Interview Questions and Answers

The task is to determine if the given binary tree nodes form exactly one valid binary tree.

• Check if there is only one root node (a node with no parent)

• Check if each node has at most one parent

• Check if there are no cycles in the tree

• Check if all nodes are connected and form a single tree

The maximum number of balanced binary trees possible with a given height is to be counted and printed.

• A balanced binary tree is one in which the difference between the left and right subtree heights is less than or equal to 1.

• The number of balanced binary trees can be calculated using dynamic programming.

• The number of balanced binary trees with height 'H' can be obtained by summing the product of the number of balanced binary trees for each possible left and right subtree hei...read more

The task is to sort an array in a wave form, where each element is greater than or equal to its adjacent elements.

• Iterate through the array and swap adjacent elements if they do not follow the wave pattern

• Start from the second element and compare it with the previous element, swap if necessary

• Continue this process until the end of the array

• Repeat the process for the remaining elements

• Return the sorted wave array

The task is to check if there exist two unique elements in the given BST such that their sum is equal to the given target 'K'.

• Traverse the BST in-order and store the elements in a sorted array

• Use two pointers, one at the beginning and one at the end of the array

• Check if the sum of the elements at the two pointers is equal to the target 'K'

• If the sum is less than 'K', move the left pointer to the right

• If the sum is greater than 'K', move the right pointer to the left

• Repeat the...read more

The task is to find the maximum sum of node values of any subtree that is a Binary Search Tree(BST).

• Traverse the binary tree in a bottom-up manner

• For each node, check if it forms a BST and calculate the sum of its subtree

• Keep track of the maximum sum encountered so far

• Return the maximum sum

Check if a given singly linked list of integers is a palindrome or not.

• Create a function to reverse the linked list.

• Use two pointers to find the middle of the linked list.

• Compare the first half of the linked list with the reversed second half to determine if it's a palindrome.

The task is to find all nodes in a binary tree that are at a distance K from a given node.

• Implement a function that takes the binary tree, target node, and distance K as input.

• Use a depth-first search (DFS) algorithm to traverse the tree and find the nodes at distance K.

• Keep track of the distance from the current node to the target node while traversing.

• When the distance equals K, add the current node to the result list.

• Continue the DFS traversal to explore other nodes in the...read more

Yes, the 0/1 Knapsack problem can be solved using dynamic programming with a space complexity of not more than O(W).

• Use a 1D array to store the maximum value that can be stolen for each weight capacity from 0 to W.

• Iterate through each item and update the array based on whether including the item would increase the total value.

• The final value in the array at index W will be the maximum value that can be stolen.

Yes, the problem can be solved in less than O(N*log(N)) time complexity using the Quick Select algorithm.

• Implement Quick Select algorithm to find the Kth largest element in O(N) time complexity.

• Partition the array around a pivot element and recursively search in the left or right partition based on the position of the pivot.

• Once you find the Kth largest element, return all elements greater than or equal to it in non-decreasing order.

Implement a function to generate Huffman codes for characters based on their frequencies in an alien language message.

• Use a priority queue to build the Huffman tree efficiently.

• Assign '0' and '1' to left and right branches of the tree respectively to generate unique binary codes.

• Ensure that each code distinctly identifies its corresponding character and minimizes the total number of bits used for the message.

Rearrange a linked list such that odd numbers appear before even numbers while preserving the order.

• Create two separate linked lists for odd and even numbers

• Traverse the original list and append nodes to respective odd/even lists

• Combine the odd and even lists while maintaining the order

• Return the rearranged linked list

Multiply two numbers represented as linked lists and return the resultant multiplied linked list.

• Create a function that takes two linked lists as input and returns the product as a linked list

• Traverse both linked lists to extract the numbers, multiply them, and create a new linked list for the product

• Handle carry over while multiplying digits and adding to the result linked list

Find the size of the largest BST subtree in a binary tree.

• Traverse the tree in a bottom-up manner to check if each subtree is a BST.

• Keep track of the size of the largest BST found so far.

• Recursively check if the current subtree is a BST and update the size accordingly.

This question is about finding the weight of the last stone after repeatedly smashing the two heaviest stones together.

• Sort the array of stone weights in descending order.

• Repeatedly smash the two heaviest stones until there is at most 1 stone left.

• If there is 1 stone left, return its weight. Otherwise, return 0.

The problem involves finding the length of the longest common subsequence between two given strings.

• Use dynamic programming to solve the problem efficiently.

• Create a 2D array to store the lengths of common subsequences of substrings.

• Iterate through the strings to fill the array and find the length of the longest common subsequence.

• Example: For input STR1 = 'abcde' and STR2 = 'ace', the longest common subsequence is 'ace' with a length of 3.

Add two numbers represented by linked lists and return the head of the sum list.

• Traverse both linked lists simultaneously while keeping track of carry from previous sum

• Create a new linked list to store the sum of the two numbers

• Handle cases where one linked list is longer than the other by padding with zeros

• Update the sum and carry values accordingly while iterating through the linked lists

Find the minimum number of multiplication operations required to multiply a series of matrices together.

• Use dynamic programming to solve this problem efficiently.

• Create a 2D array to store the minimum number of operations needed to multiply matrices.

• Iterate through different combinations of matrices to find the optimal solution.

• Consider the dimensions of the matrices to determine the number of operations required.

• Calculate the minimum number of operations by considering all p...read more

Given a string, find the longest palindromic substring within it.

• Iterate through the string and expand around each character to find palindromes

• Keep track of the longest palindrome found so far

• Return the longest palindromic substring

Print a two-dimensional matrix in spiral order.

• Iterate through the matrix in a spiral order by keeping track of the boundaries.

• Print elements in the order: top row, right column, bottom row, left column.

• Repeat the process for inner submatrices until all elements are printed.

The task is to find the total number of ways to make change for a specified value using given denominations.

• Create a dynamic programming table to store the number of ways to make change for each value up to the target value.

• Iterate through each denomination and update the table accordingly based on the current denomination.

• The final answer will be the value in the table at the target value.

• Consider edge cases such as when the target value is 0 or when there are no denominatio...read more

Find the unique element in a sorted array where all other elements appear twice.

• Iterate through the array and XOR all elements to find the unique element.

• Use a hash set to keep track of elements and find the unique one.

• Sort the array and check adjacent elements to find the unique one.

Rotate a linked list by K positions in a clockwise direction.

• Traverse the linked list to find the length and the last node.

• Connect the last node to the head to form a circular linked list.

• Find the new head by moving (length - K) steps from the last node.

• Break the circular list at the new head to get the rotated linked list.

Rearrange the nodes of a singly linked list in a specific order without altering the data of the nodes.

• Use two pointers to split the linked list into two halves, reverse the second half, and then merge the two halves alternately.

• Ensure to handle cases where the number of nodes is odd or even separately.

• Keep track of the head and tail of each half to properly rearrange the nodes.

• Ensure to update the next pointers of the nodes correctly to rearrange the linked list in the desir...read more

Reverse a linked list in groups of size K

• Iterate through the linked list in groups of size K

• Reverse each group of nodes

• Handle cases where the last group has fewer nodes than K

Merge two binary trees by summing overlapping nodes and retaining non-null nodes.

• Traverse both trees simultaneously in preorder fashion

• If both nodes are not null, sum their values for the new node

• If one node is null, use the non-null node as the new node

• Recursively merge the left and right subtrees

Maximize vaccines administered on a specific day while following certain rules.

• Distribute vaccines evenly over the given number of days.

• Ensure the difference in vaccines administered between consecutive days is at most 1.

• Maximize the number of vaccines administered on the specified day.

• Keep track of the total number of vaccines administered to not exceed the maximum limit.

• Implement a function to calculate the maximum number of vaccines administered on the specified day.

Given a binary tree and a specific node, find its inorder successor in the tree.

• Perform an inorder traversal of the binary tree to find the successor node.

• If the given node has a right child, the successor is the leftmost node in the right subtree.

• If the given node does not have a right child, backtrack to find the ancestor whose left child is the given node.

Rearrange array elements in a zig-zag manner where every odd index element is greater than its neighbors.

• Iterate through the array and swap elements at odd indices to satisfy the zig-zag condition.

• Ensure that the swapped elements are greater than their neighbors.

• Multiple correct zig-zag rearrangements may exist for a given array.

Matching nuts and bolts based on size in a one-to-one mapping strategy.

• Iterate through the nuts and bolts arrays to find matching pairs based on size.

• Use sorting algorithms like quicksort to efficiently match nuts and bolts.

• Ensure the implementation modifies the input arrays directly to reflect the proper matched order.

The task is to maximize the total sweetness of the part that Ninja will get by dividing chocolates into K + 1 parts.

• Iterate through the array of sweetness values to find the maximum sweetness value.

• Use binary search to find the maximum sweetness that Ninja can obtain by making cuts.

• Consider the constraints while implementing the solution.

• Handle multiple test cases efficiently.

Calculate the total sum of all possible root-to-leaf paths in a binary tree.

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

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

• Use recursion to explore all possible paths in the tree.

• Return the total sum modulo (10^9 + 7) as the final result.

Dijkstra's algorithm is used to find the shortest path distance from a source node to all vertices in an undirected graph.

• Implement Dijkstra's algorithm to calculate shortest path distances

• Use a priority queue to efficiently select the next node to visit

• Initialize distances to all nodes as infinity, except for the source node as 0

• Update distances based on the weights of edges and choose the shortest path

• Handle disconnected nodes by assigning a maximum positive integer value

Reverse a singly linked list of integers and return the head of the reversed linked list.

• Iterate through the linked list and reverse the pointers to reverse the list

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

• Update the head of the reversed linked list once the reversal is complete

Flatten a binary tree into a linked list following pre-order traversal order.

• Use the binary tree's right pointer as the linked list's 'next' pointer.

• Set each node's left pointer to NULL.

• Implement the solution without printing within the function.

• Follow pre-order traversal to flatten the binary tree into a linked list.

Identify equilibrium indices in a given sequence by finding positions where sum of elements before and after is equal.

• Iterate through the sequence and calculate prefix sum and suffix sum at each index

• Compare prefix sum and suffix sum to find equilibrium indices

• Handle edge cases where no equilibrium index exists

• Return the indices as a sequence of integers or an empty sequence

Reverse a linked list in groups of size K.

• Iterate through the linked list in groups of size K.

• Reverse each group of nodes.

• Handle cases where the number of elements in the last group is less than K.

Find all nodes at a specified distance K from a given node in a binary tree.

• Traverse the binary tree to find the target node.

• Use depth-first search to explore nodes at distance K from the target node.

• Keep track of the distance from the target node while traversing.

• Return a list of node values at distance K from the target node.

• Handle cases where no nodes are found at the specified distance.

The diameter of a binary tree is the longest path between any two end nodes in the tree.

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

• Use depth-first search (DFS) to calculate the height of each subtree.

• The diameter of the tree is the maximum of the sum of heights of left and right subtrees + 1.

Dijkstra's algorithm is used to find the shortest path from a source node to all other nodes in a graph with weighted edges.

• Implement Dijkstra's algorithm to find the shortest path distances from the source node to all other nodes.

• Use a priority queue to efficiently select the next node with the shortest distance.

• Initialize distances to all nodes as infinity except for the source node which is 0.

• Update distances to neighboring nodes if a shorter path is found.

• Repeat the proce...read more

The problem involves printing the spiral order of a given matrix of integers.

• Iterate through the matrix in a spiral order by keeping track of the boundaries.

• Print the elements in the order: top row, right column, bottom row, left column.

• Continue this process until all elements are printed in spiral order.

Convert a binary search tree into a Greater Tree by updating each node's data to the sum of its original data plus the data of all nodes with greater or equal values.

• Traverse the BST in reverse inorder (right, root, left) to update nodes with the sum of greater nodes.

• Keep track of the sum of greater nodes encountered so far while traversing.

• Update each node's data with the sum of greater nodes and continue traversal.

Return the level order traversal of a binary tree given in level order.

• Use a queue to perform level order traversal of the binary tree

• Start by pushing the root node into the queue

• While the queue is not empty, dequeue a node, print its value, and enqueue its children

Find the Kth ancestor of a given node in a binary tree.

• Traverse the tree to find the path from the target node to the root node.

• Store the path in a list and return the Kth element from the end.

• Handle cases where the Kth ancestor does not exist by returning -1.

Higher order functions are functions that can take other functions as arguments or return functions as their results.

• Higher order functions can be used to create more flexible and reusable code.

• They enable functional programming paradigms.

• Examples of higher order functions include map, filter, and reduce in JavaScript.

A todo list application using localstorage.

• Use HTML, CSS, and JavaScript to create the user interface.

• Use the localstorage API to store and retrieve todo items.

• Implement features like adding, editing, and deleting todo items.

• Display the list of todo items and their status.

• Allow users to mark todo items as completed or incomplete.

Hoisting is a JavaScript behavior where variable and function declarations are moved to the top of their containing scope.

• Hoisting applies to both variable and function declarations.

• Variable declarations are hoisted but not their initializations.

• Function declarations are fully hoisted, including their definitions.

• Hoisting can lead to unexpected behavior if not understood properly.

Promises in JavaScript are objects that represent the eventual completion or failure of an asynchronous operation.

• Promises are used to handle asynchronous operations such as fetching data from a server or reading a file.

• They simplify the process of writing asynchronous code by providing a more structured approach.

• Promises have three states: pending, fulfilled, or rejected.

• They can be chained together using methods like .then() and .catch().

• Promises help avoid callback hell an...read more

Design a signin page using HTML and CSS only

• Create a form element with input fields for username and password

• Style the form using CSS to make it visually appealing

• Add a submit button for users to sign in

• Consider adding error messages or validation for user input

• Use CSS to make the page responsive for different screen sizes

Memoization is a technique in JavaScript to cache the results of expensive function calls for future use.

• Memoization improves performance by avoiding redundant calculations

• It is commonly used in recursive functions or functions with expensive computations

• The cached results are stored in a data structure like an object or a map

• Memoization can be implemented manually or using libraries like Lodash or Memoizee

Temporal Dead Zone is a behavior in JavaScript where variables are not accessible before they are declared.

• Temporal Dead Zone occurs when accessing variables before they are declared

• Variables in the Temporal Dead Zone cannot be accessed or assigned

• The Temporal Dead Zone is a result of JavaScript's hoisting behavior

• Example: accessing a variable before it is declared will throw a ReferenceError

Arrow functions are a concise way to write functions in JavaScript.

• Arrow functions have a shorter syntax compared to regular functions.

• They do not have their own 'this' value.

• They do not have the 'arguments' object.

• They cannot be used as constructors with the 'new' keyword.

• They are commonly used in functional programming and with array methods like 'map' and 'filter'.

Virtual DOM is a lightweight copy of the actual DOM that allows efficient updates and rendering in JavaScript frameworks.

• Virtual DOM is a concept used in JavaScript frameworks like React.

• It is a lightweight copy of the actual DOM tree.

• Changes made to the virtual DOM are compared with the actual DOM to determine the minimal updates needed.

• This helps in efficient rendering and improves performance.

• Virtual DOM allows developers to write code as if the entire page is rendered on ...read more

IIFE stands for Immediately Invoked Function Expression. It is a JavaScript function that is executed as soon as it is defined.

• IIFE is a way to create a function expression and immediately invoke it.

• It helps in creating a private scope for variables and functions.

• It is commonly used to avoid polluting the global namespace.

• IIFE can be written using different syntaxes like using parentheses, function declaration, or arrow functions.