300+ Tech Mahindra Interview Questions and Answers

The task is to delete the middle node of a singly linked list of integers.

• If the linked list is empty or has only one node, there is no middle node to delete.

• To delete the middle node, we need to find the middle node and update the pointers of the previous and next nodes.

• To find the middle node in one traversal, we can use two pointers - a slow pointer and a fast pointer.

• The slow pointer moves one node at a time, while the fast pointer moves two nodes at a time.

• When the fast ...read more

The challenge involves splitting an array into sub-arrays to minimize cost based on unique elements and repetitions.

• Iterate through the array and keep track of unique elements and repetitions

• Calculate cost for each sub-array based on the rules provided

• Sum up the costs for all sub-arrays to get the total minimum cost

The task is to find the length of the shortest contiguous subarray that needs to be sorted in order to sort the entire array.

• Iterate through the array from left to right and find the first element that is out of order.

• Iterate through the array from right to left and find the first element that is out of order.

• Find the minimum and maximum elements within the subarray defined by the above two elements.

• Expand the subarray to include any additional elements that are out of order ...read more

This is a problem where a sorted array is rotated and we need to search for given numbers in the array.

• The array is rotated clockwise by an unknown amount.

• We need to perform binary search to find the index of the given numbers.

• If the number is found, return its index. Otherwise, return -1.

• The time complexity of the solution should be O(logN).

The question asks to implement quick sort algorithm to sort an array of integers in ascending order.

• Quick sort is a divide and conquer algorithm

• Choose a pivot point and partition the array into two parts

• Recursively sort the left and right parts of the array

• Implement the quick sort algorithm to sort the given array

The task is to swap each even bit of an integer with its adjacent bit on the right in its binary representation.

• Convert the given integer to its binary representation

• Iterate through the binary representation and swap each even bit with its adjacent bit on the right

• Convert the modified binary representation back to an integer

• Print the resulting integer

Calculate x raised to the power of n, given x and n as input from the user.

• Accept two integers x and n as input from the user

• Compute x^n and display the result

• Handle the case where x=0 and n=0 separately (0^0 = 1)

The task is to find the lowest common ancestor (LCA) of two given nodes in a binary search tree (BST).

• The LCA is the lowest node that has both given nodes as descendants.

• In a BST, the left subtree of a node contains only nodes with data less than the node's data, and the right subtree contains only nodes with data greater than the node's data.

• Start from the root node and compare it with the given nodes. If both nodes are smaller than the current node, move to the left subtree...read more

The task is to merge two sorted linked lists into a single sorted linked list.

• Create a new linked list to store the merged list

• Compare the values of the nodes from both lists and add the smaller value to the new list

• Move the pointer of the list with the smaller value to the next node

• Repeat the comparison and addition until one of the lists is empty

• Add the remaining nodes from the non-empty list to the new list

• Return the head of the new list

The task is to return the spiral path of a given matrix.

• Iterate through the matrix in a spiral pattern, starting from the outermost layer and moving towards the center.

• Keep track of the current row, column, and the boundaries of the remaining unvisited matrix.

• Print the elements in the spiral path as you traverse the matrix.

Given a string with only '{' and '}', find the minimum cost to make it valid by converting brackets.

• Iterate through the string and keep track of the opening and closing brackets

• If there are more closing brackets than opening brackets, convert the excess closing brackets to opening brackets

• If there are more opening brackets than closing brackets, convert the excess opening brackets to closing brackets

• Return the total cost of conversions needed to make the string valid

Sort the array in decreasing order based on the count of set bits in the binary representation of each integer.

• Iterate through the array and calculate the set bit count for each integer using bitwise operations.

• Use a custom comparator function to sort the array based on the set bit count.

• Maintain the original order for integers with the same set bit count.

• Modify the array in-place within the given function.

Determine if each number in the array has exactly 3 factors.

• Iterate through each number in the array and check if it has exactly 3 factors.

