Skip to content
Related Articles

Related Articles

Improve Article

Stock Buy Sell to Maximize Profit

  • Difficulty Level : Medium
  • Last Updated : 29 Jul, 2021
 

The cost of a stock on each day is given in an array, find the max profit that you can make by buying and selling in those days. For example, if the given array is {100, 180, 260, 310, 40, 535, 695}, the maximum profit can earned by buying on day 0, selling on day 3. Again buy on day 4 and sell on day 6. If the given array of prices is sorted in decreasing order, then profit cannot be earned at all.

Naive approach: A simple approach is to try buying the stocks and selling them on every single day when profitable and keep updating the maximum profit so far.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
int maxProfit(int price[], int start, int end)
{
 
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    int profit = 0;
 
    // The day at which the stock
    // must be bought
    for (int i = start; i < end; i++) {
 
        // The day at which the
        // stock must be sold
        for (int j = i + 1; j <= end; j++) {
 
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i]) {
 
                // Update the current profit
                int curr_profit = price[j] - price[i]
                                  + maxProfit(price, start, i - 1)
                                  + maxProfit(price, j + 1, end);
 
                // Update the maximum profit so far
                profit = max(profit, curr_profit);
            }
        }
    }
    return profit;
}
 
// Driver code
int main()
{
    int price[] = { 100, 180, 260, 310,
                    40, 535, 695 };
    int n = sizeof(price) / sizeof(price[0]);
 
    cout << maxProfit(price, 0, n - 1);
 
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
static int maxProfit(int price[], int start, int end)
{
 
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    int profit = 0;
 
    // The day at which the stock
    // must be bought
    for (int i = start; i < end; i++)
    {
 
        // The day at which the
        // stock must be sold
        for (int j = i + 1; j <= end; j++)
        {
 
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i])
            {
 
                // Update the current profit
                int curr_profit = price[j] - price[i]
                                + maxProfit(price, start, i - 1)
                                + maxProfit(price, j + 1, end);
 
                // Update the maximum profit so far
                profit = Math.max(profit, curr_profit);
            }
        }
    }
    return profit;
}
 
// Driver code
public static void main(String[] args)
{
    int price[] = { 100, 180, 260, 310,
                    40, 535, 695 };
    int n = price.length;
 
    System.out.print(maxProfit(price, 0, n - 1));
}
}
 
// This code is contributed by PrinciRaj1992

Python3




# Python3 implementation of the approach
 
# Function to return the maximum profit
# that can be made after buying and
# selling the given stocks
def maxProfit(price, start, end):
 
    # If the stocks can't be bought
    if (end <= start):
        return 0;
 
    # Initialise the profit
    profit = 0;
 
    # The day at which the stock
    # must be bought
    for i in range(start, end, 1):
 
        # The day at which the
        # stock must be sold
        for j in range(i+1, end+1):
 
            # If buying the stock at ith day and
            # selling it at jth day is profitable
            if (price[j] > price[i]):
                 
                # Update the current profit
                curr_profit = price[j] - price[i] +\
                            maxProfit(price, start, i - 1)+ \
                            maxProfit(price, j + 1, end);
 
                # Update the maximum profit so far
                profit = max(profit, curr_profit);
 
    return profit;
 
# Driver code
if __name__ == '__main__':
    price = [100, 180, 260, 310, 40, 535, 695];
    n = len(price);
 
    print(maxProfit(price, 0, n - 1));
 
# This code is contributed by Rajput-Ji

C#




// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
static int maxProfit(int []price, int start, int end)
{
 
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    int profit = 0;
 
    // The day at which the stock
    // must be bought
    for (int i = start; i < end; i++)
    {
 
        // The day at which the
        // stock must be sold
        for (int j = i + 1; j <= end; j++)
        {
 
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i])
            {
 
                // Update the current profit
                int curr_profit = price[j] - price[i]
                                + maxProfit(price, start, i - 1)
                                + maxProfit(price, j + 1, end);
 
                // Update the maximum profit so far
                profit = Math.Max(profit, curr_profit);
            }
        }
    }
    return profit;
}
 
