# 121. Best Time to Buy and Sell Stock

## Description

You are given an array prices where prices[i] is the price of a given stock on the ith day.

You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.

Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0.

Example 1:

Input: prices = [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.
Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell.


Example 2:

Input: prices = [7,6,4,3,1]
Output: 0
Explanation: In this case, no transactions are done and the max profit = 0.


Constraints:

• 1 <= prices.length <= 105
• 0 <= prices[i] <= 104

## Solutions

Solution 1: Enumerate + Maintain the Minimum Value of the Prefix

We can enumerate each element of the array $nums$ as the selling price. Then we need to find a minimum value in front of it as the purchase price to maximize the profit.

Therefore, we use a variable $mi$ to maintain the prefix minimum value of the array $nums$. Then we traverse the array $nums$ and for each element $v$, calculate the difference between it and the minimum value $mi$ in front of it, and update the answer to the maximum of the difference. Then update $mi = min(mi, v)$. Continue to traverse the array $nums$ until the traversal ends.

The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.

• class Solution {
public int maxProfit(int[] prices) {
int ans = 0, mi = prices[0];
for (int v : prices) {
ans = Math.max(ans, v - mi);
mi = Math.min(mi, v);
}
return ans;
}
}

• class Solution {
public:
int maxProfit(vector<int>& prices) {
int ans = 0, mi = prices[0];
for (int& v : prices) {
ans = max(ans, v - mi);
mi = min(mi, v);
}
return ans;
}
};

• '''
>>> import math
>>> a = math.inf
>>> a
inf

>>> x = float('-inf')
>>> y = float('inf')
>>> print(x < y)  # Output: True
True
>>>
>>> z = -math.inf
>>> x==z
True

'''
class Solution:
def maxProfit(self, prices: List[int]) -> int:
ans, mi = 0, inf
for v in prices:
mi = min(mi, v)
ans = max(ans, v - mi)
return ans

############

class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
if not prices:
return 0
ans = 0
pre = prices[0]
for i in range(1, len(prices)):
pre = min(pre, prices[i])
ans = max(prices[i] - pre, ans)
return ans


• func maxProfit(prices []int) (ans int) {
mi := prices[0]
for _, v := range prices {
ans = max(ans, v-mi)
mi = min(mi, v)
}
return
}

• function maxProfit(prices: number[]): number {
let ans = 0;
let mi = prices[0];
for (const v of prices) {
ans = Math.max(ans, v - mi);
mi = Math.min(mi, v);
}
return ans;
}


• /**
* @param {number[]} prices
* @return {number}
*/
var maxProfit = function (prices) {
let ans = 0;
let mi = prices[0];
for (const v of prices) {
ans = Math.max(ans, v - mi);
mi = Math.min(mi, v);
}
return ans;
};


• class Solution {
/**
* @param Integer[] $prices * @return Integer */ function maxProfit($prices) {
$win = 0;$minPrice = $prices[0];$len = count($prices); for ($i = 1; $i <$len; $i++) {$minPrice = min($minPrice,$prices[$i]);$win = max($win,$prices[$i] -$minPrice);
}
return \$win;
}
}

• public class Solution {
public int MaxProfit(int[] prices) {
int ans = 0, mi = prices[0];
foreach (int v in prices) {
ans = Math.Max(ans, v - mi);
mi = Math.Min(mi, v);
}
return ans;
}
}

• impl Solution {
pub fn max_profit(prices: Vec<i32>) -> i32 {
let mut res = 0;
let mut min = i32::MAX;
for price in prices {
res = res.max(price - min);
min = min.min(price);
}
res
}
}