• Factors of a number can be found by iterating from 1 to the square root of the number.

• Count the number of factors and return 1 if it is exactly 3, else return 0.

Validate if a binary tree is a Binary Search Tree (BST) based on given properties.

• Check if left subtree contains only nodes with data less than current node's data

• Check if right subtree contains only nodes with data greater than current node's data

• Recursively check if both left and right subtrees are also BSTs

Find the maximum sum of a subsequence without choosing adjacent elements in the original array.

• Iterate through the array and keep track of the maximum sum of non-adjacent elements.

• At each index, compare the sum of including the current element with excluding the current element.

• Return the maximum sum obtained.

• Example: For input [3, 2, 7, 10], the maximum sum is 13 by selecting 3 and 10.

• Example: For input [3, 2, 5], the maximum sum is 8 by selecting 3 and 5.

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 point to the previous node instead of the next node.

• Use three pointers to keep track of the current, previous, and next nodes while reversing the linked list.

• Ensure to update the head of the reversed linked list at the end of the process.

• Example: Input: 1 -> 2 -> 3 -> 4 -> NULL, Output: 4 -> 3 -> 2 -> 1 -> NULL

Implement a stack with push, pop, top, isEmpty, and getMin operations in O(1) time complexity without using extra space.

• Use two stacks - one to store the actual elements and another to store the minimum element at each level.

• When pushing an element, check if it is smaller than the current minimum and update the minimum stack accordingly.

• When popping an element, also pop from the minimum stack if the popped element is the current minimum.

• For getMin operation, simply return the...read more

Determine the minimum number of additional lamps needed to illuminate a string with dots and asterisks.

• Iterate through the string and check for free spaces that are not already illuminated by existing lamps

• Place a lamp at each free space that is not already illuminated by an existing lamp

• Consider edge cases where the first and last positions may need additional lamps

The task is to fill a Knapsack with stones of different colors and weights, minimizing unused capacity.

• Given N stones with weights W and colors C, choose M stones (one of each color) to fill Knapsack with total weight not exceeding X

• Minimize unused capacity of Knapsack by choosing stones wisely

• If no way to fill Knapsack, output -1

• Example: N=5, M=3, X=10, W=[1, 3, 3, 5, 5], C=[1, 2, 3, 1, 2] -> Output: 1

Find the minimum number of fountains to activate to water the entire garden.

• Iterate through the array and keep track of the farthest point each fountain can cover.

• Activate the fountain that covers the farthest point not covered by any previous fountain.

• Continue this process until the entire garden is covered.

• Return the count of activated fountains as the minimum number required.

Find the length of the longest subsequence common to two arrays consisting only of prime numbers.

• Iterate through both arrays and check if the numbers are prime.

• Use dynamic programming to find the longest common subsequence of prime numbers.

• Keep track of the length of the common prime subsequence.

• Return the length of the longest common prime subsequence.

The problem involves calculating the minimum number of partitions needed to ensure every resulting substring is a palindrome.

• Iterate through the string and check for palindromes at each possible partition point.

• Keep track of the minimum cuts needed to partition the string into palindromic substrings.

• Consider edge cases such as when the string is already a palindrome or when all characters are unique.

• Example: For input 'AACCB', the valid partition 'A | A | CC | B' requires 2 c...read more

To speed up multiplication of small integers in an array, we can use bitwise operations and parallel processing.

• Use bitwise operations like shifting and ANDing to perform multiplication faster.

• Divide the array into smaller chunks and perform multiplication in parallel using multi-threading or SIMD instructions.

• Use lookup tables for frequently used values to avoid repeated calculations.

• Use compiler optimizations like loop unrolling and vectorization.

• Consider using specialized ...read more

Find the equilibrium index of an array where sum of elements on left equals sum of elements on right.

• Iterate through the array and calculate the total sum of elements.

• For each index, calculate the sum of elements on the left and right side and check for equilibrium.

