Implementación de solución de cálculo de área máxima en Java

He tomado muchos cursos de Platzi de programación y de verdad espero que la profe siga con el mismo ritmo de claridad y calidad, nadie se toma la delicadeza de explicar como ella. Hasta con cualquier lenguaje se hace entender. No como otros que solo transcriben y le toca a uno investigar cómo funciona.

Mi código en Go:

package main

import "fmt"

func calcArea(x int, y int, dis int) int {
	if x < y {
		return x * dis
	}
	return y * dis
}

func maxArea(nums []int) int {
	i, j := 0, len(nums)-1
	area, areaNow := 0, 0
	for i != j {
		areaNow = calcArea(nums[i], nums[j], j-i)
		if areaNow > area {
			area = areaNow
		}
		if nums[i] < nums[j] {
			i++
		} else {
			j--
		}
	}
	return area
}

func main() {
	heights := []int{1, 8, 6, 2, 5, 4, 8, 3, 7}
	fmt.Println(maxArea(heights))

	heights = []int{8, 1, 6, 2, 5, 4, 1, 3, 7}
	fmt.Println(maxArea(heights))
}

C#

Inicialmente pensé en hacer un ciclo anidado que recorrería la mitad de los elementos – (esto, despues de pasar un día tratando de idear la manera de resolver … 😦 ) – pero despúes de ver la solución propuesta, y más optima, me quedó el código así:

function getMaxArea(alturas){
    let p1 = 0;
    let p2 = alturas.length-1;
    let maxArea = 0;
    while (p1<p2){
        let area = Math.min(alturas[p1],alturas[p2])*(p2-p1);
        maxArea = Math.max(area,maxArea)
        if (alturas[p1] > alturas[p2]) {
            p2--;
        }
        else{
            p1++;
        }
    }
    return maxArea;
}

Comparto mi solución en C#

    int CalcularMayorArea(int[] miArreglo)
    {
        int areaMayor = 0;
        int p1 = 0;
        int p2 = miArreglo.Length - 1;

        while (p1 != p2)
        {
            int valor1 = miArreglo[p1];
            int valor2 = miArreglo[p2];
            int valorAMultiplicar = valor1 > valor2 ? valor2 : valor1;
            int resultado = valorAMultiplicar * (p2 - p1);

            if (resultado > areaMayor)
            {
                areaMayor = resultado;
            }

            if (valor1 >= valor2)
            {
                p2--;
            }
            else
            {
                p1++;
            }
        }

        return areaMayor;
    }

Desarollo una solución diferente en donde en vez de usar dos apuntadores, se utilizan solo dos maximos. Lenguaje de programación: Scala:

object ContainerWithMostWater {
  def algorithm(numList: List[Int]): Int = {
    var max1 = 0
    var max2 = 0

    for (number <- numList) {
      if (number > max1) {
        max2 = max1
        max1 = number
      } else if (number > max2) {
        max2 = number
      }
    }

    val container = max2 * max2
    container
  }

  def main(args: Array[String]): Unit = {
    val numberList = List(9, 8, 1, 2, 3, 11)
    println("The area of the largest rectangle is " + algorithm(numberList))
  }
}

ContainerWithMostWater.main(Array())

Mi versión del algoritmo actualizada hecha en C++

#include <bits/stdc++.h>
using namespace std;

int containerWithMostWater(int input[],int arraySize);
int calculateArea(int lengt, int width);
int updateVariable(int maxArea, int currentArea);

int main(){
    //Change the values of the array.
    int array1[]= {1, 8, 6, 2, 5, 4, 8, 3, 7};
    //Variable to storage the number of elements inside the array.
    int arraySize= sizeof(array1)/sizeof(array1[0]);
                                                //Calling the Function
    cout << "The Maximum possible area is: " << containerWithMostWater(array1, arraySize) << endl;
    return 0;
}

int containerWithMostWater(int input[], int arraySize){
    //Pointer 1
    int p1= 0;
    //Pointer 2
    int p2= arraySize-1;
    //MaxArea is a variable to save the maximum possible area
    //that a container can storage.
    int maxArea= 0;

    for (int i = 0; i < arraySize; i++)
    {
        //Comparisons to check which pointer has to be updated.
        if(input[p1]<input[p2]){
            maxArea = updateVariable(maxArea, calculateArea(input[p1], p2-p1));
            p1+=1;
        }else{
            maxArea= updateVariable(maxArea, calculateArea(input[p2], (p2-p1)));
            p2-=1;
        }
    }
    //Returns the maximum Area.
    return maxArea;
}

int calculateArea(int lengt, int width){
    //Returns the area of a rectangle, which is the shape that the container has.
    return lengt*width;
}

int updateVariable(int maxArea, int currentArea){
    //Returns the maximum value between the current calculated area and the maxArea
    //from the previous iteration.
    if(maxArea<currentArea){
        maxArea= currentArea;
    }
    return maxArea;
}

Convertido a python:

def maxArea(heights):
    lp = 0 # left pointer
    rp = len(heights)-1 # right pointer
    maxArea = -1

    while lp < rp:
        # compute area
        area = (rp -lp + 1) * min(heights[lp], heights[rp])
        # get max. area
        maxArea = max(area, maxArea)
        # discard smallest value
        if heights[lp] < heights[rp]:
            lp += 1
        else:
            rp -= 1
    return maxArea

heights = [1,8,6,2,5,4,8,3,7]
print(maxArea(heights))

Comparto mi solución:

function maxArea(alturas) {
  let mayorArea = 0;
  let pointer1 = 0;
  let pointer2 = alturas.length - 1;
  while (pointer1 < pointer2) {
    let area = (pointer2 - pointer1) * Math.min(alturas[pointer1], alturas[pointer2]);
    if (area > mayorArea) mayorArea = area;
    alturas[pointer1] <= alturas[pointer2] ? pointer1++ : pointer2--;
  }
  return mayorArea
}

Mi solucion

 function maxArea(alturas) {
    // Tu código aquí 
    let p1 = 0;
    let p2 = alturas.length-1;
    let maxA = 0;
  
    while (p2 !== p1) {
      let min = Math.min(alturas[p1], alturas[p2]);
      let dif = (p2 - p1)
      let area = dif * min; 
      maxA = area > maxA ? area : maxA;
  
      let nextl = Math.min(alturas[p1 + 1], alturas[p2]);
      let nextr = Math.min(alturas[p1], alturas[p2 - 1] );
      if ((dif * nextl) > (dif * nextr)) {
        p1++;
      }
      else {
        p2--;
      }
    } 
    return maxA;
  }
  const alturas = [1,8,6,2,5,4,8,3,7]
  console.log(maxArea(alturas))

Comparto mi solución en JS

export function maxArea(alturas) {
  // Tu código aquí 👈
  let left = 0;
  let right = alturas.length - 1;
  let maxWater = 0;

  while (left < right) {
    const h = Math.min(alturas[left], alturas[right]);
    const b = right - left;
    if (maxWater < b * h) {
      maxWater = b * h;
    }
    alturas[left] < alturas[right] ? left++ : right--;
  }
  return maxWater;
}