400+ Paytm Interview Questions and Answers

A puzzle where 100 people shoot the person in front of them until only one person remains.

• Each person shoots the person in front of them and hands the gun to the next to next person.

• This continues until only one person remains.

• The last person standing is the one who was not shot by anyone.

Generate all binary strings of length 'K' with no consecutive '1's in lexicographically increasing order.

• Use backtracking to generate all possible binary strings without consecutive '1's.

• Start with an empty string and recursively add '0' or '1' based on the condition.

• Keep track of the current string and its length to ensure no consecutive '1's are added.

• Sort the generated strings in lexicographically increasing order before outputting.

The task is to find the sum of squares of the first 'N' natural numbers.

• Iterate from 1 to N and calculate the square of each number

• Add all the squares together to get the final sum

• Return the sum as the result

Find the minimum number of coins needed to make up a given amount using specific denominations.

• Iterate through the available denominations in descending order

• For each denomination, calculate the maximum number of coins that can be used

• Subtract the total value of coins used from the amount until amount becomes 0

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.

• Update the head of the reversed linked list as the last node encountered during the reversal process.

The task is to find the length of the longest consecutive sequence in an unsorted array of integers.

• Iterate through the array and store all elements in a set for constant time lookup.

• For each element, check if it is the start of a sequence by looking for element-1 in the set.

• If it is the start, keep incrementing the count until the next element is not found in the set.

Design a stack that supports getMin() operation in O(1) time with O(1) extra space using inbuilt stack data structure.

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

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

• When popping an element, also pop the top element from the minimum stack if it matches the popped element.

• For getMin() operation, simply return th...read more

Verify if a string is a subsequence of another string by checking if characters are retained in order.

• Iterate through both strings simultaneously, checking if characters match in order.

• If a character in STR1 matches a character in STR2, move to the next character in STR2.

• If all characters in STR1 are found in STR2 in order, return True; otherwise, return False.

Implement a search function to find a specified integer in a rotated sorted array with O(logN) time complexity.

• Implement a binary search algorithm to efficiently search for the target integer.

• Handle the rotation of the array by finding the pivot point first.

• Return the index of the target integer if found, else return -1.

• Ensure the time complexity of the search function is O(logN) for each query.

Reorder a singly linked list so that all even-valued nodes appear before odd-valued nodes while preserving the original order.

• Create two separate linked lists for even and odd nodes

• Traverse the original list and move nodes to respective even or odd lists

• Merge the even and odd lists while maintaining the original order

Given two binary trees T and S, determine if S is a subtree of T with the same structure and node values.

• Traverse through tree T and check if any subtree matches tree S

• Use recursion to compare nodes of both trees

• Handle edge cases like null nodes and empty trees

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

• Use dynamic programming to keep track of the number of ways to make change for each value up to the target value.

• Iterate through each denomination and update the number of ways to make change for each value based on the current denomination.

• Handle base cases such as making change for 0 or using only the smallest denomination.

• Consider edge cases like having a single...read more

Given an array, partition it into two subsets to minimize the absolute difference between their sums.

• Use dynamic programming to calculate all possible subset sums.

• Iterate through the subset sums to find the minimum absolute difference.

• Consider all possible partitions of the array elements.

• Example: For input [1, 6, 11, 5], the minimum absolute difference is 1.

• Example: For input [1, 2, 3], the minimum absolute difference is 0.

Implement a function to determine if a numeric string contains a substring whose value equals the product of two consecutive integers.

• Iterate through all substrings of the input string and check if their integer value equals the product of two consecutive integers.

• Use nested loops to generate all possible substrings efficiently.

• Check if the product of two consecutive integers matches the integer value of the substring.

• Return 'True' if any such substring is found, otherwise re...read more

Find nodes at a specific distance from a target node in a binary tree.

• Traverse the binary tree to find the target node.

• Perform a depth-first search to identify nodes at distance K from the target node.

• Return the values of nodes found at distance K in an array.

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

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

• Track the time taken to rot all fresh oranges and return the result.

• If any fresh oranges remain after simulation, return -1 as it is impossible to rot all oranges.

Design a special stack supporting constant time operations like push, pop, top, and getMin.

• Implement a stack using an additional stack to keep track of the minimum element.

• Use two stacks - one to store elements and another to store minimum values.

• Ensure constant time complexity for all operations by maintaining the minimum value at the top of the min stack.

• Example: Push(1), Push(2), getMin() should return 1.

The task is to modify a singly linked list by reversing every alternate 'K' nodes of the linked list.

• Iterate through the linked list in groups of size K, reverse every alternate group

• Handle cases where the number of remaining nodes is less than K

• Update the pointers accordingly to reverse the nodes in the linked list

Find the minimum sum of a falling path through a square array by selecting one element from each row with constraints on column selection.

• Iterate through the array from the second row, updating each element with the minimum sum of the element and its adjacent elements from the previous row.

• The minimum sum path will end in the last row with the minimum value.

• Use dynamic programming to efficiently calculate the minimum falling path sum.

• Example: For input [[5, 10], [25, 15]], th...read more

Given a string and an integer K, create a new string by selecting the smallest character from the first K characters of the input string and repeating the process until the input string is empty.

• Iterate through the input string, selecting the smallest character from the first K characters each time.

• Remove the selected character from the input string and append it to the new string.

• Continue this process until the input string is empty.

• Return the final new string formed.

Count the number of subsequences of length 3 forming a geometric progression with a specified common ratio in an array of integers.

• Iterate through the array and for each element, check for possible subsequences of length 3 with the given common ratio.

• Use a hashmap to store the count of possible subsequences for each element as the middle element.

• Return the total count of subsequences modulo 10^9 + 7.

• Example: For input [2, 4, 8, 16] and common ratio 2, the only subsequence [2,...read more

Group anagrams in an array of strings based on their characters.

• Iterate through each string in the input array/list.

• For each string, sort the characters alphabetically to create a key for grouping.

• Use a hashmap to group strings with the same key.

• Return the grouped anagrams as separate arrays of strings.

Return the middle element of a singly linked list, or the one farther from the head node if there are even elements.

• Traverse the linked list with two pointers, one moving twice as fast as the other

• When the fast pointer reaches the end, the slow pointer will be at the middle

• Return the element pointed to by the slow pointer

Count the number of distinct-element subsets in an array modulo 10^9+7.

• Iterate through the array and keep track of distinct elements using a set.

• Calculate the number of subsets using the formula 2^distinct_count - 1.

• Return the result modulo 10^9+7 for each test case.

Sort an array in wave form where each element is greater than or equal to its adjacent elements.

• Iterate through the array and swap adjacent elements to form a wave pattern.

• Ensure that the first element is greater than or equal to the second element.

• There can be multiple valid wave arrays, so any valid wave array is acceptable.

Reverse a given singly linked list by changing 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

The task is to sort an array of 0s, 1s, and 2s in increasing order.

• Use a three-pointer approach to partition the array into three sections: 0s, 1s, and 2s.

• Initialize three pointers: low, mid, and high. low points to the start of the array, mid points to the current element being processed, and high points to the end of the array.

• While mid <= high, if ARR[mid] is 0, swap ARR[low] and ARR[mid], increment low and mid. If ARR[mid] is 1, increment mid. If ARR[mid] is 2, swap ARR[m...read more

Given a matrix of 1s and 0s, replace 0s surrounded by 1s with 1s.

• Iterate through the matrix and check each 0 surrounded by 1s.

• If a 0 is surrounded by 1s, replace it with 1.

• Update the matrix in place without printing or returning it.

Find the K-th smallest element in a given array of distinct integers.

• Sort the array in ascending order.

• Return the element at index K-1 from the sorted array.

• Handle edge cases like K being out of bounds or array being empty.

Determine the minimum number of moves required to distribute coins in a binary tree so that every node has exactly one coin.

• Traverse the binary tree in a bottom-up manner to distribute coins efficiently.

• Keep track of the excess or deficit of coins at each node to calculate the minimum moves required.

• Transfer coins from nodes with excess coins to nodes with deficits to balance the distribution.

• Example: For the input ROOT = [2, -1, 0, -1, -1], the output is 1 as one move is nee...read more

The 0-1 Knapsack Problem involves maximizing the value of items a thief can steal within a weight limit.

• Use dynamic programming to solve the problem efficiently.

• Create a 2D array to store the maximum value that can be achieved at each weight limit.

• Iterate through the items and weights to fill the array with optimal values.

• Return the maximum value achievable at the given weight limit.

Implement a function to delete a node at a specified position in a linked list.

• Traverse the linked list to find the node at the specified position.

• Update the pointers to skip the node to be deleted.

• Handle edge cases like deleting the head or tail node.

• Return the modified linked list.

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

• Calculate the arithmetic sequence based on the given first term and common difference.

• Check if the given number is part of the calculated sequence.

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

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.

The task is to find the maximum possible sum of a non-empty subarray of an array.

• Iterate through the array and keep track of the maximum sum encountered so far

• If the current element is greater than the sum so far, start a new subarray

• If the current element plus the sum so far is greater than the maximum sum, update the maximum sum

• Return the maximum sum

Find all possible permutations of an array of distinct integers.

• Use backtracking to generate all possible permutations

• Swap elements to create different permutations

• Return the permutations as an array of arrays of integers

Decode a given encoded string back to its original form by repeating the encoded string 'count' times.

• Parse the input string to extract the count and the encoded string within the brackets

• Use recursion to decode the encoded string by repeating it 'count' times

• Handle nested brackets by recursively decoding the inner strings first

The task is to connect N ropes into one rope with minimum cost.

• Sort the array of rope lengths in ascending order.

• Initialize a variable to keep track of the total cost.

• While there are more than one rope, take the two shortest ropes and connect them.

• Add the cost of connecting the two ropes to the total cost.

• Replace the two shortest ropes with the connected rope.

• Repeat the above steps until only one rope remains.

• Return the total cost.

To delete a node in a singly linked list given a reference to the node.

• Traverse the linked list to find the node to be deleted.

• Update the value of the node to be deleted with the value of the next node.

• Point the next pointer of the node to be deleted to the next node's next pointer.

The task is to find the smallest positive integer value that cannot be represented as a sum of elements of any proper subset of the given array.

• The array is sorted in non-decreasing order, so we can iterate through the array and keep track of the maximum sum we can form.

• If the current element is greater than the maximum sum + 1, then the maximum sum + 1 is the smallest positive integer that cannot be represented.

• If all elements in the array can be represented as a sum of subs...read more

Program to compute factorial of a given integer 'n', with error handling for negative values.

• Create a function to calculate factorial using a loop or recursion

• Check if input is negative, return 'Error' if true

• Handle edge cases like 0 and 1 separately

• Return the calculated factorial value

This question asks to find the minimum number of platforms required at a railway station so that no train needs to wait.

• Sort the arrival and departure times arrays in ascending order.

• Initialize a variable 'platforms' to 1 and 'maxPlatforms' to 1.

• Iterate through the arrival and departure times arrays simultaneously.

• If the current arrival time is less than or equal to the current departure time, increment 'platforms'.

• If 'platforms' is greater than 'maxPlatforms', update 'maxPla...read more

Implementing a shuffle function for a playlist of songs

• Create a new empty playlist

• Randomly select a song from the original playlist and add it to the new playlist

• Remove the selected song from the original playlist

• Repeat until all songs have been added to the new playlist

• Return the new shuffled playlist

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

• The diameter of a binary tree can be calculated by finding the maximum of the following three values: 1) the diameter of the left subtree, 2) the diameter of the right subtree, and 3) the longest path that passes through the root node.

• To find the diameter of a binary tree, we can use a recursive approach where we calculate the height of each node and update the diameter at ea...read more

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

• Iterate through the array to find the coverage of each fountain.

• Keep track of the farthest coverage reached by each activated fountain.

• Activate the fountain that covers the farthest distance not yet covered.

• Repeat until the entire garden is watered.

Print nodes of a binary tree in spiral order traversal.

• Use a queue to perform level order traversal.

• Alternate between printing nodes from left to right and right to left at each level.

• Handle null nodes appropriately.

• Example: For input '1 2 3 -1 -1 4 5 -1 -1 -1 -1', output should be '1 3 2 4 5'.

Create a deep copy of a linked list with random pointers.

• Iterate through the original linked list and create a new node for each node in the list.

• Store the mapping of original nodes to their corresponding new nodes in a hashmap.

• Iterate through the list again to set the next and random pointers of the new nodes based on the mapping.

• Return the head of the newly created deep copied linked list.

Create a BSTIterator class for inorder traversal of a binary search tree.

• Implement a constructor that takes the root of the binary search tree and initializes the iterator.

• Implement next() function to return the next smallest element in the inorder traversal.

• Implement hasNext() function to check if there is a next element in the inorder traversal.

• Traverse the binary search tree in inorder to get the desired output.

The task is to find the number of distinct ways to climb from the 0th step to the Nth step, where each time you can climb either one step or two steps.

• Use dynamic programming to solve this problem

• Create an array to store the number of ways to reach each step

• Initialize the first two elements of the array as 1 and 2

• For each subsequent step, the number of ways to reach that step is the sum of the number of ways to reach the previous two steps

• Return the number of ways to reach th...read more

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.

Find the inorder successor of a given node in a binary tree.

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

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

• If the given node does not have a right child, backtrack to the parent nodes to find the successor.

Reorder array to avoid odd numbers at even indices and even numbers at odd indices.

• Swap odd numbers at even indices with the nearest odd number at an odd index.

• Swap even numbers at odd indices with the nearest even number at an even index.

• Maintain counts of odd and even numbers to ensure equal distribution.

The problem involves finding the number of ways to express a given positive integer as a sum of cubes of two integers.

• Iterate through all possible values of A and B within the given constraints.

• Check if A^3 + B^3 equals the given N, increment the count if true.

• Handle the case where A = B separately to avoid counting duplicates.

Ceil value of a key in a Binary Search Tree (BST) is the smallest integer greater than or equal to the given number.

• Traverse the BST to find the closest integer greater than or equal to the given key.

• Compare the key with the current node value and update the ceil value accordingly.

• Recursively traverse left or right subtree based on the key value to find the ceil value.

• Return the ceil value once found for each test case.

Sort an integer array containing only 0s, 1s, and 2s in linear time complexity.

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

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

• Time complexity should be O(N) to solve the problem efficiently.

Delete the middle node of a singly linked list in O(N) time complexity and O(1) space complexity.

• Identify the middle node using slow and fast pointers technique.

• Update the pointers to skip the middle node.

• Handle edge cases like no middle node or two middle nodes.

• Perform the deletion in a single traversal of the linked list.

• Return the modified linked list after deletion.

Identify and return the bottom right view of a given binary tree by viewing it from an angle of 45 degrees from the bottom right side.

• Traverse the binary tree in a right-to-left manner and keep track of the last node encountered at each level.

• Use a queue for level order traversal and update the result array with the last node at each level.

• Return the result array sorted in ascending order as the bottom right view of the binary tree.

Find the minimum distance from a given node to the nearest leaf node in a binary tree.

• Traverse the binary tree from the given node 'X' to find the nearest leaf node using BFS or DFS.

• Keep track of the distance from 'X' to each leaf node encountered during traversal.

• Return the minimum distance found as the output.

Find all unique pairs of elements in an array that add up to a given 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.

Implement quick sort algorithm to sort an array of integers in ascending order.

• Choose a pivot element (e.g., rightmost element) to partition the array into two subarrays.

• Recursively apply quick sort on the subarrays until the entire array is sorted.

