Programa Javascript para comprar acciones y vender para maximizar las ganancias

El costo de una acción en cada día se da en una array, encuentre la ganancia máxima que puede obtener comprando y vendiendo en esos días. Por ejemplo, si la array dada es {100, 180, 260, 310, 40, 535, 695}, la ganancia máxima se puede obtener comprando el día 0 y vendiendo el día 3. Nuevamente, compre el día 4 y venda el día 6. Si la array de precios dada se ordena en orden decreciente, entonces no se puede obtener ninguna ganancia.

Enfoque ingenuo: un enfoque simple es intentar comprar acciones y venderlas todos los días cuando sea rentable y seguir actualizando la ganancia máxima hasta el momento.

A continuación se muestra la implementación del enfoque anterior:

<script>
// Javascript program to implement
// the above approach
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
function maxProfit(price, start, end)
{
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    let profit = 0;
 
    // The day at which the stock
    // must be bought
    for (let i = start; i < end; i++)
    {
        // The day at which the
        // stock must be sold
        for (let j = i + 1; j <= end; j++)
        {
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i])
            {
                // Update the current profit
                let curr_profit = price[j] - price[i] +
                                  maxProfit(price,
                                            start, i - 1) +
                                  maxProfit(price,
                                            j + 1, end);
 
                // Update the maximum profit
                // so far
                profit = Math.max(profit,
                                  curr_profit);
            }
        }
    }
    return profit;
}
 
// Driver code
let price = [100, 180, 260, 310,
             40, 535, 695];
let n = price.length;
document.write(maxProfit(
               price, 0, n - 1));
</script>

Producción:

865

Enfoque eficiente: si se nos permite comprar y vender solo una vez, entonces podemos usar el siguiente algoritmo. Diferencia máxima entre dos elementos . Aquí se nos permite comprar y vender varias veces. 
El siguiente es el algoritmo para este problema.  

1. Encuentre los mínimos locales y guárdelos como índice inicial. Si no existe, regresa.
2. Encuentre los máximos locales. y guárdelo como un índice final. Si llegamos al final, establezca el final como el índice final.
3. Actualice la solución (Incremente el recuento de pares de compra-venta)
4. Repita los pasos anteriores si no se llega al final.

<script>
// JavaScript program to implement
// the above approach
 
// This function finds the buy sell
// schedule for maximum profit
function stockBuySell(price, n)
{
    // Prices must be given for at
    // least two days
    if (n == 1)
        return;
 
    // Traverse through given price array
    let i = 0;
    while (i < n - 1)
    {
        // Find Local Minima
        // Note that the limit is (n-2) as we
        // are comparing present element to
        // the next element
        while ((i < n - 1) &&
               (price[i + 1] <= price[i]))
            i++;
 
        // If we reached the end, break
        // as no further solution possible
        if (i == n - 1)
            break;
 
        // Store the index of minima
        let buy = i++;
 
        // Find Local Maxima
        // Note that the limit is (n-1) as we
        // are comparing to previous element
        while ((i < n) &&
              (price[i] >= price[i - 1]))
            i++;
 
        // Store the index of maxima
        let sell = i - 1;
 
        document.write(`Buy on day: ${buy}   
        Sell on day: ${sell}<br>`);
    }
}
 
// Driver code
// Stock prices on consecutive days
let price = [100, 180, 260,
             310, 40, 535, 695];
let n = price.length;
 
// Function call
stockBuySell(price, n);
 
// This code is contributed by Potta Lokesh
</script>

Producción:

Buy on day: 0     Sell on day: 3
Buy on day: 4     Sell on day: 6

Complejidad del tiempo: el bucle externo se ejecuta hasta que me convierto en n-1. Los dos bucles internos incrementan el valor de I en cada iteración. Entonces la complejidad del tiempo total es O(n)

Complejidad espacial : O (1) ya que usa variables constantes

¡ Consulte el artículo completo sobre Stock Buy Sell to Maximize Profit para obtener más detalles!