Software Engineer

Store the arrival time and departure time and sort them based on arrival time then check if the arrival time of the next train is smaller than the departure time of the previous train if it is smaller then increment the number of the platforms needed otherwise not.

Store the arrival time and departure time in array arr and sort this array based on arrival time
Declare a priority queue(min-heap) and store the departure time of the first train also declare a counter cnt and initialize it with 1.
Iterate over arr from 1 to n-1 
check if the arrival time of the current train is less than or equal to the departure time of the previous train which is kept on top of the priority queue
If true, then push the new departure time and increment the counter cnt
otherwise, we pop() the departure time
push new departure time in the priority queue
Finally, return the cnt.

The idea is to find the pivot point, divide the array into two sub-arrays, and perform a binary search.

The main idea for finding a pivot is – 

For a sorted (in increasing order) and rotated array, the pivot element is the only element for which the next element to it is smaller than it.
Using a binary search based on the above idea, a pivot can be found.
It can be observed that for a search space of indices in the range [l, r] where the middle index is mid, 
If rotation has happened in the left half, then obviously the element at l will be greater than the one at mid.
Otherwise, the left half will be sorted but the element at mid will be greater than the one at r.
After the pivot is found divide the array into two sub-arrays.
Now the individual sub-arrays are sorted so the element can be searched using Binary Search.

The idea is to iterate through the array and for every element arr[i], calculate the sum of elements from 0 to i (this can be done as sum += arr[i]). If the current sum has been seen before, there must be a zero-sum subarray. Hashing is used to store the sum values so that the sum can be stored quickly and find out whether the current sum is seen before or not.

Follow the given steps to solve the problem:

1) Declare a variable sum, to store the sum of prefix elements
2) Traverse the array and at each index, add the element into the sum and check if this sum exists earlier. If the sum exists, then return true
3) Also, insert every prefix sum into a map, so that later on it can be found whether the current sum is seen before or not
4) At the end return false, as no such subarray is found

The idea is to use an auxiliary array. We maintain two pointers one to the leftmost or smallest element and the other to the rightmost or largest element. Move both pointers toward each other and alternatively copy elements at these pointers to an auxiliary array. Finally, Copy the auxiliary array back to the original array.

Ans:- n-1

Ans:- Network model between the tables that connect them

1) Convert all the letters in a sentence to lowercase. 
2) Use String.erase() method on the sentence to erase the white space in between the sentences.
3) Use the reverse method to reverse the sentence. 
4) Checked the sentence reversed the sentence and returned the result.

The idea is to find the Number of ways of Denominations By using the Top Down (memorization).

Algorithm:

Creating a 2-D vector to store the Overlapping Solutions
Keep Track of the overlapping subproblems while Traversing the array coins[]
Recall them whenever needed.

1) Traverse the link list from head to end.
2) For every newly encountered element, check whether it is in the hash table:
if yes, remove it
otherwise put it in the hash table.
3) At the end, the Hash table will contain only the unique elements.