• Time complexity can be optimized to NlogN for worst-case scenarios.

Find two lines to form a container with maximum water capacity based on given heights.

• Iterate through the array and use two pointers to find the maximum area.

• Calculate the area using the formula: min(height[left], height[right]) * (right - left).

• Move the pointer with the smaller height towards the center to potentially find a larger area.

Find the total number of distinct paths in a maze with obstacles from top-left to bottom-right cell.

• Use dynamic programming to keep track of the number of paths to reach each cell.

• Handle blocked cells by setting their path count to 0.

• Only move right or down from any given cell to calculate the number of paths.

• Return the total number of valid paths modulo 10^9 + 7.

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 by summing up all transactions.

• Use a recursive algorithm to minimize cash flow by settling debts between friends.

• Update the graph after each settlement and continue until all debts are settled.

• Output the minimized cash flow in a 2-D matrix for each test case.

The task is to find the length of the longest common subsequence between two given strings.

• Implement a function to find the longest common subsequence between two strings.

• Use dynamic programming to solve this problem efficiently.

• Iterate through the strings and build a matrix to store the lengths of common subsequences.

• The value in the bottom-right corner of the matrix will be the length of the longest common subsequence.

Group anagrams together in a list of strings.

• Iterate through the list of strings and sort each string to group anagrams together.

• Use a hashmap to store the sorted string as key and the original string as value.

• Return the values of the hashmap as the grouped anagrams.

Maximize profit by scheduling jobs within their deadlines.

• Sort the jobs array in descending order of profits.

• Iterate through the sorted array and schedule jobs based on deadlines.

• Keep track of completed jobs and their profits to calculate the total profit.

• Return the maximum profit achieved by scheduling jobs within deadlines.

Calculate and print the median after each new integer is added to the stream.

• Use a min heap to store the larger half of the numbers and a max heap to store the smaller half.

• Keep the two heaps balanced by ensuring the size difference is at most 1.

• If the total number of elements is odd, the median is the top of the larger heap. If even, average the tops of both heaps.

The task is to find the Next Greater Element for each element in a list of integers.

• Iterate through the list of integers from right to left

• Use a stack to keep track of elements whose NGE is yet to be found

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

• Assign the NGE as the top element of the stack or -1 if the stack is empty

Determine if two nodes in a binary tree are cousins based on level and parent nodes.

• Traverse the binary tree to find the levels and parents of the given nodes.

• Check if the nodes are at the same level and have different parents to determine if they are cousins.

• Return 'YES' if the nodes are cousins, 'NO' otherwise.

• Example: For input '1 2 3 4 -1 5 6 -1 7 -1 -1 -1 -1 -1 -1' and nodes 4 7, output is 'YES'.

Add two numbers represented by linked lists and return the result as a new linked list.

• Traverse both linked lists simultaneously while adding corresponding elements and carry over the sum if needed

• Handle cases where one linked list is longer than the other

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

Implement Merge Sort algorithm to sort a sequence of numbers in non-descending order.

• Implement the Merge Sort algorithm which involves dividing the array into two halves, sorting each half, and then merging them back together.

• Recursively call the Merge Sort function on each half of the array until the base case of having a single element in the array is reached.

• Merge the sorted halves back together in a new array in non-descending order.

• Ensure to handle the edge cases such as...read more

Implement a function to print the zigzag traversal of a binary tree.

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

• Maintain a flag to switch between printing nodes from left to right and right to left at each level.

• Store nodes at each level in a list and reverse the list if the flag is set to print in zigzag order.

Number of possible BSTs with 2 and 3 nodes.

• For 2 nodes, only 2 BSTs are possible.

• For 3 nodes, 5 BSTs are possible.

• Number of BSTs can be calculated using Catalan numbers formula.

• Catalan(2) = 2, Catalan(3) = 5.

The task is to find the minimum number of characters needed to insert into a given string to make it a palindrome.

• Use dynamic programming to find the longest palindromic subsequence of the given string.

