Maximizing Profit in Stock Buy Sell in Java

It is one of the prominent problems asked in the technical interviews. In this problem, an integer array is given that represents the cost of the stock on different dates. Note that one can purchase and sell the stock any number of times. In this section, we will discuss the maximizing profit problem in a stock buy sell in Java. Let's understand the problem.

Consider the following array.

int arr[] = {50, 90, 130, 155, 20, 267, 347}

Here, the cost of the stock on day 1 is 50. Next day, the cost becomes 90, and 130 on the third day, and so on. Thus, a person can purchase a stock on the first day, and can sell on the fourth day. Thus, the profit becomes 155 - 50 = 105. Again, the stock can be purchased on the fifth day and should be sold on the seventh day. Thus, the profit becomes 347 - 20 = 327, and the total profit becomes 105 + 327 = 432 that is the maximum profit earned.

Approach: Naive

In this approach, a stock is purchased and then sold out every day when it is profitable. Also, one needs to keep track of the maximum profit earned so far. The following program depicts the same.

FileName: MaxProfitStock.java

public class MaxProfitStock
{

// A method that returns the maximized profit
// which can be made after buying and selling
// the stocks given 
public int maximumProfit(int p[], int st, int ed)
{

// If the stocks can not be purchased
if (ed <= st)
{
return 0;
}

// Initializing the profit
int prof = 0;

// Looking for the day at which the stock must
// be purchased
for (int j = st; j < ed; j++)
{

// The day at which the
// stock must be sold
for (int i = j + 1; i <= ed; i++)
{

// If purchasing the stock on the jth day and
// selling it on the ith day is profitable
if (p[i] > p[j])
{

// Updating the current profit
// Suppose i = 6, j = 3, ed = 8, and st = 1
// Then, currProfit is profit found is equal to 
// the profit made when stock is sold on the day 6 and purchased on the day 3
// plus the profit made from the day 1 to the day 5 plus the profit made from 
// the day 7 to the day 8
int currProfit = p[i] - p[j] + maximumProfit(p, st, j - 1) + maximumProfit(p, i + 1, ed);

// Updating the maximum profit found so far
prof = Math.max(prof, currProfit);
}
}
}
return prof;
}

// main method
public static void main(String argvs[])
{
// price of the stock
int price[] = { 50, 90, 130, 155, 20, 267, 347 };
int size = price.length; // computing the size

System.out.println("The price of the stock on different days is: ");

for(int i = 0; i < size; i++)
{
// displaying the stock price
System.out.print(price[i] + " ");
}

System.out.println();
// creating an object of the class MaxProfitStock
MaxProfitStock obj = new MaxProfitStock();

int ans  = obj.maximumProfit(price, 0, size - 1);

System.out.print("The maximum profit earned is: ");

System.out.print(ans);
}
}

Output:

The price of the stock on different days is: 
50 90 130 155 20 267 347 
The maximum profit earned is: 432

Approach: Efficient

In order to make the solution more efficient, we will not be using recursion. In this approach, we will find the local minima and maxima. The local minima will be treated as the starting index, and the local maxima will be treated as the ending index. If local minima do not exist, then return. We will also be updating the solution by updating the count of buy-sell pairs. Observe the following code.

FileName: MaxProfitStock1.java

// important import statement
import java.util.ArrayList;
// for storing the days when to 
// purchase and sell the stock
class Interval 
{
int buy;
int sell;
}
public class MaxProfitStock1
{
// A method that computes the maximum profit using the cost of the stock
void stockBuySell(int p[], int size)
{
// We can not buy and sell the stock on the same day
// Hence, there is no need to proceed further
if (size == 1)
{
System.out.println("No profit is possible as the number of days is equal to 1");
return;
}

int c = 0;

// the solution array
ArrayList<Interval> al = new ArrayList<Interval>();

// Traversing through the given array of price 
int j = 0;
while (j < size - 1) 
{
// Findinng the Local Minima. Note that the limit is (size - 2) as we are
// doing the comparison of the present element to the next element.
while ((j < size - 1) && (p[j + 1] <= p[j]))
{
j = j + 1;
}

// If we reached the end, break as 
// there are no further possible solutions
if (j == size - 1)
{
break;
}

// creating an object of the class interval
Interval in = new Interval();
// Store the index of minima
in.buy = j + 1; 
j = j + 1;


// Find Local Maxima. Note that the limit is (size - 1) as we 
// have to compare to previous element
while ((j < size) && (p[j] >= p[j - 1]))
{
j = j + 1;
}

// storing the index for the maxima
in.sell = j;
al.add(in);

// Incrementing the number of buy or sell
c = c + 1;
}

// displaying the solution
if (c == 0)
{
System.out.println("Buying the stock on any given day will not make the profit.");
}
else
{
int ans = 0;
for (int i = 0; i < c; i++)
{
System.out.println("Buy the stock on day: " + al.get(i).buy
+ "	 "
+ "Sell the stock on day: " + al.get(i).sell);

ans = ans + (p[(al.get(i).sell - 1)] - p[(al.get(i).buy - 1)]);
}



System.out.println("Thus, the total profit is: " + ans);

}



return;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class MaxProfitStock1
MaxProfitStock1 obj = new MaxProfitStock1();

// price of stock on the consecutive days
int p[] = {50, 90, 130, 155, 20, 267, 347};
int size = p.length; // computing the size

System.out.println("The price of the stock on different days is: ");

for(int i = 0; i < size; i++)
{
// displaying the stock price
System.out.print(p[i] + " ");
}

System.out.println("\n");

// method call
obj.stockBuySell(p, size);
}
}

