10+ MakeMyTrip Full Stack Developer Interview Questions and Answers

Tower of Hanoi problem involves moving 'N' disks from one rod to another following specific rules in less than 2^N moves.

• Implement a recursive function to move disks from one rod to another while following the rules.

• Use the concept of recursion and backtracking to solve the Tower of Hanoi problem efficiently.

• Maintain a count of moves and track the movement of disks in a 2-D array/list.

• Ensure that larger disks are not placed on top of smaller disks during the movement.

• The solu...read more

Minimum number of operations to make all elements in an array equal by performing addition, subtraction, multiplication, or division.

• Iterate through the array to find the maximum and minimum elements.

• Calculate the difference between the maximum and minimum elements.

• The minimum number of operations needed is the difference between the maximum and minimum elements.

Find the maximum distance between two elements in an array where the element at the first index is less than or equal to the element at the second index.

• Iterate through the array and keep track of the minimum element encountered so far along with its index.

• Calculate the maximum distance by subtracting the current index from the index of the minimum element.

• Update the maximum distance if a greater distance is found while iterating.

• Return the maximum distance calculated.

Find the minimum cost to make all elements of an array equal by changing them to the same value.

• Calculate the median of the array and find the sum of absolute differences between each element and the median.

• Sort the array and find the median element, then calculate the sum of absolute differences between each element and the median.

• If the array has an even number of elements, consider the average of the two middle elements as the median.

Count the total number of inversions in an integer array.

• Iterate through the array and for each pair of elements, check if the inversion condition is met.

• Use a nested loop to compare each pair of elements efficiently.

• Keep a count of the inversions found and return the total count at the end.

Find the maximum length of a sequence of 1's by converting at most K zeroes into ones in a binary array.

• Iterate through the array and keep track of the current window of 1's and zeroes.

• Use a sliding window approach to find the maximum length of the sequence.

• Update the window by flipping zeroes to ones within the limit of K flips.

• Return the maximum length of the sequence obtained.

The task is to determine the number of islands present on a 2D grid after each query of converting water to land.

• Create a function that takes the grid dimensions, number of queries, and query coordinates as input.

• For each query, convert the water at the given coordinates to land and then count the number of islands on the grid.

• Use depth-first search (DFS) or breadth-first search (BFS) to identify connected land cells forming islands.

• Return the number of islands after each que...read more

Find the shortest path in a binary matrix from a source cell to a destination cell consisting only of 1s.

• Use Breadth First Search (BFS) algorithm to find the shortest path.

• Keep track of visited cells to avoid revisiting them.

• Calculate the path length by counting the number of 1s in the path.

• Handle edge cases such as invalid inputs and unreachable destination.

Implement a function to find the square root of a number with a given precision.

• Create a function that takes 'N' and 'D' as input parameters

• Use a mathematical algorithm like Newton's method to approximate the square root

• Iterate until the precision condition is met

• Return the square root with the required precision

The problem involves determining if it is possible to reach a destination point from a source point using specified moves.

• Iterate through each test case and check if destination is reachable from source using specified moves

• Implement a recursive function to explore all possible paths from source to destination

• Keep track of visited points to avoid infinite loops

• Return true if destination is reachable, false otherwise

Find the maximum sum of products for array rotations.

• Iterate through all possible rotations of the array and calculate the sum of products for each rotation.

• Keep track of the maximum sum of products found so far.

• Return the maximum sum of products obtained.

Validate if a given binary tree is a Binary Search Tree (BST) or not.

• Check if the left subtree of a node contains only nodes with data less than the node's data.

• Check if the right subtree of a node contains only nodes with data greater than the node's data.

• Ensure that both the left and right subtrees are also binary search trees.

• Traverse the tree in an inorder manner and check if the elements are in sorted order.

• Recursively check each node's value against the range of values ...read more

Find the length of the longest duplicate substring in a given string.

• Iterate through all possible substrings of the input string.

• Use a rolling hash function to efficiently compare substrings.

• Store the lengths of duplicate substrings and return the maximum length.

Determine the length of the shortest contiguous subarray that needs to be sorted to make the entire array sorted in ascending order.

• Iterate from left to right to find the first element out of order.

• Iterate from right to left to find the last element out of order.

• Calculate the length of the subarray between the two out of order elements.

Implement a function to delete a node from a Binary Search Tree and return the inorder traversal of the modified BST.

• Understand the properties of a Binary Search Tree (BST) - left subtree contains nodes with data less than the node, right subtree contains nodes with data greater than the node.

• Implement a function to delete the given node from the BST while maintaining the BST properties.

• Perform inorder traversal of the modified BST to get the desired output.

• Handle cases where...read more

Given an array of integers and a target sum, find all pairs of elements that add up to the target sum.

• Use a hashmap to store the difference between the target sum and each element as keys and their indices as values.

• Iterate through the array and check if the current element's complement exists in the hashmap.

• Return the pairs of elements that add up to the target sum in sorted order.

The task is to determine the left view of a binary tree, which consists of nodes visible when viewed from the left side.

• Traverse the binary tree level by level from left to right, keeping track of the first node encountered at each level.

• Use a queue to perform level order traversal and keep track of the level number for each node.

• Store the first node encountered at each level in a result array to get the left view of the binary tree.