Stocks are profitable
You are given an array/list 'prices' where the elements of the array represent the prices of the stock as they were yesterday and indices of the array represent minutes. Your task is to find and return the maximum profit you can make by buying and selling the stock. You can buy and sell the stock only once.

Note:

You can’t sell without buying first.

For Example:

For the given array [ 2, 100, 150, 120], The maximum profit can be achieved by buying the stock at minute 0 when its price is Rs. 2 and selling it at minute 2 when its price is Rs. 150. So, the output will be 148.

Input Format:

The first line contains a single integer ‘T’ denoting the number of test cases to be run. Then the test cases follow. The first line of each test case contains a single integer ‘N’, representing the size of the array. The second line of each test case contains ‘N’ space-separated integers representing the elements of the given array.

Output Format:

For each test case, print a single integer representing the maximum profit you can achieve. If the maximum profit is negative, print 0. Output for each test case will be printed in a separate line.

Note :

You are not required to print anything, it has already been taken care of. Just implement the function.

Constraints:

1

Question

Stocks are profitable

You are given an array/list 'prices' where the elements of the array represent the prices of the stock as they were yesterday and indices of the array represent minutes. Your task is to find and return the maximum profit you can make by buying and selling the stock. You can buy and sell the stock only once.

Note:

You can’t sell without buying first.

For Example:

For the given array [ 2, 100, 150, 120],
The maximum profit can be achieved by buying the stock at minute 0 when its price is Rs. 2 and selling it at minute 2 when its price is Rs. 150.
So, the output will be 148.

Input Format:

The first line contains a single integer ‘T’ denoting the number of test cases to be run. Then the test cases follow.

The first line of each test case contains a single integer ‘N’, representing the size of the array.

The second line of each test case contains ‘N’ space-separated integers representing the elements of the given array.

Output Format:

For each test case, print a single integer representing the maximum profit you can achieve. If the maximum profit is negative, print 0.

Output for each test case will be printed in a separate line.

Note :

You are not required to print anything, it has already been taken care of. Just implement the function.

Constraints:

1 <= T <= 10
2 <= N <= 10^4
1 <= ARR[i] <= 10^9

Time Limit: 1 sec.

Accepted Answer

Brute Force

We will check all the possible ways of buying and selling stocks. We will fix the time we are buying the stock and check all the possible minutes we can sell this stock and update the maximum profit we can get. Now we will take the maximum profit for all the possible buying time and that would be our final maximum profit.

Algorithm:

Initialize an integer variable ‘maxProfit’ to store the maximum profit we can achieve and initialize it with 0. Since if the maximum profit is negative we have to return 0.
Now iterate over the array.
1. Consider the current index as the buying minute.
2. Now for this buying minute iterate over all the minutes after that(when we can sell the stock)
  1. Store the maximum profit in a variable called ‘CurMaxProfit’.
3. Then take the maximum of all the ‘CurMaxProfit’ and store it in the ‘MaxProfit’ variable
Finally, return the ‘MaxProfit’ value.

Space Complexity: O(1)Explanation:

O(1)

Constant space is used.

Time Complexity: O(n^2)Explanation:

O(N^2), where ‘N’ is the size of the array.

Since we are iterating over all the possible buying time and for each we are considering all the selling time, the final time complexity will be O(N^2).

Python (3.5)

'''
    Time Complexity: O(N^2)
    Space Complexity: O(1)

    Where N is the size of the array.
'''

def maximumProfit(prices):
    
    # Variable to store the maximum profit.
    maxProfit = 0
    n = len(prices)
    
    # Iterating over the array for the buying price.
    for i in range(n - 1):
        
        '''
                Variables to store current buying price and
                maximum profit for if we buy stock at this minute.
        '''
        buy = prices[i]
        curMaxProfit = 0
        
        '''
                Iterating over the next minutes for selling price,
                and storing the maximum profit we can get in curMaxProfit.
        '''
        for j in range(i + 1, n):
            curMaxProfit = max(curMaxProfit, (prices[j] - buy))
            
        '''
                Taking the maximum of all the curMaxProfit and
                storing it in the maxProfit variable.
        '''
        maxProfit = max(maxProfit, curMaxProfit)
        
    return maxProfit

C++ (g++ 5.4)

/*
    Time Complexity: O(N^2)
    Space Complexity: O(1)

    Where N is the size of the array.
*/

int maximumProfit(vector &prices){

    // Variable to store the maximum profit.
    int maxProfit = 0;
    int n = prices.size();
    
    // Iterating over the array for the buying price.
    for(int i = 0;i < n - 1 ; i++){

        /*
            Variables to store current buying price and 
            maximum profit for if we buy stock at this minute.
        */
        int buy = prices[i], curMaxProfit = 0;

        /*
            Iterating over the next minutes for selling price,
            and storing the maximum profit we can get in curMaxProfit.
        */
        for(int j = i + 1; j < n; j++){
            curMaxProfit = max(curMaxProfit, (prices[j] - buy) );
        }

        /*
            Taking the maximum of all the curMaxProfit and 
            storing it in the maxProfit variable.
        */
        maxProfit = max(maxProfit, curMaxProfit);
    }

    return maxProfit;
}

Java (SE 1.8)

/*

    Time Complexity: O(N^2)

    Space Complexity: O(1)



    Where N is the size of the array.

*/



import java.util.ArrayList;



public class Solution {

    public static int maximumProfit(ArrayList prices) {



        // Variable to store the maximum profit.

        int maxProfit = 0;

        int n = prices.size();



        // Iterating over the array for the buying price.

        for (int i = 0; i < n - 1; i++) {



            /*

                Variables to store current buying price and

                maximum profit for if we buy stock at this minute.

            */

            int buy = prices.get(i), curMaxProfit = 0;



            /*

                Iterating over the next minutes for selling price,

                and storing the maximum profit we can get in curMaxProfit.

            */

            for (int j = i + 1; j < n; j++) {

                curMaxProfit = Math.max(curMaxProfit, (prices.get(j) - buy));

            }



            /*

                Taking the maximum of all the curMaxProfit and

                storing it in the maxProfit variable.

            */

            maxProfit = Math.max(maxProfit, curMaxProfit);

        }



        return maxProfit;

    }

}

Accepted Answer

Optimised Brute Force

We will iterate over the array and as we go along we will update the buying price as the minimum of the prices till now and will also update the ‘MaxProfit’ variable if selling at this time is more profitable.

Algorithm:

Initialize a variable ‘BUY’ to store the buying price and ‘MaxProfit’ to store the maximum profit we can achieve.
Now we will iterate over the array.
1. If the current price is less than our buying price, we will update that.
2. Else if selling at this minute gives us more profit, then we will update our ‘MaxProfit’ variable as ‘Prices[i]’ - ‘BUY’.
Finally, return the ‘MaxProfit’ variable.

Space Complexity: O(1)Explanation:

O(1).

Constant space is used.

Time Complexity: O(n)Explanation:

O(N), where ‘N’ is the size of the array.

Since we are simultaneously updating our buying and selling time by iterating only once, the time complexity will be O(N).