Best Time to Buy and Sell Stock - JS Solution

Editorial

Editorial solutions and visualizations are prepared with care, but we do not guarantee 100% accuracy or completeness. Please use your own judgment to verify results. Visucodize is not responsible for decisions made based on this content.

const CURRENT_PRICE = 'current_price', CURRENT_PRICE_COLOR = 'blue';

function visMainFunction(pricesInput) {
    initClassProperties();

    let maxProfit = 0;
    let minPrice = Infinity;
    let index = 0;

    startBatch();
    makeVisVariable(maxProfit).options({label: 'maxProfit'}).createVis(true);
    makeVisVariable(minPrice).options({label: 'minPrice'}).createVis(true);
    const prices = new VisArray(...pricesInput);
    makeVisVariable(index).registerAsIndexPointer(prices, CURRENT_PRICE);
    endBatch();

    explanationAndColorPaletteNotifications();

    for (let price of prices) {
        startPartialBatch();

        notification(
            `The current price is ${makeColoredSpan(price, CURRENT_PRICE_COLOR)} the min price so far was <b>${minPrice}</b>.<br/>
            Therefore, the max possible profit that would be obtained by selling at this point is the <b>currentPrice - minPrice</b> which is <b>${price - minPrice}</b>.<br/>
            The new maxProfit will be the maximum of that value and the existing maxProfit.`
        );

        maxProfit = Math.max(maxProfit, price - minPrice);

        notification(
            `The current price is ${makeColoredSpan(price, CURRENT_PRICE_COLOR)} and the minPrice so far was <b>${minPrice}</b>. </br>
            So the new minPrice will be min of these two which is <b>${Math.min(minPrice, price)}</b>.`
        );

        minPrice = Math.min(minPrice, price);

        index += 1;
        endBatch();
    }

    notification(`The maximum possible profit is <b>${maxProfit}</b>`);
    return maxProfit;
}

function explanationAndColorPaletteNotifications() {
    explanationNotification();
    notification(`
        🎨 <b>Color Palette Guide</b><br/><br/>
        • ${makeColoredSpan("Blue", CURRENT_PRICE_COLOR)} background → <b>Current price</b><br/>
    `);
}

function initClassProperties() {
   setClassProperties(CURRENT_PRICE, {
    'backgroundColor': CURRENT_PRICE_COLOR
   });
}

Approach

Goal

Given an array of prices, compute the maximum possible profit from a single buy → sell transaction.

Key Idea (Intuition)

You must buy before you sell. For any day treated as the sell day, the best buy is simply the lowest price seen so far. So we maintain two running values while scanning once: minPrice (lowest price up to the current day) and maxProfit (best profit found so far). At each day, we (1) compute today’s possible profit against minPrice and update maxProfit, then (2) update minPrice with today’s price.

Initialization

maxProfit = 0 — best profit found so far.
minPrice = Infinity — the minimum price seen so far; first price will become the initial minimum.

Traversal

Iterate over the array prices from left to right (one pass). For each price:

Per-Iteration Logic

Compute possible profit at this sell point:
possibleProfit = price − minPrice
Treat today as the sell day; compare with the lowest buy price seen so far.
Update maxProfit:
maxProfit = Math.max(maxProfit, possibleProfit)
Keep the best profit encountered so far.
Update minPrice:
minPrice = Math.min(minPrice, price)
Refresh the lowest-so-far price for future sell-day checks.

Return

After the loop finishes, return maxProfit.

Why This Works

A single pass is enough because for each day we only need the minimum price from previous days. By maintaining minPrice, we can directly calculate the best possible profit if we sell at today’s price. By maintaining maxProfit alongside, we always keep track of the best profit across all days.

Time Complexity

The algorithm makes a single pass over the input array of prices. Each iteration performs constant-time operations such as comparisons and assignments. Thus, the overall time complexity is O(n), where n is the number of prices.

Space Complexity

The algorithm uses only a constant amount of extra space for variables such as maxProfit, minPrice. At each iteration, the same fixed variables are updated, and no new structures are created. No additional data structures are required that grow with the input size. Therefore, the space complexity is O(1).

Input-1

Best Time to Buy and Sell Stock - JS Solution

Solution code

Solution explanation

Solution explanation

Approach

Goal

Key Idea (Intuition)

Initialization

Traversal

Per-Iteration Logic

Return

Why This Works

Time Complexity

Space Complexity