SDE - 1

Algorithm: 
Step 1 . Create an empty queue Q. 
Step 2. Find all rotten oranges and add them to Q. 
Step 3. Run a loop While Q is not empty
Step 4. Do following till Q is not empty 
Step 5. pop an orange from the queue, rot all adjacent oranges. While rotting the adjacent, make sure that the time is incremented by one if there are adjacent oranges and add them in the Q.
Step 6. Just find minimum time you got from Q, for each Orange U got from Q.

Considering N- size of Linked List

Step -1: First check if k iis greator than the N if it is then first update value of k as ::

k = k%N;

Step - 2 : Now go to kth node
Step - 3 : we need to change the next of kth node to NULL, the next of the last node to the previous head node, and finally, change the head to (k+1)th node. So we need to get hold of three nodes: kth node, (k+1)th node, and last node. 
Now we got two linked list 
1- which have nodes upto kth nodes
2- which have nodes after kth nodes.

Step 4 :Just attach the first Linked lIst to second Linked list.

Explanation : Let's take an example

Petrol_Pump = [1, 2, 3, 4, 5]

Distance = [3, 4, 5, 1, 2]

ind = [0, 1, 2, 3, 4]

Now we will find difference the betweeen Petrol_Pump[i] - Distance[i] = [-2, -2, -2, 3, 3] ===> (sum of all values) ==>0 and if it means solution is exists or else we will return -1

lets take tank as a capacity for storing water as a 0.
if i = 0, index = 0 at that time we will do tank += Petrol_Pump[i] - Distance[i]

if(tank < 0) it means we can't get the result for previous indexes, So we will update to i+1

And at last we will check if total < 0 we will return -1 else we will return our updated index.

So, we calculate the consumption of travel from one Petrol_Pump station to other. If the fuel in tank is less than 0, then reset to zero, because the Petrol_Pump as start cannot support the problem. So, change the start index. And also, calculate the total consumption, so that no need of iteration in clockwise is needed. If total is still negative, then no answer

In this problem I just had to tell them my approach and there was discussion on my approach.

I used two stacks here one to store actual stack elements ( Elements_Stack ) and the other as an extra stack (Min_Stack) to store minimum elements. we maintain push() and pop() operations in such a way that the top of the Min_Stack is provides the minimum element. 

Push(int x) // inserts an element x to Min_Stack 
1) push x to the Elements_Stack
2) compare x with the top element of the Min_Stack. Let the top element be y. 
…..a) If x is smaller than y then push x to the Min_Stack. 
…..b) If x is greater than y then push y to the Min_Stack.
int Pop() // removes an element from Min_Stack and return the removed element 
1) pop the top element from the Min_Stack. 
2) pop the top element from the Elements_Stack and return it.
Step 1 is necessary to make sure that the Min_Stack is updated for future operations.
int getMin() // returns the minimum element from Special Stack 
1) Return the top element of the Min_Stack.

The problem is solvable by dynamic programming. The approach that I used to solve it is as follows:

Step 1: Initialize a grid of m x n with zeros.
Step 2: the rightmost colum and bottom row with 1's, which denotes that there are only one path from those locations to the bottom-right corner.
Step 3: Calculate the number of paths for each cell of the grid from the second to the last row and column to the top row and the leftmost column. This is done by summing up the cell values from below and right of a particular cell.
Step 4: Pick up the value from the grid[0][0], which now contains the total number of paths from origin to the bottom-right corner.

Tip 1: Go through the GFG OS section.

Tip 1 : MUST have good understanding of ACID properties , normalisation, how to perform Joins in table and practice Queries

Tip 1 : Must know what have you written in your Resume

Tip 1 : have some prior Knowledge about company