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 byuing 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 byuing 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 byuing 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 byuing 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 byuing 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 algorithm for this problem.
- Find the local minima and store it as starting index. If not exists, return.
- Find the local maxima. and store it as ending index. If we reach the end, set the end as ending index.
- Update the solution (Increment count of buy sell pairs)
- Repeat the above steps if 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]); // Fucntion 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]); // fucntion 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; // fucntion 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) # Fucntion 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; // fucntion call stock.stockBuySell(price, n); } } // This code is contributed by PrinciRaj1992 |
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)
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
the element 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 |
5
Time Complexity: O(n)
Space complexity: O(1)
This article is compiled by Ashish Anand and reviewed by 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.