• Subtract the length of the longest palindromic subsequence from the length of the original string to get the minimum insertions required.

• Handle edge cases like an empty string or a string that is already a palindrome.

• Example: For input 'abcaa', the longest palindromic subsequen...read more

The task is to compute the modulus of the difference between the sum of nodes at odd levels and the sum of nodes at even levels in a binary tree.

• Traverse the binary tree level by level and calculate the sum of nodes at odd and even levels separately.

• Find the absolute difference between the sums and return the modulus of this difference.

• Handle null nodes by skipping them during the sum calculation.

The task is to find the minimum number of characters needed to be added to the front of a string to make it a palindrome.

• Iterate through the string from both ends and count the number of characters that need to be added to make it a palindrome.

• Use two pointers approach to compare characters from start and end of the string.

• Keep track of the count of characters needed to be added to form a palindrome.

Find two elements in an unsorted array whose sum is equal to a given number x.

• Use a hash table to store the difference between x and each element in the array.

• Iterate through the array and check if the current element is in the hash table.

• Return the pair of elements that add up to x.

The task is to determine the lexicographically smallest array that can be obtained by performing at most 'K' swaps of consecutive elements.

• Sort the array in non-decreasing order and keep track of the number of swaps made.

• Iterate through the array and swap adjacent elements if it results in a lexicographically smaller array.

• Continue swapping until the maximum number of swaps 'K' is reached or the array is lexicographically smallest.

• Return the final lexicographically smallest a...read more

My favourite app is Spotify. I would like to see improvements in the algorithm for personalized playlists.

• Improved algorithm for personalized playlists

• Better integration with social media platforms

• Option to create collaborative playlists with friends

Rotate a square matrix by 90 degrees in an anti-clockwise direction using constant extra space.

• Iterate through each layer of the matrix from outer to inner layers

• Swap elements in groups of 4 to rotate the matrix

• Handle odd-sized matrices by adjusting the center element if needed

The Colorful Knapsack Problem involves selecting one stone of each color to fill a knapsack with a given weight capacity, minimizing unused capacity.

• Iterate through the stones and keep track of the minimum weight for each color.

• Use dynamic programming to find the optimal solution by considering all possible combinations.

• Handle cases where the knapsack cannot be filled under the given conditions by returning -1.

• In the given example, the optimal solution is to select stones wit...read more

Find the Lowest Common Ancestor (LCA) of two nodes in a Binary Search Tree (BST).

• Traverse the BST from the root node to find the LCA of the given nodes.

• Compare the values of the nodes with the values of P and Q to determine the LCA.

• If the values of P and Q are on opposite sides of the current node, then the current node is the LCA.

The task is to find the maximum amount of money Mr. X can rob from houses arranged in a circle without alerting the police.

• The problem can be solved using dynamic programming.

• Create two arrays to store the maximum amount of money robbed when considering the first house and when not considering the first house.

• Iterate through the array and update the maximum amount of money robbed at each house.

• The final answer will be the maximum of the last element in both arrays.

LRU cache in a database management system stores most recently used data and removes least recently used data when full.

• LRU cache is implemented using a doubly linked list and a hash map.

• Each node in the linked list represents a key-value pair.

• When a key is accessed, it is moved to the front of the linked list.

• If the cache is full, the least recently used node at the end of the list is removed.

• Example: If cache size is 3 and keys accessed in order are A, B, C, D, A, then afte...read more

Find minimum no of platforms required to avoid collision between trains based on their arrival and departure times.

• Sort both arrays in ascending order

• Initialize platform count and max count to 1

• Loop through both arrays and compare arrival and departure times

• If arrival time is less than or equal to departure time, increment platform count

• Else, decrement platform count

• Update max count if platform count is greater than max count

• Return max count

Given an array and a target sum, find a subarray that sums up to the target sum.

• Iterate through the array while keeping track of the running sum and the starting index of the subarray.

• Use a hashmap to store the running sum and its corresponding index.

• If the running sum - target sum is found in the hashmap, it means a subarray with the target sum exists.

• Return the starting and ending indices of the subarray or [-1, -1] if no such subarray exists.

Find all occurrences of a given string in a matrix in all eight possible directions.

• Iterate through each cell in the matrix and check for the starting character of the word.

• For each starting character found, check in all eight directions for the complete word.

• Keep track of the coordinates of each character in the word for each occurrence.

• Print the coordinates of each character for all occurrences found.

• If no occurrences are found, output 'No match found'.

Find the diagonal traversal of a binary tree of integers.

• Traverse the binary tree diagonally using a queue and a map to store nodes at each diagonal level.

• Use a depth-first search approach to traverse the tree and populate the map with nodes at each diagonal level.

• Iterate through the map to get the diagonal traversal of the binary tree.

Given stock prices for 'N' days, find maximum profit with up to two buy-and-sell transactions.

• Iterate through the array of stock prices to find the maximum profit with two transactions

• Keep track of the maximum profit by considering all possible buy and sell combinations

• Ensure to sell the stock before buying again to maximize profit

Find the largest element in a sorted array smaller than or equal to a given integer X.

• Use binary search to efficiently find the floor value of X in the sorted array.

• Compare the middle element of the array with X and adjust the search accordingly.

• Return the element before or equal to X as the floor value, or -1 if no such element exists.

Answering the question about possible trees with two and three nodes.

• For two nodes, there is only one possible tree.

• For three nodes, there are three possible trees.

• The formula for calculating the number of possible trees with n nodes is (2n-3)!!.

• The double exclamation mark represents the double factorial function.

• The double factorial function is defined as n!! = n(n-2)(n-4)...(1 or 2).

Design a Least Recently Used (LRU) cache data structure that supports get and put operations with a given capacity.

• Implement a doubly linked list to keep track of the order of keys based on their recent usage.

• Use a hashmap to store key-value pairs for quick access and updates.

• When capacity is reached, evict the least recently used item before inserting a new one.

• Update the order of keys in the linked list whenever a key is accessed or updated.

Find the Kth smallest and largest elements in an array.

• Sort the array to easily find the Kth smallest and largest elements.

• Ensure K is within the array's size to avoid errors.

• Handle multiple test cases efficiently.

• Consider edge cases like when N is small or K is at the extremes.

Given a sorted N * N matrix, find the position of a target integer 'X'.

• Iterate over rows and columns to search for the target integer 'X'.

• Utilize the sorted nature of the matrix to optimize the search process.

• Return the position of 'X' if found, else return '-1 -1'.

Move all even numbers to the beginning and odd numbers to the end of an array.

• Iterate through the array and swap even numbers to the front and odd numbers to the back.

• Use two pointers, one starting from the beginning and one from the end, to achieve the desired arrangement.

• Return the modified array with even numbers at the start and odd numbers at the end.

Determine if two strings are anagrams of each other by checking if they have the same characters in different order.

• Create a character frequency map for both strings and compare them.

• Sort both strings and compare if they are equal.

• Use a hash table to store character counts and check if they are the same for both strings.

Find the longest palindromic substring in a given string, returning the rightmost one if multiple exist.

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

• Keep track of the longest palindrome found and its starting index

• Return the substring starting from the index of the longest palindrome found

Find the length of the smallest subarray in a given array with sum greater than a given value.

• Iterate through the array while keeping track of the current subarray sum.

• Use two pointers technique to find the smallest subarray with sum greater than X.

• Update the minimum subarray length as you iterate through the array.

• Return the length of the smallest subarray found.

• Example: For ARR = [1, 2, 21, 7, 6, 12] and X = 23, the output is 2.

Market acceptance of new product depends on various factors such as product features, pricing, competition, and marketing strategies.

• Conducting market research to understand customer needs and preferences

• Analyzing competitor products and pricing strategies

• Developing effective marketing campaigns to create awareness and generate interest

• Offering competitive pricing and attractive promotions

• Collecting feedback from early adopters and making necessary improvements

• Monitoring sale...read more