Playground: Container with Most Water

export function maxArea(alturas) {
  let pointer1 = 0;
  let pointer2 = alturas.length-1
  let maxArea = 0
  while (pointer1 < pointer2) {

    let minHeight = Math.min(alturas[pointer1], alturas[pointer2])

    let currentArea = (pointer2-pointer1) * minHeight
    if (currentArea > maxArea) {
      maxArea = currentArea
    }
    if (alturas[pointer1] <  alturas[pointer2]) {
      pointer1 ++
    } else {
      pointer2 --
    }
  }
  return maxArea
}

Mi solucion en python, javascript es muy duro 🤕

def container_with_most_water(list=[1, 8, 6, 2, 5, 4, 8, 3, 7]):
  max_area = 0
  p1=0
  p2=len(list)-1
  while p2 > p1:
    area = min(list[p1], list[p2]) * (p2-p1)
    if area > max_area:
      max_area = area
    if list[p1] < list[p2]:
      p1 += 1
    else:
      p2 -= 1
  return max_area

Podemos uzar el siguiente enfoque:

function maxArea(height) {
    let maxWater = 0;
    let left = 0;
    let right = height.length - 1;

    while (left < right) {
        const hLeft = height[left];
        const hRight = height[right];
        const width = right - left;
        const minHeight = Math.min(hLeft, hRight);
        const area = width * minHeight;

        maxWater = Math.max(maxWater, area);

        if (hLeft < hRight) {
            left++;
        } else {
            right--;
        }
    }

    return maxWater;
}

export function maxArea(alturas) {
  // Tu código aquí 👈
  var p1 = 0, p2 = alturas.length - 1, maxArea = 0;
  while (p1 != p2) {
    maxArea = Math.max(maxArea, (p2 - p1) * Math.min(alturas[p1], alturas[p2]));
    if (alturas[p1] - alturas[p2] < 0) {
      p1 += 1;
    } else {
      p2 -= 1;
    }
  }
  return maxArea;
}

le pedi a la IA que me convirtiera mi codigo python a Js solo para er la serpentina 🎉 🐧🐍

.
.
.
.

Para probar el código en node js:

function maxArea(alturas) {
// Tu código aquí 👈
const heigth = alturas;
let maxArea = 0;
let p1 = 0;
let p2 = heigth.length - 1;
console.log(maxArea, p1, p2);

while (p1 < p2) {
    let minHeight = Math.min(heigth[p1], heigth[p2]);
    let area = (p2 - p1) * minHeight;

    if (area > maxArea) {
        maxArea = area;
    }
    if (alturas[p1] <= alturas[p2]) {
        p1++;
    } else {
        p2--;
    }

}

return maxArea;

}

Container With Most Water

I learned a lot with this challenge 💚

def max_area(height):
    """
    T = O(n)
    We only iterate once our list to calculate the area,
    that means that is linear.

    S = O(1)
    We only store 3 variables that regardless of the input
    they do not change their value so it´s linear.
    """
    max_area = 0
    left_pointer, right_pointer = 0, len(height) - 1

    while left_pointer < right_pointer:  # T = O(n)
        area = (right_pointer - left_pointer) * min(height[right_pointer], height[left_pointer])
        max_area = max(max_area, area)
        if height[right_pointer] >= height[left_pointer]:
            left_pointer += 1
        else:
            right_pointer -= 1

    return max_area


if __name__ == '__main__':
    input1 = [1, 8, 6, 2, 5, 4, 8, 3, 7]
    output1 = 49

    input2 = [8, 1, 6, 2, 5, 4, 1, 3, 7]
    output2 = 56

    print(max_area(input1))
    print(max_area((input2)))

Sugiero que se agreguen más casos de prueba, habia hecho un algoritmo que estaba mal, pero pasaban los tests 😕 jaja

Bueno, igual aqui quedo, o(n)

export const maxArea = (heights) => {
  let right = heights.length - 1;
  let left = 0;
  let max = 0;
  for (let i = 0; i < heights.length; i++) {
    const distance = right - left;
    const leftHeight = heights[left];
    const rightHeight = heights[right];
    const maxHeight = Math.min(leftHeight, rightHeight);

    const area = distance * maxHeight;
    if (area > max) max = area
    if (leftHeight > rightHeight) right--
    else left++
  }
  return max;
}

Yo había resuelto este problema hace tiempo, había tratado de hacer lo mismo con dos indices por la izquierda y por la derecha, pero realmente no conocía el patrón two points, y no sabia como aplicarlo de forma más limpia y elegante como con el while p1!=p2, les muestro esta solución en python:

def maxArea(height):
        n = len(height)
        left = 0
        right = n-1
        base = n-1
        max_value = 0

        while base > 0:
            if height[left] <= height[right]:
               max_v = base*height[left]
               if max_value < max_v:
                   max_value = max_v
               left += 1
                

            elif height[left] > height[right]:
                max_v = base*height[right]
                if max_value < max_v:
                    max_value = max_v
                right -= 1

            base -= 1

        return max_value

function containerMostWater(alturas) {
  let p1 = 0;
  let p2 = alturas.length - 1;
  let area = 0;

  while (p1 !== p2) {
    const h = Math.min(alturas[p1], alturas[p2]);
    const b = p2 - p1;
    area = Math.max(area, b * h);

    if (alturas[p1] < alturas[p2]) {
      p1++;
    } else {
      p2--;
    }
  }
  return area;
}

export function maxArea(alturas) {
      let i = 0;
    let j = list.length - 1;
    let max = 0
    while (i !== j) {
        let temp = 0
        if (list[i] < list[j]) {
            temp = list[i] * (j - i);
            i++;
        } else {
            temp = list[j] * (j - i);
            j--
        }

        if (temp > max) {
            max = temp;
        }
    }
    return max;

}

Comparto mi intento :]

function maxArea(heights) {
	let p1 = 0, p2 = heights.length - 1;
	let bestArea = 0;

	while (true) {
		const val1 = heights[p1], val2 = heights[p2]; // Alturas de cada apuntador
		const b = p2 - p1;
		const h = Math.min(val1, val2);
		const area = b * h;

		if (area > bestArea)
			bestArea = area; // Guardar mejor area

		if (val1 > val2) // Recorrer apuntadores
			p2--;
		else
			p1++;

		if (p1 === p2)
			break;
	}

	return bestArea;
}

Comparto mi solucion

export function maxArea(alturas) {
  // Tu código aquí 👈
  let pointer1 = 0;
  let pointer2 = alturas.length - 1;
  let better_area = 0;

  while (pointer1 != pointer2) {
    let small = Math.min(alturas[pointer1], alturas[pointer2]);
    let base = pointer2 - pointer1;

    if ((small * base) > better_area) {
      better_area = (small * base)
    }

    if (alturas[pointer1] == small) {
      pointer1 += 1;
    }
    else {
      pointer2 -= 1;
    }
  }
  return better_area;
}

dejando codigo :

haber si les sirve!

export function maxArea(alturas) {
  // Tu código aquí 👈
  let p1 = alturas.length - 1;
  let area = [];
  let final = 0;
  let p2 = 0;
  let i = 0;

  while (1 < p1 && p2 < p1) {
    if (alturas[p1] < alturas[p2]) {
      area[i] = alturas[p1] * (p1 - p2);
      p1--;
    } else {
      area[i] = alturas[p2] * (p1 - p2);
      p2++;
    }
    i++;
  }

  while (0 <= i) {
    if (final < area[i]) {
      final = area[i];
    }
    i--;
  }
  return final;
}