Best Time to Buy and Sell Stock: Optimal Solution (Data-Backed Guide)

The Data: Why This Problem Gets Asked Everywhere

Best Time to Buy and Sell Stock is not just a LeetCode warm-up. It's an interview staple across every tier of company — from FAANG giants to quant hedge funds to unicorn startups.

Why is this problem so universally popular? Because it tests a fundamental interviewing skill: can you convert a naive O(n²) brute force into a clean O(n) one-pass scan? This "track the minimum so far" technique appears across dozens of harder problems. Mastering it here unlocks a whole family of solutions.

Problem Statement

LeetCode #121 — Best Time to Buy and Sell Stock

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. If you cannot achieve any profit, return 0.

Input:  prices = [7, 1, 5, 3, 6, 4]
Output: 5
Explanation: Buy on day 2 (price=1), sell on day 5 (price=6). Profit = 6 - 1 = 5.

Input:  prices = [7, 6, 4, 3, 1]
Output: 0
Explanation: Prices only decrease. No profitable transaction possible.

Input:  prices = [2, 4, 1]
Output: 2
Explanation: Buy on day 1 (price=2), sell on day 2 (price=4). Profit = 4 - 2 = 2.

Approach 1: Brute Force O(n²)

The naive instinct is to check every possible buy-sell pair and track the maximum profit.

def maxProfit(prices):
    max_profit = 0

    for i in range(len(prices)):
        for j in range(i + 1, len(prices)):
            profit = prices[j] - prices[i]
            max_profit = max(max_profit, profit)

    return max_profit

What to say in the interview: "A brute force approach would be to try every buy-sell pair — O(n²) time. But we don't need to revisit old prices if we track the minimum price seen so far. That gives us O(n) time in a single pass."

Approach 2: Optimal One-Pass Greedy O(n)

The key insight: as you scan left to right, you want to buy at the lowest price seen so far and sell at the highest price after that buy point.

You don't need to look back. At every new price, you ask two questions:

1. Is this price lower than my current minimum? If yes — update min_price. This is now my best buy point.
2. Is current_price - min_price greater than my current best profit? If yes — update max_profit.

That's it. One pass, two variables.

Visual Walkthrough

Tracing prices = [7, 1, 5, 3, 6, 4]:

Final answer: 5. Buy at price 1 (day 1), sell at price 6 (day 4).

Code in Python, Java & JavaScript

def maxProfit(prices: list[int]) -> int:
    min_price = float('inf')
    max_profit = 0

    for price in prices:
        if price < min_price:
            min_price = price           # found a cheaper buy point
        elif price - min_price > max_profit:
            max_profit = price - min_price  # found a better profit

    return max_profit

class Solution {
    public int maxProfit(int[] prices) {
        int minPrice = Integer.MAX_VALUE;
        int maxProfit = 0;

        for (int price : prices) {
            if (price < minPrice) {
                minPrice = price;
            } else if (price - minPrice > maxProfit) {
                maxProfit = price - minPrice;
            }
        }

        return maxProfit;
    }
}

/**
 * @param {number[]} prices
 * @return {number}
 */
var maxProfit = function(prices) {
    let minPrice = Infinity;
    let maxProfit = 0;

    for (const price of prices) {
        if (price < minPrice) {
            minPrice = price;
        } else if (price - minPrice > maxProfit) {
            maxProfit = price - minPrice;
        }
    }

    return maxProfit;
};

Complexity Analysis

This is the best achievable complexity for this problem. You must examine every price at least once, so O(n) time is optimal. The O(1) space is a bonus — this solution is strictly better than brute force in time with no space penalty.

Interview-ready explanation: "Time is O(n) because we do a single pass over the array with constant work at each step. Space is O(1) because we only maintain two scalar variables — no auxiliary data structures."

All 6 Follow-Up Variants You Must Know

The stock problem is actually a series of 6 LeetCode problems. Interviewers at companies like Goldman Sachs, Google, and Amazon commonly ask follow-ups after you solve #121. Know all of them.

Variant 1: Multiple Transactions Allowed (LeetCode #122)

"What if you could buy and sell on multiple days?"

Insight: Capture every upward slope. Add price - prev_price to profit whenever it's positive.

def maxProfit(prices):
    profit = 0
    for i in range(1, len(prices)):
        if prices[i] > prices[i - 1]:
            profit += prices[i] - prices[i - 1]
    return profit

Variant 2: At Most 2 Transactions (LeetCode #123)

"What if you could complete at most 2 transactions?"

Insight: Track four states — after 1st buy, after 1st sell, after 2nd buy, after 2nd sell. Use DP with these states.

def maxProfit(prices):
    buy1 = buy2 = float('-inf')
    sell1 = sell2 = 0

    for price in prices:
        buy1  = max(buy1,  -price)
        sell1 = max(sell1,  buy1  + price)
        buy2  = max(buy2,   sell1 - price)
        sell2 = max(sell2,  buy2  + price)

    return sell2

Variant 3: At Most K Transactions (LeetCode #188)

"What if you could complete at most k transactions?"

Insight: Generalize the 2-transaction DP to k states. Use a DP table of size k x n. Handle the edge case k >= n//2 (equivalent to unlimited transactions).

Variant 4: With Cooldown (LeetCode #309)

"What if after selling, you must wait 1 day before buying again?"

Insight: Track three states — held (stock in hand), sold (just sold today), rest (cooldown or idle). Transition between states each day.

Variant 5: With Transaction Fee (LeetCode #714)

"What if each transaction incurs a fee?"

Insight: Same as unlimited transactions (#122) but subtract fee on each sell. Two states: cash (no stock held), held (holding stock).

Variant 6: Can You Prove the Greedy? (LC #122 Follow-Up)

"Can you prove the greedy is optimal for unlimited transactions?"

Insight: Any multi-day profit can be decomposed into sum of consecutive daily gains. Capturing every positive day-to-day delta is equivalent to any optimal multi-buy strategy.

The Bigger Pattern: When to Use This Technique

The "track minimum/maximum so far" pattern from LC #121 appears across many other problems. Once you internalize it here, you'll recognize it immediately elsewhere.

• Maximum Subarray (LC #53) — track running sum, reset when negative (Kadane's Algorithm)
• Trapping Rain Water (LC #42) — track max from left, max from right at each position
• Jump Game (LC #55) — track max reachable index as you scan forward
• Gas Station (LC #134) — track total surplus and minimum surplus point
• Maximum Product Subarray (LC #152) — track both max and min product (negatives can flip sign)

How to Actually Remember This

With 199 appearances across 63 companies, you will encounter this problem or one of its 6 variants in a real interview. Seeing the code once isn't enough — you need to retrieve it fluently under pressure.

Track all 6 stock variants together on DSAPrep.dev. Tag them under Greedy and Dynamic Programming and the spaced repetition system will surface them at exactly the right intervals — so you don't review too early (wasted effort) or too late (already forgotten).

One problem at a time. One review at a time. Future you will thank present you.