# Solution For Best Time To Buy And Sell Stock

The Best Time to Buy and Sell Stock problem on LeetCode asks us to find the maximum profit that can be made by buying and then selling a stock with the given prices. In other words, we need to find the difference between the maximum price and the minimum price in the given array of stock prices.

We can solve this problem efficiently by iterating over the price array and keeping track of the minimum price seen so far and the maximum profit that can be made by buying at that minimum price and selling at the current price. We update the maximum profit at each iteration and return it as the final result.

Here is the step by step algorithm to solve this problem:

1. Initialize the minimum price and maximum profit to the first price in the array.
2. Iterate over the remaining prices in the array:
a. If the current price is less than the minimum price seen so far, update the minimum price.
b. Otherwise, calculate the profit that can be made by buying at the minimum price seen so far and selling at the current price. If this profit is greater than the maximum profit seen so far, update the maximum profit.
3. Return the maximum profit as the final result.

Here is the Python code implementation of the above algorithm:

“`python
def maxProfit(prices):
if len(prices) < 2:
return 0

``````min_price = prices
max_profit = 0

for price in prices[1:]:
if price < min_price:
min_price = price
else:
max_profit = max(max_profit, price - min_price)

return max_profit
``````

“`

In this code, we first handle the edge case where the length of the given price array is less than 2. If the input array has only one or no prices, we cannot make any profit, so we return 0.

If we have more than one price in the array, we initialize the minimum price to the first price and the maximum profit to 0. Then we iterate over the remaining prices in the array and update the minimum price and maximum profit at each iteration as described in the algorithm above.

Finally, we return the maximum profit as the result.

The time complexity of this algorithm is O(n) where n is the length of the input array, and the space complexity is O(1) since we only need to store the minimum price and maximum profit.

## Step by Step Implementation For Best Time To Buy And Sell Stock

```class Solution {
public int maxProfit(int[] prices) {
// keep track of the minimum price
int minPrice = Integer.MAX_VALUE;
// keep track of the maximum profit
int maxProfit = 0;

for (int i = 0; i < prices.length; i++) {
if (prices[i] < minPrice) {
// update the minimum price
minPrice = prices[i];
} else if (prices[i] - minPrice > maxProfit) {
// update the maximum profit
maxProfit = prices[i] - minPrice;
}
}

return maxProfit;
}
}```
```Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Note that you cannot sell a stock before you buy one.

Example 1:

Input: [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Not 7-1 = 6, as selling price needs to be larger than buying price.
Example 2:

Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

def maxProfit(prices):

# We need to keep track of the minimum value we've seen so far, as well as the maximum profit

min_val = float('inf')
max_profit = 0

for price in prices:

# Update the minimum value if we've seen a new low

if price < min_val:

min_val = price

# Update the maximum profit if we can get a better one

else:

profit = price - min_val

if profit > max_profit:

max_profit = profit

return max_profit```
```var maxProfit = function(prices) {
// keep track of the minimum price
let minPrice = prices;
// keep track of the maximum profit
let maxProfit = 0;

for (let i = 1; i < prices.length; i++) {
// if the current price is less than the minPrice, update the minPrice
if (prices[i] < minPrice) {
minPrice = prices[i];
} else if (prices[i] - minPrice > maxProfit) {
// else if the current price minus the minPrice is greater than the maxProfit, update the maxProfit
maxProfit = prices[i] - minPrice;
}
}

return maxProfit;
};```
```class Solution {
public:
int maxProfit(vector& prices) {
int minprice = INT_MAX;
int maxprofit = 0;
for (int i = 0; i < prices.size(); i++) {
if (prices[i] < minprice)
minprice = prices[i];
else if (prices[i] - minprice > maxprofit)
maxprofit = prices[i] - minprice;
}
return maxprofit;
}
};```
```public int MaxProfit(int[] prices)
{
int minprice = int.MaxValue;
int maxprofit = 0;
for (int i = 0; i < prices.Length; i++)
{
if (prices[i] < minprice)
minprice = prices[i];
else if (prices[i] - minprice > maxprofit)
maxprofit = prices[i] - minprice;
}
return maxprofit;
}

/*
This code iterates through the array of prices,
keeping track of the minimum value seen so far
and the maximum profit that could be made by
buying at the minimum value and selling at the
current price.
*/```

## Top 100 Leetcode Practice Problems In Java

Get 30% Off Instantly!
[gravityforms id="5" description="false" titla="false" ajax="true"]