Container With Most Water: análisis del problema

Esta imagen puede servir para entender el problema

El sombreado azul representa la cantidad de agua, y esta es el área que hay que hallar. Se multiplica el área del mas bajo (7) por la distancia entre los dos (7):
7 * 7 = 49

Mi solucion despues de muchas horas de estar intentando resolver otro algoritmo que de plano no iba a funcionar 😦

/**

• Two pointers (p1, p2), one at the start, one at the end.
• • Calculate the water with distance (p2-p1) minus minum height. Save result in water
• • if the two values are the same, move pointers (p1++) (p2–)
• • if not, move the pointer of the minimum height
• • if two pointers are the same value (points to the same value), finish the execution.
    */

Cuando yo era estudiante de ingeniería mecánica, este problema se solucionaba con integrales. La matemática booleana y la programación lo hacen ver tan fácil que es impresionante.

De verdad los computadores, son un invento de la humanidad al mismo nivel de la rueda, diría yo que incluso más.

En mi caso no entendí a la primera, decidí analizarlo un poco 😃
En otras palabras cada línea representa una pared del contenedor, y el área formada por el contenedor se puede calcular como el producto de distancia entre las líneas y la altura de la línea más baja.
En el ejemplo [1,8,6,2,5,4,8,3,7], comparan 8 y 7, su distancia la vemos de índice 1 al índice 8, por lo cual su distancia es 7, mientras que altura sería la más baja que es 7. Multiplicando 7 * 7 = 49.

El área formada por el contenedor depende tanto de la altura de las líneas como de la distancia entre ellas. En el caso de las líneas de altura 8 y 7, aunque su altura no es la máxima posible, la distancia entre ellas es la mayor de todas las combinaciones posibles, lo que resulta en un área mayor.

Mi primera solución en Java:

public class ContainerWithMostWater {

    public static int containerWithMostWater(int[] alturas) {
        int areaMax = 0;

        for (int i = 0; i < alturas.length; i++) {
            for (int j = 0; j < alturas.length; j++) {
                if (i != j) {
                    int altura = Math.min(alturas[i], alturas[j]);
                    int ancho = j - i;
                    int area = altura * ancho;

                    if (area > areaMax) {
                        areaMax = area;
                    }
                }
            }
        }

        return areaMax;
    }

    public static void main(String[] args) {
        int[] alturas = {1, 8, 6, 2, 5, 4, 8, 3, 7};

        int areaMax = containerWithMostWater(alturas);
        System.out.println(areaMax);
    }
}

Mi primera solución:

function getContainerCapacity (numbers, size) {
    /* 
    T = O(n)
    S = O(1)
    */
let maxNumber = 0
let previousNumber = 0;
let capacityContainer;

for (let i = 1; i < size; i++){
    if(numbers[i] > numbers[i - 1] && numbers[i] >= maxNumber) {
        if(i <= 1){
            previousNumber = numbers[i-1];
        } else {
            previousNumber = numbers[i-1] <= previousNumber ? maxNumber : numbers[i-1];
        }
        maxNumber = numbers[i];
    } else if (numbers[i] < numbers[i - 1] && i == 1){
        maxNumber = numbers[i-1];
        previousNumber = numbers[i];
    }
    if(previousNumber != 0 && numbers[i] != maxNumber && numbers[i] > previousNumber){
        previousNumber = numbers[i];
    }
}
    capacityContainer = previousNumber * previousNumber;
    return `The capacity of this container is: ${capacityContainer} liters`; 
}

function getRandomArray (size) {
    if(typeof size != "number") return "Debes ingresar un número";
    const array = new Array(size)
    for (let i=0; i<size; i++) {
        array[i] = Math.floor(Math.random() * 100);
    }
    return array;

}

const arr = getRandomArray(10);
console.log(arr);
console.log(getContainerCapacity(arr, arr.length));