Stock Buy and Sell - Visualization

Arrays

Contents

VisualizationProblemExamplesSolutionAlgorithmCodeTimeSpace

Visualization Player

Problem Statement❯

Given an array prices, where prices[i] represents the stock price on the ith day, your task is to find the maximum profit you can achieve by choosing a single day to buy one stock and a different day in the future to sell that stock.

  • You must buy the stock before you sell it.
  • If there is no way to make a profit, return 0.

Examples❯

Input Prices Maximum Profit Description
[7, 1, 5, 3, 6, 4] 5 Buy at 1 and sell at 6 (6 - 1 = 5)Visualization
[7, 6, 4, 3, 1] 0 Prices continuously decline — no profit is possibleVisualization
[1, 2, 3, 4, 5] 4 Buy at 1 and sell at 5 — increasing pricesVisualization
[2, 4, 1, 5] 4 Buy at 1 and sell at 5Visualization
[5] 0 Only one price — no possible transactionVisualization
[] 0 Empty array — no data to work withVisualization

Solution❯

Understanding the Problem

We are given an array of stock prices, where each element represents the price of a stock on a particular day. Our goal is to find the best day to buy and the best day to sell the stock to maximize profit. However, we are allowed to make this transaction only once, and we must buy the stock before we sell it.

In simple terms, we want to choose two days: one for buying and one for selling. The profit is the difference between the selling price and the buying price. If no profit is possible (i.e., prices only go down), we return 0.

Step-by-Step Solution with Explanation

1. Track the Minimum Price

As we go through the list, we will keep track of the lowest price we’ve seen so far. This will represent the best day to buy so far.

2. Calculate Profit

At each step, we calculate the profit if we were to sell the stock on that day, using the lowest price we've seen before. If this profit is greater than the best profit we’ve recorded, we update our best profit.

3. Use Example for Better Understanding

Let’s understand this with a beginner-friendly example: [7, 1, 5, 3, 6, 4]

  • Day 1: Price = 7 → minPrice = 7
  • Day 2: Price = 1 → minPrice = 1 (found a cheaper buy)
  • Day 3: Price = 5 → profit = 5 - 1 = 4 → maxProfit = 4
  • Day 4: Price = 3 → profit = 3 - 1 = 2 → maxProfit remains 4
  • Day 5: Price = 6 → profit = 6 - 1 = 5 → maxProfit = 5
  • Day 6: Price = 4 → profit = 4 - 1 = 3 → maxProfit remains 5

Result: Best profit is 5 (Buy at 1, sell at 6)

Handling Edge Cases

Case 1: Prices Only Go Down

Example: [7, 6, 4, 3, 1]
The price keeps dropping. Any buy-sell pair results in a loss. So, the maximum profit is 0.

Case 2: Constant or Steady Increase

Example: [1, 2, 3, 4, 5]
Here, buying at day 1 and selling at day 5 gives the best result: profit = 5 - 1 = 4.

Case 3: Single Price

Example: [10]
We can’t sell if we buy on the only day available. So, the profit is 0.

Case 4: Empty Array

There are no prices at all, so no transaction can be made. The answer is 0.

Algorithm Steps❯

  1. Given an array prices where prices[i] represents the price of a stock on the ith day.
  2. Initialize min_price to a very large number and max_profit to 0.
  3. Traverse through the array:
  4. → If prices[i] is less than min_price, update min_price.
  5. → Else, calculate the profit by prices[i] - min_price and update max_profit if it is greater.
  6. After the loop, return max_profit.

Code

C
C++
Python
Java
JS
Go
Rust
Kotlin
Swift
TS
#include <stdio.h>
#include <limits.h>

int maxProfit(int prices[], int size) {
    int minPrice = INT_MAX;
    int maxProfit = 0;
    for (int i = 0; i < size; i++) {
        if (prices[i] < minPrice)
            minPrice = prices[i];
        else if (prices[i] - minPrice > maxProfit)
            maxProfit = prices[i] - minPrice;
    }
    return maxProfit;
}

int main() {
    int prices[] = {7, 1, 5, 3, 6, 4};
    int size = sizeof(prices) / sizeof(prices[0]);
    printf("Max Profit: %d\n", maxProfit(prices, size));
    return 0;
}

Time Complexity❯

CaseTime ComplexityExplanation
Best CaseO(n)Even in the best case (increasing prices), the algorithm must scan all elements to compute maximum profit.
Average CaseO(n)The algorithm performs a single pass over the array to track the minimum price and compute the maximum profit.
Worst CaseO(n)In the worst case (decreasing prices), the algorithm still traverses the entire array to ensure no profit is possible.

Space Complexity❯

O(1)

Explanation: The solution uses a constant amount of extra space, maintaining only variables like min_price and max_profit.


Comments

💬 Please keep your comment relevant and respectful. Avoid spamming, offensive language, or posting promotional/backlink content.
All comments are subject to moderation before being published.

Loading comments...