• Return the left-most equilibrium index found, or -1 if none exist.

Given N meetings with start and end times, find the maximum number of meetings that can be organized in a single room without overlap.

• Sort the meetings based on end times.

• Iterate through the sorted meetings and select the next meeting whose start time is greater than or equal to the end time of the previous meeting.

• Return the selected meetings in the order they are organized.

Split the array into maximum number of subarrays such that first and last occurrence of every distinct element lies within a single subarray.

• Iterate through the array and keep track of the first and last occurrence of each element.

• Use a hashmap to store the indices of each element.

• Count the number of subarrays where the first and last occurrence of each element are within the same subarray.

The problem involves splitting an array into 'K' consecutive subarrays of length 'M' with each subarray containing a single distinct element.

• Iterate through the array and check if each subarray of length 'M' contains only one distinct element.

• Keep track of the count of distinct elements in each subarray.

• Return 1 if it is possible to split the array according to the condition, otherwise return 0.

Count distinct substrings of a given string using trie data structure.

• Implement a trie data structure to store all substrings of the given string.

• Count the number of nodes in the trie to get the distinct substrings count.

• Handle empty string case separately.

• Example: For 'ab', distinct substrings are: '', 'a', 'b', 'ab'.

The problem involves finding the intersection of two sorted arrays efficiently.

• Use two pointers to iterate through both arrays simultaneously.

• Compare elements at the pointers and move the pointers accordingly.

• Handle cases where elements are equal, and update the intersection array.

• Return the intersection array as the result.

Find the maximum product of a subset of an array modulo 10^9+7.

• Iterate through the array and keep track of the maximum positive product and minimum negative product encountered so far.

• Handle cases where the array contains zeros separately.

• Return the maximum product modulo 10^9+7.

Given an array, split it into maximum subarrays with first and last occurrence of each element in a single subarray.

• Iterate through the array and keep track of the first and last occurrence of each element.

• Use a hashmap to store the indices of each element.

• Split the array whenever the last occurrence of an element is found.

Given an array of positive integers representing water in buckets, find the minimum amount of water to be removed to equalize all buckets.

• Sort the array in non-decreasing order to easily identify the buckets with excess water.

• Calculate the average water volume by dividing the total water volume by the number of buckets.

• Iterate through the array and calculate the excess water in each bucket compared to the average.

• Sum up the excess water in all buckets to get the minimum amoun...read more

Minimize cash flow among friends by optimizing transactions.

• Create a graph where nodes represent friends and edges represent transactions.

• Calculate net amount each friend owes or is owed.

• Use a recursive algorithm to settle debts by minimizing cash flow.

• Update the graph after each transaction to reflect the new balances.

• Repeat the process until all balances are settled.

The task is to maximize the sum of selected elements from an array by following specific rules.

• Select elements strategically to maximize the sum

• Remove occurrences of selected element, and its neighbors

• Repeat the process until the array becomes empty

Find all leaders in a sequence - elements greater than all elements to their right.

• Iterate from right to left, keep track of maximum element encountered so far

• If current element is greater than maximum, it is a leader

• Return the leaders in the same order as the input sequence

Find the Next Greater Element for each element in an array.

• Iterate through the array from right to left

• Use a stack to keep track of elements with no greater element to the right

• Pop elements from the stack until finding a greater element or stack is empty

Check if a given number is part of an arithmetic sequence with a given first term and common difference.

• Calculate the arithmetic sequence using the formula: nth term = X + (n-1) * C

• Check if Y is equal to any term in the sequence to determine if it belongs to the sequence

• Return 'True' if Y belongs to the sequence, otherwise return 'False'

Find the maximum sum achievable by a simple path between any two nodes in a binary tree.

• Traverse the binary tree to find all possible paths and calculate their sums.

• Keep track of the maximum sum encountered during traversal.

• Consider paths that may include the same node twice.

• Implement a recursive function to explore all possible paths.

• Handle cases where nodes have negative values.

Implement a function to update 'next' pointers in a complete binary tree.

• Iterate level by level using a queue

• Connect nodes at each level using 'next' pointers

• Handle null nodes appropriately

• Ensure the tree is a complete binary tree

Implement a wildcard pattern matching algorithm to determine if a given wildcard pattern matches a text string completely.

• Create a recursive function to match the pattern with the text character by character.

• Handle cases for '?' and '*' characters separately.

• Use dynamic programming to optimize the solution.

• Check for edge cases like empty pattern or text.

Find the number with the maximum frequency in an array of integers.

• Iterate through the array and keep track of the frequency of each number using a hashmap.

• Find the number with the maximum frequency and return it.

• If multiple elements have the same maximum frequency, return the one that appears first in the array.

Find the length of the longest subarray with zero sum in an array of integers.

• Iterate through the array and keep track of the running sum using a hashmap.

• If the running sum is seen before, it means there is a subarray with zero sum.

• Calculate the length of the subarray with zero sum and update the maximum length found so far.

Detect and remove loop in a singly linked list in place with O(n) time complexity and O(1) space complexity.

• Use Floyd's Cycle Detection Algorithm to identify the loop in the linked list.

• Once the loop is detected, use two pointers to find the start of the loop.

• Adjust the pointers to remove the loop and return the modified linked list.

i is stored in global data segment, j is stored in stack, k is stored in heap.

• i is a global variable and is stored in the global data segment

• j is a local variable and is stored in the stack

• k is a pointer variable and is stored in the stack, while the memory it points to is allocated on the heap using malloc()

Find all possible paths for a rat in a maze to reach its destination.

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

• Keep track of the current path and mark visited cells to avoid loops.

• Return the paths that lead from the start position to the destination.

• Example: [[1, 0, 0], [1, 1, 0], [0, 1, 1]]

Santa needs to find the quickest path to deliver gifts in Ninja town by jumping over buildings with least travel time.

• Santa can jump to (x+1, y+1), (x+1, y), or (x, y+1) from any cell (x, y) within grid boundaries.

• The travel time between two buildings equals the absolute difference in their heights.

• Find the shortest path from (0, 0) to (N-1, M-1) using dynamic programming or Dijkstra's algorithm.

• Consider all possible paths and choose the one with the minimum total travel time...read more

Zigzag level order traversal of a binary tree alternating direction at each level.

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

• Maintain a flag to alternate the direction of traversal at each level.

• Store nodes at each level in separate lists and reverse the list if traversal direction is right to left.

Implement a function to return elements of a matrix in spiral order.

• Iterate through the matrix in a spiral order by adjusting the boundaries of rows and columns.

• Keep track of the direction of traversal (right, down, left, up) to properly move through the matrix.

• Handle edge cases such as when the matrix is empty or has only one row or column.

Detect if a singly linked list forms a cycle by checking if a node's next pointer points back to a previous node.

• Traverse the linked list using two pointers, one moving at double the speed of the other.

• If the two pointers meet at any point, there is a cycle in the linked list.

• Use Floyd's Cycle Detection Algorithm for efficient detection.

• Example: Input: 3 2 0 -4 -1, 1 Output: true

Check if two strings are anagrams of each other by comparing the sorted characters.

• Sort the characters of both strings and compare them.

• Use a dictionary to count the occurrences of characters in each string.

• Ensure both strings have the same length before proceeding.

• Handle edge cases like empty strings or strings with different lengths.

• Example: str1 = 'listen', str2 = 'silent' should return True.

Count occurrences of a digit in a given range.

• Iterate through the range [A, B] and count occurrences of digit K.

• Convert integers to strings for easier digit comparison.

• Handle edge cases like when A or B is equal to K.

The task is to rearrange an array such that no two adjacent elements are the same.

• Iterate through the array and check if any adjacent elements are the same.

• If adjacent elements are the same, swap one of them with a different element.

• Return 'YES' if a valid rearrangement is possible, 'NO' otherwise.

Determine if a binary tree is symmetric by checking if its left and right subtrees are mirror images of each other.

• Check if the left and right subtrees of the root node are mirror images of each other

• Recursively check if the left subtree of the left child is a mirror image of the right subtree of the right child, and vice versa

• Base case: If both nodes are null, return true; If one node is null and the other is not, return false

• Example: For the input tree 1 2 2 3 4 4 3, the tr...read more

Find predecessor and successor of a given node in a binary search tree (BST).

• Predecessor is the node visited just before the given node in an inorder traversal.

• Successor is the node visited immediately after the given node in an inorder traversal.

• Return -1 if predecessor or successor does not exist.

• Implement inorder traversal to find predecessor and successor.

The problem involves counting the number of distinct ways to climb N stairs by taking 1 or 2 steps at a time.

• Use dynamic programming to solve the problem efficiently.

• The number of ways to reach the Nth stair is the sum of the number of ways to reach the (N-1)th stair and the (N-2)th stair.

• Handle base cases for N=0 and N=1 separately.

• Apply modulo operation to avoid overflow while calculating the result.

• Consider using memoization to optimize the solution by storing intermediate...read more

Given an array, find the number of 'good' arrays that can be formed by deleting one element.

• Iterate through each element in the array and check if deleting it results in a 'good' array

• Keep track of the sum of elements at odd and even indices to determine if the array is 'good'

• Return the count of 'good' arrays

Client-server code with optimal thread handling for multiple requests

• Use a thread pool to handle multiple requests efficiently

• Optimal number of threads depends on CPU cores and available memory

• Increasing threads beyond optimal number can lead to resource contention and performance degradation

Convert a binary tree into its mirror tree by interchanging left and right children of non-leaf nodes.

• Traverse the binary tree in a recursive manner.

• Swap the left and right children of each non-leaf node.

• Continue this process until all nodes are visited.

• Output the inorder traversal of the mirror tree.

Given an encrypted string with repeated substrings represented by counts, find the K'th character of the decrypted string.

• Parse the encrypted string to extract substrings and their counts

• Iterate through the decrypted string to find the K'th character

• Handle cases where counts are more than one digit or in parts

Implement a queue using only stack data structures, supporting FIFO principle.

• Use two stacks to simulate a queue: one for enqueueing and one for dequeueing.

• For enQueue operation, push elements onto the enqueue stack.

• For deQueue operation, if dequeue stack is empty, transfer elements from enqueue stack.

• For peek operation, return top element of dequeue stack.

• For isEmpty operation, check if both stacks are empty.

Implement a stack using two queues to store integer values with specified functions.

• Create a stack class with two queue data members.

• Implement push, pop, top, size, and isEmpty functions.

• Ensure proper handling of edge cases like empty stack.

• Use queue operations like enqueue and dequeue to simulate stack behavior.

• Maintain the size of the stack and check for emptiness.

• Example: Push 42, pop to get 42, push 17, top to get 17.

Find the maximum window size to sort an unsorted array.

• Identify the longest decreasing subarray from the beginning and longest increasing subarray from the end

• Find the minimum and maximum element in the identified subarrays

• Expand the identified subarrays until all elements in the array are covered

• The length of the expanded subarray is the maximum window size

The task is to represent a binary tree in a 2-D array of strings with specific formatting rules.

• Create a 2-D array of strings with 'H' rows and odd number of columns.

• Fill in the array based on the given binary tree, following the specified formatting rules.

• Leave empty strings for unfilled cells and adjust spacing for empty subtrees.

• Ensure the output matches the example provided in the question.

Calculate the number of distinct ways to climb N stairs by either taking one or two steps at a time.

• Use dynamic programming to keep track of the number of ways to reach each stair

• The number of ways to reach a stair is the sum of the number of ways to reach the previous two stairs

• Return the result modulo 10^9+7

Level Order Traversal of Binary Tree returns nodes in level order traversal.

• Perform a level order traversal of the binary tree starting from the root node.

• Visit nodes level by level, printing them in the order they are encountered.

• Use a queue data structure to keep track of nodes at each level.

The task is to print the Top View of a Binary Tree, which is the set of nodes visible when viewed from the top, in left to right order.

• Traverse the binary tree in level order and maintain a map to store the horizontal distance of each node from the root.

• For each node, if the horizontal distance is not already in the map, add the node's value to the result.

• Print the values from the map in ascending order of horizontal distance to get the Top View of the Binary Tree.

Given a rotated sorted array, find the index of a given integer 'K'.

• Perform binary search to find the pivot point where the array is rotated.

• Based on the pivot point, apply binary search on the appropriate half of the array to find 'K'.

• Handle cases where 'K' is not present in the array by returning -1.

The task is to identify and print every path in a binary tree whose node values sum up to a specified number 'K'.

• Traverse the binary tree to find paths with sum equal to 'K'.

• Print each valid path in the order encountered in the tree.

• Handle cases where nodes may have missing children (-1).

Puzzle: On which day in November was the pond filled with half the ice?

• The amount of ice in the pond doubles each day in November

• The pond is filled with ice on the last day of November

• To find the day when the pond was half-filled, work backwards from the last day

The Diamond Problem is a conflict that occurs when a class inherits from two classes that have a common base class.

• The Diamond Problem arises in multiple inheritance.

• It occurs when a class inherits from two classes that have a common base class.

• This leads to ambiguity in accessing the common base class members.

• To fix the Diamond Problem, virtual inheritance is used.

• Virtual inheritance ensures that only one instance of the common base class is inherited.

The Unbounded Knapsack Problem involves maximizing profit by filling a knapsack with items of specific profit and weight.

• Iterate through each item and calculate the maximum profit that can be obtained by including or excluding the item in the knapsack.

• Use dynamic programming to store and reuse subproblem solutions to optimize the solution.

• The final answer will be the maximum profit that can be obtained by filling the knapsack with the given items.

Identify missing numbers within the range of smallest and largest elements in an array.

• Find the smallest and largest elements in the array.

• Generate a list of numbers within this range.

• Remove numbers that are present in the array.

• Sort and return the missing numbers.

Using two hour glasses, one emptied in 4 minutes and another in 7 minutes, calculate 9 minutes.

• Start both hour glasses simultaneously

• When the 4-minute hour glass is empty, flip it again

• When the 7-minute hour glass is empty, 4 minutes have passed

• Flip the 7-minute hour glass again and wait for it to empty

• When it's empty, 9 minutes have passed

Given two linked lists that merge at some point, find the data value at the merging node.

• 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 the nodes match to find the merging node

Find the second largest element in an array of integers.

• Iterate through the array to find the largest and second largest elements.

• Handle cases where all elements are identical.

• Return -1 if a second largest element does not exist.

Implementing naming of threads in a multi-threaded OS and implementing rand5 using rand7

• Use thread ID or thread name to name threads in a multi-threaded OS

• Implement a function that generates a random number between 1 and 7

• Use rejection sampling to implement rand5 using rand7

• Ensure thread names are unique to avoid confusion

• Test the implementation thoroughly to ensure correctness

Count the number of subarrays containing only 1s and 0s in a given array of 0s and 1s.

• Iterate through the array and count consecutive 1s and 0s separately.

• Use two variables to keep track of the count of 1s and 0s subarrays.

• Add the counts of 1s and 0s subarrays to get the final result.

Virtual destructors in C++ are used to ensure that the correct destructor is called when deleting an object through a pointer to its base class.

• Virtual destructors are declared in the base class and are used when deleting an object through a pointer to the base class.

• They allow proper destruction of derived class objects.

• Without virtual destructors, only the base class destructor would be called, leading to memory leaks and undefined behavior.

• Virtual destructors are necessary...read more

Use a hash table to store the words and check for existence in constant time.

• Create a hash table with the words as keys and a boolean value as the value.

• For each new word, check if it exists in the hash table. If it does, it has appeared before. If not, add it to the hash table.

• Alternatively, use a set data structure to store only the unique words and check for existence in the set.

The task is to 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 keep track of nodes at each level.

• Consider null nodes as well while traversing the tree.

To measure 45 minutes using two wires of different lengths that burn for one hour when ignited at both ends.

• Ignite one end of the first wire and both ends of the second wire simultaneously.

• After 30 minutes, the second wire will burn out completely.

• At this point, ignite the other end of the first wire.

• When the first wire burns out completely, 45 minutes will have passed.

The first question is about checking if a string formed by concatenating all string fields in a linked list is a palindrome or not.

• Traverse the linked list and concatenate all string fields

• Check if the concatenated string is a palindrome by comparing characters from both ends

• Consider edge cases like empty linked list or single node with an empty string field

Semaphores are synchronization primitives used in operating systems to control access to shared resources.

• Binary semaphore: Can take only two values, 0 and 1. Used for mutual exclusion.

• Counting semaphore: Can take any non-negative integer value. Used for resource allocation.

• Mutex semaphore: A binary semaphore used for mutual exclusion.

• Named semaphore: A semaphore that can be accessed by multiple processes.

• Unnamed semaphore: A semaphore that can only be accessed by threads wit...read more

Merge sort and Quick sort are sorting algorithms used to sort arrays of data.

• Merge sort is a divide and conquer algorithm that divides the input array into two halves, sorts each half recursively, and then merges the sorted halves.

• Quick sort is also a divide and conquer algorithm that selects a pivot element and partitions the array around the pivot, sorting the two resulting sub-arrays recursively.

• Merge sort has a time complexity of O(n log n) and is stable, but requires add...read more

Comparison of heights of two soldiers chosen based on different criteria from a grid of soldiers.

• Soldier A is chosen based on tallest men from every column and shortest among them.

• Soldier B is chosen based on shortest men from every row and tallest among them.

• The height of Soldier A and Soldier B cannot be determined without additional information about the grid of soldiers.

To determine if a point is inside a polygon, use the ray casting algorithm.

• Create a line from the point to a point outside the polygon

• Count the number of times the line intersects with the polygon edges

• If the count is odd, the point is inside the polygon; otherwise, it is outside

To find 2 defective vending machines out of n machines in O(1) time, label each machine with a unique number and use XOR operation.

• Label each machine with a unique number from 1 to n

• Calculate the XOR of all the numbers from 1 to n and the XOR of all the numbers of the working machines

• The result of XORing these two values will give the XOR of the two defective machines

• Find the rightmost set bit in the XOR result, divide the machines into two groups based on that bit, and XOR t...read more

To find and remove a loop in a Linked List, we can use Floyd's Cycle Detection Algorithm.

• Use two pointers, slow and fast, to detect if there is a loop in the Linked List

• If the two pointers meet at some point, there is a loop

• To remove the loop, set one of the pointers to the head of the Linked List and move both pointers one step at a time until they meet again

• The meeting point is the start of the loop, set the next pointer of this node to NULL to remove the loop

To remove unnecessary parenthesis from an expression, we need to apply a set of rules to identify and eliminate them.

• Identify and remove parenthesis around single variables or constants

• Identify and remove parenthesis around expressions with only one operator

• Identify and remove parenthesis around expressions with operators of equal precedence

• Identify and remove parenthesis around expressions with operators of different precedence

• Apply the rules recursively until no more unnece...read more

Distribute 50 white and 100 black eggs in one bag and 50 white and 0 black eggs in the other bag.

• Distribute the black eggs in one bag and white eggs in the other bag

• Ensure that both bags have equal number of white eggs

• The bag with black eggs will have a higher probability of getting a black egg