Output:

The price of the stock on different days is: 
50 90 130 155 20 267 347 

Buy the stock on day: 1	 Sell the stock on day: 4
Buy the stock on day: 5	 Sell the stock on day: 7
Thus, the total profit is: 432

Complexity Analysis: The outer-loop runs till j = 0 to size - 1. The two inner loops increment the value of j in each iteration. Therefore, these two inner loops help j to reach size - 1 faster. Therefore, the time complexity of the program is O(size). The program also uses some extra space to store the days where the stock is bought or sold. Thus, the space complexity of the program is O(size), as the number of days cannot exceed the number of elements present in the array.

Approach: Valley Peak

In this approach, we require to look for the next greater element and subtract it from the current element. We do so because the difference keeps on increasing unless we hit a minimum. Note that, we have not used any extra space. The time complexity of this approach still remains O(size).

The following Java program depicts the same.

FileName: MaxProfitStock2.java

public class MaxProfitStock2
{
// A method that computes the maximum profit using the cost of the stock
public int stockBuySell(int p[], int size)
{

// maximumProfit adds up to the difference between the adjacent
// elements, only if they are lying in the ascending order
int maximumProfit = 0;

// The loop begins from 1
// as it is doing comparison with the previous value
for (int j = 1; j < size; j++)
{
if (p[j] > p[j - 1])
{
maximumProfit = maximumProfit + p[j] - p[j - 1];
}
}
return maximumProfit;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class MaxProfitStock2
MaxProfitStock2 obj = new MaxProfitStock2();

// price of stock on the consecutive days
int p[] = {50, 90, 130, 155, 20, 267, 347};
int size = p.length; // computing the size

System.out.println("The price of the stock on different days is: ");

for(int i = 0; i < size; i++)
{
// displaying the stock price
System.out.print(p[i] + " ");
}

System.out.println("\n");

// invoking the method stockBuySell()
obj.stockBuySell(p, size);

int ans  = obj.stockBuySell(p, size);

System.out.print("The maximum profit earned is: ");

System.out.print(ans);

}
}

Output:

The price of the stock on different days is: 
50 90 130 155 20 267 347 
The maximum profit earned is: 432

Note 1: If the prices of the stock are arranged in descending order. Then, one cannot earn a profit.

For example:

int p[] = { 800, 795, 505, 440, 311, 261, 181, 101, 40, 5};

The cost of a stock is decreasing day by day. Therefore, if a person purchases a stock on a day, then any day after the stock has been purchased will have the cost of the stock less than the purchased cost. Hence, one will bear a loss.

Note 2: There can be many variations of this problem. One of the variations is to maximize the profit when a stock is allowed to be sold and bought only one time. Now, this problem is similar to the problem where one has to find the maximum difference between two elements, where the element of the higher value comes after the element of the smaller value.

If we take the price of the stock on consecutive days as int p[] = {50, 90, 130, 155, 20, 267, 347}, then the maximum profit for one time buy and sell is 347 - 20 = 327.

FileName: MaxProfitStock3.java

public class MaxProfitStock3
{
// A method that computes the maximum profit using the cost of the stock
public int stockBuySell(int p[], int size)
{

// for storing the maximum profit
int maximumProfit = 0;

int maxCost = 0;
for (int j = size - 1; j >= 0; j--)
{

maxCost = Math.max(maxCost, p[j]);
maximumProfit = Math.max(maximumProfit, maxCost - p[j]);

}
return maximumProfit;
}

// main method
public static void main(String argvs[])
{
// creating an object of the class MaxProfitStock3
MaxProfitStock3 obj = new MaxProfitStock3();

// price of stock on the consecutive days
int p[] = {50, 90, 130, 155, 20, 267, 347};
int size = p.length; // computing the size

System.out.println("The price of the stock on different days is: ");

for(int i = 0; i < size; i++)
{
// displaying the stock price
System.out.print(p[i] + " ");
}

System.out.println("\n");
// invoking the method stockBuySell()
obj.stockBuySell(p, size);
int ans  = obj.stockBuySell(p, size);
System.out.print("The maximum profit earned is: ");
System.out.print(ans);

}
}

Output:

The price of the stock on different days is: 
50 90 130 155 20 267 347 
The maximum profit earned is: 327

Similarly, one can write the code to maximize the profit when the buying and selling of a stock are allowed at most two times, or at most three times, and so on.

Next TopicPermutation Coefficient in Java

← prev next →