// Driver code
public static void Main(String[] args)
{
    int []price = { 100, 180, 260, 310,
                    40, 535, 695 };
    int n = price.Length;
 
    Console.Write(maxProfit(price, 0, n - 1));
}
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
// Javascript implementation of the approach
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
function maxProfit( price, start, end)
{
 
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    let profit = 0;
 
    // The day at which the stock
    // must be bought
    for (let i = start; i < end; i++) {
 
        // The day at which the
        // stock must be sold
        for (let j = i + 1; j <= end; j++) {
 
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i]) {
 
                // Update the current profit
                let curr_profit = price[j] - price[i]
                                  + maxProfit(price, start, i - 1)
                                  + maxProfit(price, j + 1, end);
 
                // Update the maximum profit so far
                profit = Math.max(profit, curr_profit);
            }
        }
    }
    return profit;
}
 
    // Driver program
     
    let price = [ 100, 180, 260, 310,
                    40, 535, 695 ];
    let n = price.length;
 
    document.write(maxProfit(price, 0, n - 1));
     
</script>
Output
865

Efficient approach: If we are allowed to buy and sell only once, then we can use following algorithm. Maximum difference between two elements. Here we are allowed to buy and sell multiple times. 
Following is the algorithm for this problem.  



  1. Find the local minima and store it as starting index. If not exists, return.
  2. Find the local maxima. and store it as an ending index. If we reach the end, set the end as the ending index.
  3. Update the solution (Increment count of buy-sell pairs)
  4. Repeat the above steps if the end is not reached.

C++




// C++ Program to find best buying and selling days
#include <bits/stdc++.h>
using namespace std;
 
// This function finds the buy sell
// schedule for maximum profit
void stockBuySell(int price[], int n)
{
    // Prices must be given for at least two days
    if (n == 1)
        return;
 
    // Traverse through given price array
    int i = 0;
    while (i < n - 1) {
 
        // Find Local Minima
        // Note that the limit is (n-2) as we are
        // comparing present element to the next element
        while ((i < n - 1) && (price[i + 1] <= price[i]))
            i++;
 
        // If we reached the end, break
        // as no further solution possible
        if (i == n - 1)
            break;
 
        // Store the index of minima
        int buy = i++;
 
        // Find Local Maxima
        // Note that the limit is (n-1) as we are
        // comparing to previous element
        while ((i < n) && (price[i] >= price[i - 1]))
            i++;
 
        // Store the index of maxima
        int sell = i - 1;
 
        cout << "Buy on day: " << buy
             << "\t Sell on day: " << sell << endl;
    }
}
 
// Driver code
int main()
{
    // Stock prices on consecutive days
    int price[] = { 100, 180, 260, 310, 40, 535, 695 };
    int n = sizeof(price) / sizeof(price[0]);
 
    // Function call
    stockBuySell(price, n);
 
    return 0;
}
 
// This is code is contributed by rathbhupendra

C




// Program to find best buying and selling days
#include <stdio.h>
 
// solution structure
struct Interval {
    int buy;
    int sell;
};
 
// This function finds the buy sell schedule for maximum profit
void stockBuySell(int price[], int n)
{
    // Prices must be given for at least two days
    if (n == 1)
        return;
 
    int count = 0; // count of solution pairs
 
    // solution vector
    Interval sol[n / 2 + 1];
 
    // Traverse through given price array
    int i = 0;
    while (i < n - 1) {
        // Find Local Minima. Note that the limit is (n-2) as we are
        // comparing present element to the next element.
        while ((i < n - 1) && (price[i + 1] <= price[i]))
            i++;
 
        // If we reached the end, break as no further solution possible
        if (i == n - 1)
            break;
 
        // Store the index of minima
        sol[count].buy = i++;
 
        // Find Local Maxima.  Note that the limit is (n-1) as we are
        // comparing to previous element
        while ((i < n) && (price[i] >= price[i - 1]))
            i++;
 
        // Store the index of maxima
        sol[count].sell = i - 1;
 
        // Increment count of buy/sell pairs
        count++;
    }
 
    // print solution
    if (count == 0)
        printf("There is no day when buying the stock will make profitn");
    else {
        for (int i = 0; i < count; i++)
            printf("Buy on day: %dt Sell on day: %dn", sol[i].buy, sol[i].sell);
    }
 
    return;
}
 
// Driver program to test above functions
int main()
{
    // stock prices on consecutive days
    int price[] = { 100, 180, 260, 310, 40, 535, 695 };
    int n = sizeof(price) / sizeof(price[0]);
 
    // function call
    stockBuySell(price, n);
 
    return 0;
}

Java




// Program to find best buying and selling days
import java.util.ArrayList;
 
// Solution structure
class Interval {
    int buy, sell;
}
 
class StockBuySell {
    // This function finds the buy sell schedule for maximum profit
    void stockBuySell(int price[], int n)
    {
        // Prices must be given for at least two days
        if (n == 1)
            return;
 
        int count = 0;
 
        // solution array
        ArrayList<Interval> sol = new ArrayList<Interval>();
 
        // Traverse through given price array
        int i = 0;
        while (i < n - 1) {
            // Find Local Minima. Note that the limit is (n-2) as we are
            // comparing present element to the next element.
            while ((i < n - 1) && (price[i + 1] <= price[i]))
                i++;
 
            // If we reached the end, break as no further solution possible
            if (i == n - 1)
                break;
 
            Interval e = new Interval();
            e.buy = i++;
            // Store the index of minima
 
            // Find Local Maxima.  Note that the limit is (n-1) as we are
            // comparing to previous element
            while ((i < n) && (price[i] >= price[i - 1]))
                i++;
 
            // Store the index of maxima
            e.sell = i - 1;
            sol.add(e);
 
            // Increment number of buy/sell
            count++;
        }
 
        // print solution
        if (count == 0)
            System.out.println("There is no day when buying the stock "
                               + "will make profit");
        else
            for (int j = 0; j < count; j++)
                System.out.println("Buy on day: " + sol.get(j).buy
                                   + "        "
                                   + "Sell on day : " + sol.get(j).sell);
 
        return;
    }
 
    public static void main(String args[])
    {
        StockBuySell stock = new StockBuySell();
 
        // stock prices on consecutive days
        int price[] = { 100, 180, 260, 310, 40, 535, 695 };
        int n = price.length;
 
        // function call
        stock.stockBuySell(price, n);
    }
}
 
// This code has been contributed by Mayank Jaiswal

Python3




# Python3 Program to find
# best buying and selling days
 
# This function finds the buy sell
# schedule for maximum profit
def stockBuySell(price, n):
     
    # Prices must be given for at least two days
    if (n == 1):
        return
     
    # Traverse through given price array
    i = 0
    while (i < (n - 1)):
         
        # Find Local Minima
        # Note that the limit is (n-2) as we are
        # comparing present element to the next element
        while ((i < (n - 1)) and
                (price[i + 1] <= price[i])):
            i += 1
         
        # If we reached the end, break
        # as no further solution possible
        if (i == n - 1):
            break
         
        # Store the index of minima
        buy = i
        i += 1
         
        # Find Local Maxima
        # Note that the limit is (n-1) as we are
        # comparing to previous element
        while ((i < n) and (price[i] >= price[i - 1])):
            i += 1
             
        # Store the index of maxima
        sell = i - 1
         
        print("Buy on day: ",buy,"\t",
                "Sell on day: ",sell)
         
# Driver code
 
# Stock prices on consecutive days
price = [100, 180, 260, 310, 40, 535, 695]
n = len(price)
 
# Function call
stockBuySell(price, n)
 
# This is code contributed by SHUBHAMSINGH10

C#




// C# program to find best buying and selling days
using System;
using System.Collections.Generic;
 
// Solution structure
class Interval
{
    public int buy, sell;
}
 
public class StockBuySell
{
    // This function finds the buy sell
    // schedule for maximum profit
    void stockBuySell(int []price, int n)
    {
        // Prices must be given for at least two days
        if (n == 1)
            return;
 
        int count = 0;
 
        // solution array
        List<Interval> sol = new List<Interval>();
 
        // Traverse through given price array
        int i = 0;
        while (i < n - 1)
        {
            // Find Local Minima. Note that
            // the limit is (n-2) as we are
            // comparing present element
            // to the next element.
            while ((i < n - 1) && (price[i + 1] <= price[i]))
                i++;
 
            // If we reached the end, break
            // as no further solution possible
            if (i == n - 1)
                break;
 
            Interval e = new Interval();
            e.buy = i++;
            // Store the index of minima
 
            // Find Local Maxima. Note that
            // the limit is (n-1) as we are
            // comparing to previous element
            while ((i < n) && (price[i] >= price[i - 1]))
                i++;
 
            // Store the index of maxima
            e.sell = i - 1;
            sol.Add(e);
 
            // Increment number of buy/sell
            count++;
        }
 
        // print solution
        if (count == 0)
            Console.WriteLine("There is no day when buying the stock "
                            + "will make profit");
        else
            for (int j = 0; j < count; j++)
                Console.WriteLine("Buy on day: " + sol[j].buy
                                + "     "
                                + "Sell on day : " + sol[j].sell);
 
        return;
    }
 
    // Driver code
    public static void Main(String []args)
    {
        StockBuySell stock = new StockBuySell();
 
        // stock prices on consecutive days
        int []price = { 100, 180, 260, 310, 40, 535, 695 };
        int n = price.Length;
 
        // function call
        stock.stockBuySell(price, n);
    }
}
 
// This code is contributed by PrinciRaj1992

Javascript




<script>
       // JavaScript program for the above approach
 
       // This function finds the buy sell
       // schedule for maximum profit
       function stockBuySell(price, n) {
           // Prices must be given for at least two days
           if (n == 1)
               return;
 
           // Traverse through given price array
           let i = 0;
           while (i < n - 1) {
 
               // Find Local Minima
               // Note that the limit is (n-2) as we are
               // comparing present element to the next element
               while ((i < n - 1) && (price[i + 1] <= price[i]))
                   i++;
 
               // If we reached the end, break
               // as no further solution possible
               if (i == n - 1)
                   break;
 
               // Store the index of minima
               let buy = i++;
 
               // Find Local Maxima
               // Note that the limit is (n-1) as we are
               // comparing to previous element
               while ((i < n) && (price[i] >= price[i - 1]))
                   i++;
 
               // Store the index of maxima
               let sell = i - 1;
 
               document.write(`Buy on day: ${buy}   
            Sell on day: ${sell}<br>`);
           }
       }
 
       // Driver code
 
       // Stock prices on consecutive days
       let price = [100, 180, 260, 310, 40, 535, 695];
       let n = price.length;
 
       // Function call
       stockBuySell(price, n);
 
   // This code is contributed by Potta Lokesh
 
   </script>
Output
Buy on day: 0     Sell on day: 3
Buy on day: 4     Sell on day: 6

Time Complexity: The outer loop runs till I become n-1. The inner two loops increment value of I in every iteration. So overall time complexity is O(n)

Valley Peak Approach:

In this approach, we just need to find the next greater element and subtract it from the current element so that the difference keeps increasing until we reach a minimum. If the sequence is a decreasing sequence so the maximum profit possible is 0.

C++




#include <iostream>
using namespace std;
 
// Preprocessing helps the code run faster
#define fl(i, a, b) for (int i = a; i < b; i++)
 
// Function that return
int maxProfit(int* prices, int size)
{
    // maxProfit adds up the difference between
    // adjacent elements if they are in increaisng order
    int maxProfit = 0;
    // The loop starts from 1
    // as its comparing with the previous
    fl(i, 1, size) if (prices[i] > prices[i - 1]) maxProfit
        += prices[i] - prices[i - 1];
    return maxProfit;
}
 
// Driver Function
int main()
{
    int prices[] = { 100, 180, 260, 310, 40, 535, 695 };
    int N = sizeof(prices) / sizeof(prices[0]);
    cout << maxProfit(prices, N) << endl;
    return 0;
}
// This code is contributed by Kingshuk Deb
Output
865

Time Complexity: O(n)
Auxiliary Space: O(1)

Another Approach:

The idea is to find the minimum element in the array and subtract with all elements in the array and find the maximum value.



First, we store the first element of the array in a variable. 
Now compare the first element with all the elements of the array and find the minimum element. 
Then store the minimum element of the array in that variable. 
Then subtract the minimum element with the entire array and find the maximum value and then at last return the max value.

C++




#include <bits/stdc++.h>
using namespace std;
 
int maxProfit(int prices[], int N)
{
    int n = N;
    int cost = 0;
    int maxCost = 0;
 
    if (n == 0)
    {
        return 0;
    }
     
    // Store the first element of array
    // in a variable
    int min_price = prices[0];
 
    for(int i = 0; i < n; i++)
    {
         
        // Now compare first element with all
        // the element of array and find the
        // minimum element
        min_price = min(min_price, prices[i]);
 
        // Since min_price is smallest element of the
        // array so subtract with every element of the
        // array and return the maxCost
        cost = prices[i] - min_price;
 
        maxCost = max(maxCost, cost);
    }
    return maxCost;
}
 
// Driver Code   
int main()
{
   
    // Stock prices on consecutive days
    int prices[] = { 7, 1, 5, 3, 6, 4 };
    int N = sizeof(prices) / sizeof(prices[0]);
     
    cout << maxProfit(prices, N);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

Java




import java.io.*;
import java.util.*;
 
class BuyStock {
 
    public static int maxProfit(int[] prices)
    {
        int n = prices.length;
        int cost = 0;
        int maxCost = 0;
 
        if (n == 0) {
            return 0;
        }
 
        // store the first element of array in a variable
 
        int min_price = prices[0];
 
        for (int i = 0; i < n; i++) {
 
            // now compare first element with all the
            // element of array and find the minimum element
 
            min_price = Math.min(min_price, prices[i]);
 
            // since min_price is smallest element of the
            // array so subtract with every element of the
            // array and return the maxCost
 
            cost = prices[i] - min_price;
 
            maxCost = Math.max(maxCost, cost);
        }
        return maxCost;
    }
   
    // Driver Code
    public static void main(String[] args)
    {
        // stock prices on consecutive days
        int prices[] = { 7, 1, 5, 3, 6, 4 };
        System.out.print(maxProfit(prices));
    }
}

Python3




def maxProfit(prices):
     
    n = len(prices)
    cost = 0
    maxcost = 0
 
    if (n == 0):
        return 0
 
    # Store the first element of
    # array in a variable
    min_price = prices[0]
 
    for i in range(n):
         
        # Now compare first element with all
        # the element of array and find the
        # minimum element
        min_price = min(min_price, prices[i])
 
        # Since min_price is smallest element
        # of the array so subtract with every
        # element of the array and return the
        # maxCost
        cost = prices[i] - min_price
 
        maxcost = max(maxcost, cost)
 
    return maxcost
 
# Driver Code
prices = [ 7, 1, 5, 3, 6, 4 ]
 
# Stock prices on consecutive days
print(maxProfit(prices))
 
# This code is contributed by avanitrachhadiya2155

C#




using System;
 
class BuyStock {
 
    public static int MaxProfit(int[] prices)
    {
        int n = prices.Length;
        int cost = 0;
        int MaxCost = 0;
 
        if (n == 0) {
            return 0;
        }
 
        // store the first element of array in a variable
        int Min_price = prices[0];
 
        for (int i = 0; i < n; i++) {
 
            // now compare first element with all the
            // element of array and find the Minimum element
            Min_price = Math.Min(Min_price, prices[i]);
 
            // since Min_price is smallest element of the
            // array so subtract with every element of the
            // array and return the MaxCost
            cost = prices[i] - Min_price;
 
            MaxCost = Math.Max(MaxCost, cost);
        }
        return MaxCost;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        // stock prices on consecutive days
        int []prices = { 7, 1, 5, 3, 6, 4 };
        Console.Write(MaxProfit(prices));
    }
}
 
// This code is contributed by shivanisinghss2110

Javascript




<script>
 
function maxProfit(prices, N)
{
    let n = N;
    let cost = 0;
    let maxCost = 0;
 
    if (n == 0)
    {
        return 0;
    }
     
    // Store the first element of array
    // in a variable
    let min_price = prices[0];
 
    for(let i = 0; i < n; i++)
    {
         
        // Now compare first element with all
        // the element of array and find the
        // minimum element
        min_price = Math.min(min_price, prices[i]);
 
        // Since min_price is smallest element of the
        // array so subtract with every element of the
        // array and return the maxCost
        cost = prices[i] - min_price;
 
        maxCost = Math.max(maxCost, cost);
    }
    return maxCost;
}
 
// Driver Code
 
    // Stock prices on consecutive days
    let prices = [ 7, 1, 5, 3, 6, 4 ];
    let N = prices.length;
     
    document.write(maxProfit(prices, N));
 
// This code is contributed by Surbhi Tyagi.
</script>
Output
5

Time Complexity: O(n)
Space complexity: O(1)

 

This article is compiled by Ashish Anand and reviewed by the GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :