Best Time to Buy and Sell Stock II - Practice Coding Problems

Best Time to Buy and Sell Stock II - Problem

Imagine you're a day trader with perfect knowledge of future stock prices! You have an array prices where prices[i] represents the stock price on day i.

Your goal is to maximize profit by buying and selling strategically with these rules:

🔹 You can hold at most one share at any time
🔹 You can buy and sell multiple times
🔹 You can even buy and sell on the same day
🔹 You must buy before you sell

Return the maximum profit you can achieve.

Example: If prices = [7,1,5,3,6,4], you could:

Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 4
Buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 3
Total profit = 7

Input & Output

example_1.py — Basic Case

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

› Output: 7

💡 Note: Buy on day 2 (price = 1) and sell on day 3 (price = 5), profit = 4. Then buy on day 4 (price = 3) and sell on day 5 (price = 6), profit = 3. Total profit = 7.

example_2.py — Increasing Prices

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

› Output: 4

💡 Note: Buy on day 1 (price = 1) and sell on day 5 (price = 5), profit = 4. Alternatively, you can buy and sell every day for the same total profit.

example_3.py — Decreasing Prices

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

› Output: 0

💡 Note: Since prices are always decreasing, no profit can be made. The best strategy is to never buy.

Visualization

Tap to expand

Understanding the Visualization

Identify Price Increases

Scan through prices and find every day where price > previous day's price

Capture Each Profit

For each price increase, add the difference to our total profit

Sum All Gains

The sum of all positive price differences gives us maximum profit

Key Takeaway

🎯 Key Insight: Since we can perform unlimited transactions, the optimal strategy is to capture every single profitable price increase. This greedy approach guarantees maximum profit!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the price array

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space

✓ Linear Space

Constraints

1 ≤ prices.length ≤ 3 × 10⁴
0 ≤ prices[i] ≤ 10⁴
You can perform multiple transactions
You can only hold at most one share at any time

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 25

The optimal greedy approach works by capturing every profitable price increase. Since we can buy and sell multiple times, we simply add up all positive price differences between consecutive days. This gives us O(n) time and O(1) space complexity while guaranteeing maximum profit.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(n)	Recursively try all possible buy/sell decisions for each day
Greedy Approach (Optimal)	O(n)	O(1)	Capture every profitable price increase in a single pass

Brute Force (Try All Combinations) — Algorithm Steps

For each day, track whether we currently own stock
If we don't own stock: try buying today vs doing nothing
If we own stock: try selling today vs doing nothing
Recursively solve for remaining days
Return the maximum profit from all choices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at day 0

We don't own stock, so we can buy or do nothing

Branch into choices

Each day creates multiple branches for different decisions

Explore all paths

Recursively explore every possible sequence of decisions

Return maximum

Compare profits from all paths and return the best

Code -

solution.c — C

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

int backtrack(int* prices, int size, int day, int holding) {
    if (day >= size) {
        return 0;
    }
    
    // Option 1: Do nothing
    int profit = backtrack(prices, size, day + 1, holding);
    
    if (holding) {
        // Option 2: Sell today
        int sellProfit = prices[day] + backtrack(prices, size, day + 1, 0);
        if (sellProfit > profit) profit = sellProfit;
    } else {
        // Option 2: Buy today
        int buyProfit = -prices[day] + backtrack(prices, size, day + 1, 1);
        if (buyProfit > profit) profit = buyProfit;
    }
    
    return profit;
}

int maxProfit(int* prices, int size) {
    return backtrack(prices, size, 0, 0);
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int prices[1000];
    int count = 0;
    char* token = strtok(line, " \n");
    while (token != NULL) {
        prices[count++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    printf("%d\n", maxProfit(prices, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each day we have up to 3 choices (buy/sell/hold), leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth equals the number of days

⚡ Linearithmic Space

Constraints

1 ≤ prices.length ≤ 3 × 10⁴
0 ≤ prices[i] ≤ 10⁴
You can perform multiple transactions
You can only hold at most one share at any time

89.5K Views

Very High Frequency

~15 min Avg. Time

2.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 (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler