Best Time to Buy and Sell Stock

class Solution {
public:
    int calculateMaxProfit(vector<int>& stockPrices) {
        int lowestPrice = INT_MAX;
        int highestProfit = 0;
        for (int i = 0; i < stockPrices.size(); i++) {
            if (stockPrices[i] < lowestPrice)
                lowestPrice = stockPrices[i];
            else if (stockPrices[i] - lowestPrice > highestProfit)
                highestProfit = stockPrices[i] - lowestPrice;
        }
        return highestProfit;
    }
};

The provided C++ solution addresses the "Best Time to Buy and Sell Stock" problem by efficiently tracking the minimal stock price and calculating the maximum profit achievable. Working through an array of daily stock prices, the function calculateMaxProfit leverages a loop to inspect every price:

• Initializes lowestPrice to INT_MAX to ensure any stock price will be considered lower initially.
• Initializes highestProfit to 0, representing no profit scenario as the baseline.
• Iterates through the list of stock prices, updating the lowestPrice if a current price is lower than any previously recorded prices.
• Checks for potential profit by subtracting the lowestPrice from the current price. If this profit surpasses highestProfit, it updates highestProfit accordingly.

This method guarantees that you capture the maximum possible profit from single buy and sell transactions without needing a nested loop, thereby operating in linear time complexity, O(n). The solution is both time-efficient and easy to understand, making optimal use of resources.

public class Solution {
    public int calculateMaxProfit(int[] stockPrices) {
        int lowestPrice = Integer.MAX_VALUE;
        int highestProfit = 0;
        for (int i = 0; i < stockPrices.length; i++) {
            if (stockPrices[i] < lowestPrice) lowestPrice = stockPrices[i];
            else if (stockPrices[i] - lowestPrice > highestProfit) highestProfit = stockPrices[i] - lowestPrice;
        }
        return highestProfit;
    }
}

This solution summary describes an approach to solving the "Best Time to Buy and Sell Stock" problem using Java, focusing on maximizing profit given the price of a stock over several days.

• The solution is implemented within a class named Solution with a method called calculateMaxProfit.
• It accepts an integer array stockPrices which represents the stock price on each day.

The method functions as follows:

• Initialize lowestPrice to Integer.MAX_VALUE. This variable will hold the minimum price of the stock observed so far.
• Initialize highestProfit to 0. This variable will keep track of the maximum profit achieved at any given point.
• Use a single loop to iterate through the array stockPrices.
  • For each price in the array:
    • Update lowestPrice to the current price if the current price is lower than lowestPrice.
    • If the current price is higher than lowestPrice, calculate the potential profit (stockPrices[i] - lowestPrice).
    • If this potential profit exceeds highestProfit, update highestProfit with this new value.
• The method returns highestProfit, which will be the maximum achievable profit by buying low and selling high at optimal times.

This solution efficiently calculates the maximum possible profit with a time complexity of O(n), where n is the number of days, and requires O(1) additional space. The method ensures that the buying and selling happen in the right order (you cannot sell the stock before you buy it). This approach effectively captures the best trading scenario by maintaining the lowest prices seen so far and the highest possible profit at any stage.

int calculateMaxProfit(int* stockPrices, int numberOfDays) {
    int lowestPrice = INT_MAX;
    int highestProfit = 0;
    for (int day = 0; day < numberOfDays; day++) {
        if (stockPrices[day] < lowestPrice)
            lowestPrice = stockPrices[day];
        else if (stockPrices[day] - lowestPrice > highestProfit)
            highestProfit = stockPrices[day] - lowestPrice;
    }
    return highestProfit;
}

This solution is implemented in C to solve the problem of determining the best time to buy and sell stock for maximum profit. The function, calculateMaxProfit, takes an array of stock prices and the number of days as its parameters.

Follow these steps to understand how the code works:

1. Initiate lowestPrice with INT_MAX to ensure any price in the array is lower initially.
2. Set highestProfit to zero, this will store the maximum profit found.

The function then enters a loop iterating over each day:

1. If the current day's stock price is lower than the lowestPrice, update lowestPrice to this value.
2. If the difference between the current day's stock price and lowestPrice is greater than highestProfit, update highestProfit accordingly.

Finally, the function returns the highestProfit which represents the maximum profit that could be achieved based on the given stock prices and number of days.

This approach ensures checking each possible day's profit in relation to the lowest price seen so far, leading to an efficient solution with a time complexity of O(n), where n is the number of days. This method is particularly effective for large arrays, providing a quick way to determine the best buy and sell points without the need for nested loops or additional data structures.

var getMaximumProfit = function (priceList) {
    let lowestPrice = Number.MAX_VALUE;
    let highestProfit = 0;
    for (let index = 0; index < priceList.length; index++) {
        if (priceList[index] < lowestPrice) lowestPrice = priceList[index];
        else if (priceList[index] - lowestPrice > highestProfit)
            highestProfit = priceList[index] - lowestPrice;
    }
    return highestProfit;
};

The solution presented above is designed to find the maximum profit from a list of stock prices using JavaScript. The function getMaximumProfit takes an array priceList as input, where each element represents the stock price on a given day.

Follow these principles to understand how the function operates:

• Initialize lowestPrice to the maximum possible value that a number in JavaScript can hold. This helps in ensuring any price in the list is lower than this initial value.
• Set highestProfit to 0 as a starting point.
• Iterate through each price in the priceList array:
  • If the current price is less than lowestPrice, update lowestPrice to this current price.
  • If the current price minus lowestPrice is greater than highestProfit, update highestProfit to this difference.
• After iterating through all prices, highestProfit will hold the maximum possible profit.

This efficient approach ensures that the function processes each price in the list only once, thus having a linear time complexity of O(n), where n is the number of days (or stock prices) in the input list. The simplicity of using a single loop and conditional checks makes the code straightforward and efficient for large inputs.

class Solution:
    def calculateMaxProfit(self, costs: List[int]) -> int:
        lowest_price = float("inf")
        highest_profit = 0
        for price in costs:
            if price < lowest_price:
                lowest_price = price
            elif price - lowest_price > highest_profit:
                highest_profit = price - lowest_price

        return highest_profit

The provided solution in Python addresses the problem of determining the best time to buy and sell stock to maximize profit. Implement the following logic:

1. Declare two variables: lowest_price initialized to infinity to keep track of the minimum stock price encountered so far, and highest_profit initialized to zero for tracking the maximum profit possible.
2. Iterate over the list of stock prices:
   • When a stock price less than the lowest_price is encountered, update lowest_price.
   • If the current price minus lowest_price yields a profit greater than highest_profit, update highest_profit with this new profit value.
3. Return the highest_profit, which will be the maximum profit from selling and buying on optimal days.

This method ensures efficiency by computing the result in a single pass through the stock prices, giving a time complexity of O(n). It effectively finds the lowest buy price and the highest profit without needing a nested loop, thus optimizing performance.