How do you approach Best Time to Buy and Sell Stock?

Track the minimum price seen so far as you iterate.

What is the time complexity of Best Time to Buy and Sell Stock?

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

What are common mistakes on Best Time to Buy and Sell Stock?

Assuming the locally best choice is globally best with no exchange argument. If you cannot state why it holds, it is probably a DP problem. Sorting by the wrong key - by start time where the proof needs end time is the interval-scheduling classic. Missing the case where two greedy choices tie and the tiebreak decides correctness.

gitGood.dev

← Back to problems

Best Time to Buy and Sell Stock

EasyAlgorithms

Description

You are given an array `prices` where `prices[i]` is the price of a given stock on the `i`th 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.

Example 2

Input: prices = [7,6,4,3,1]

Output: 0

Explanation: No transactions are done, max profit = 0.

Constraints

- 1 <= prices.length <= 10^5 - 0 <= prices[i] <= 10^4

Best Time to Buy and Sell Stock: approach, complexity and pitfalls

An easy greedy problem, graded against 7 test cases (4 of them hidden).

The pattern: Greedy

Take the locally best option each step and prove it stays globally optimal.

Reach for it when you see: Interval scheduling, jump/reachability questions, or an optimisation with an obvious local choice.

More Greedyproblems →

If you are stuck

Show the 3-step hint ladder

Track the minimum price seen so far as you iterate.
At each day, calculate the profit if you sold today (current price - min price so far).
Keep track of the maximum profit seen.

The optimal approach

Show the approach: One Pass

Keep track of the minimum price seen so far and the maximum profit. For each price, update the minimum and check if selling at the current price gives a better profit.

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

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.

Common Greedy mistakes

These apply to the pattern as a whole, not just this problem.

Assuming the locally best choice is globally best with no exchange argument. If you cannot state why it holds, it is probably a DP problem.
Sorting by the wrong key - by start time where the proof needs end time is the interval-scheduling classic.
Missing the case where two greedy choices tie and the tiebreak decides correctness.