Introducci贸n

1

Arrays y Strings para resolver algoritmos avanzados

2

Arrays y Strings en detalle

Dos Apuntadores

3

Patr贸n de Dos Apuntadores

4

Verifying Alien Dictionary: an谩lisis del problema

5

Soluci贸n de Verifying Alien Dictionary

6

Playground: Verifying Alien Dictionary

7

Programando Verifying Alien Dictionary con JavaScript

8

Merge Two Sorted Lists: an谩lisis del problema

9

Soluci贸n de Merge Two Sorted Lists

10

Playground: Merge Two Sorted Lists

11

Programando Merge Two Sorted Lists con Python

12

Container With Most Water: an谩lisis del problema

13

Soluci贸n de Container With Most Water

14

Playground: Container with Most Water

15

Programando Container With Most Water con Java

16

Reto: Trapping Rain Water

17

Ejercicios recomendados de Dos Apuntadores

18

Ejercicios resueltos de Dos Apuntadores

Ventana Deslizante

19

Patr贸n de Ventana Deslizante

20

Longest Substring Without Repeating Characters: an谩lisis del problema

21

Soluci贸n de Longest Substring Without Repeating Characters

22

Playground: Longest Substring Without Repeating Characters

23

Programando Longest Substring Without Repeating Characters con Python

24

Ejercicios recomendados de Ventana Deslizante

25

Ejercicios resueltos de Ventana Deslizante

B煤squeda Binaria

26

Algoritmo de B煤squeda Binaria

27

Search in Rotated Arrays: an谩lisis del problema

28

Soluci贸n de Search in Rotated Arrays

29

Playground: Search in Rotated Arrays

30

Programando Search in Rotated Arrays

31

Search 2D Array Matrix: an谩lisis del problema

32

Soluci贸n de Search 2D Array Matrix

33

Playground: Search 2D Array Matrix

34

Programando Search 2D Array Matrix

Pr贸ximos pasos

35

Toma el Curso Avanzado de Algoritmos: Estructuras de Datos Lineales

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Programando Container With Most Water con Java

15/35
Recursos

Aportes 11

Preguntas 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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.

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;
}

C#

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))

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))
}

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;
}