Best Time to Buy and Sell Stock - Practice Coding Problems

Best Time to Buy and Sell Stock - Problem

You're given an array prices where prices[i] represents the price of a stock on the i-th day. Your goal is to maximize profit by choosing a single day to buy one share of stock and a different day in the future to sell that stock.

The key constraint is that you must buy before you sell - you can't sell a stock you don't own! Return the maximum profit you can achieve from this transaction. If no profit is possible, return 0.

Example: If prices = [7,1,5,3,6,4], you should buy on day 2 (price = 1) and sell on day 5 (price = 6) for a profit of 5.

Input & Output

example_1.py — Standard Case

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

› Output: 5

💡 Note: 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.py — No Profit Case

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

› Output: 0

💡 Note: In this case, no transactions are done and the max profit = 0. The prices are continuously decreasing, so any purchase would result in a loss.

example_3.py — Single Element

$ Input: prices = [1]

› Output: 0

💡 Note: Cannot complete any transaction with only one price point, so return 0.

Visualization

Tap to expand

Understanding the Visualization

Track the Valley

Keep track of the lowest point (price) we've seen so far - this is our best buying opportunity

Calculate Peak Profit

At each new point, calculate how much profit we'd make if this were our selling point

Update Records

Update our maximum profit if current profit is better, and update minimum price if current price is lower

Single Pass Success

By the end of our journey, we've found the optimal valley-to-peak combination

Key Takeaway

🎯 Key Insight: Instead of checking all combinations, track the minimum price (best buy point) and calculate profit for each potential sell day in a single pass

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element visited once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables: min_price and max_profit

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
0 ≤ prices[i] ≤ 10⁴
You must buy before you sell (cannot sell on the same day or before buying)

Asked in

a Amazon 47 G Google 42 f Meta 38 ⊞ Microsoft 35 Apple 28

The optimal solution uses a single-pass tracking approach in O(n) time. The key insight is to track the minimum price seen so far as our best buy opportunity, while calculating the profit if we sold on each day. This eliminates the need to check all buy-sell combinations, reducing complexity from O(n²) to O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Try every possible buy-sell combination
One-Pass Tracking (Optimal)	O(n)	O(1)	Track minimum price while calculating maximum profit in single pass

Brute Force (Nested Loops) — Algorithm Steps

For each day i (buy day), iterate through all days j where j > i (sell days)
Calculate profit = prices[j] - prices[i] for each pair
Keep track of the maximum profit found
Return the maximum profit (or 0 if no profit possible)

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Buy Day

Start with day 0 as buy day

Try All Sell Days

Check all future days as potential sell days

Calculate Profit

For each pair, calculate profit = sell_price - buy_price

Track Maximum

Keep track of the highest profit found

Next Buy Day

Move to next buy day and repeat

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int maxProfit(int* prices, int pricesSize) {
    if (pricesSize < 2) return 0;
    
    int maxProfit = 0;
    
    // Try every buy day
    for (int i = 0; i < pricesSize; i++) {
        // Try every sell day after buy day
        for (int j = i + 1; j < pricesSize; j++) {
            int profit = prices[j] - prices[i];
            if (profit > maxProfit) {
                maxProfit = profit;
            }
        }
    }
    
    return maxProfit;
}

int main() {
    int prices[1000];
    int count = 0;
    int price;
    
    while (scanf("%d", &price) == 1) {
        prices[count++] = price;
        if (getchar() == '\n') break;
    }
    
    printf("%d\n", maxProfit(prices, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track maximum profit

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 10⁵
0 ≤ prices[i] ≤ 10⁴
You must buy before you sell (cannot sell on the same day or before buying)

73.9K Views

Very High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler