Reto: altura de un triángulo

4/27
Recursos

Aportes 15

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

const calcularAlturaTrianguloEscaleno = (ladoBase, lado2, lado3) => {
  const semiperimetro = (ladoBase + lado2 + lado3) / 2;
  return {
    altura: (2 / ladoBase) * Math.sqrt(semiperimetro *
          (semiperimetro - ladoBase) *
          (semiperimetro - lado2) *
          (semiperimetro - lado3)
      ),
  };
};

Analisis

Primero que nada hay que tener en cuenta que este triangulo tiene mas de una altura, dependiendo de la orientación, todas sirven para calcular el área pero hay que tenerlo en cuenta al momento de pasar los datos porque el orden de los factores altera el resultado.

Codigo en JavaScript:

function calcularAlturaTrianguloEscaleno(a, b, c) {
	/*
	Calcula la altura (hb) de un triangulo escaleno
	a = lado1
	b = base
	c = lado2
	*/
	const x = (c**2 - a**2 + b**2) / (2 * b);
	const h = Math.sqrt(c**2 - x**2);

	return h;
}

Otra opción.

También con la formula de Heron puedes calcular el área de un triangulo escaleno sin necesidad de conocer la altura, pero eso ya es otra historia. Hay un video del poderosísimo JulioProfe de 27 minutos demostrando de donde se obtiene esa formula.

My result based on this web

function compareNumbers(a, b) {
    return a - b;
};

function scaleneTriangleH(side1, side2, side3){
    const semiPerimeter = ( side1 + side2 + side3 ) / 2;
    const sideArray = [side1,side2,side3];
    const [a,b,c] = sideArray.sort(compareNumbers);
    console.log({semiPerimeter,a,b,c})
    return (2 / a)*(Math.sqrt( semiPerimeter * (semiPerimeter-a) * (semiPerimeter-b) * (semiPerimeter-c) ))
};

Para resolverlo dividí la base del triangulo para formar dos triángulos rectángulos con la misma alturas para tener dos ecuaciones y dos incógnitas usando Pitágoras, del algebra obtuve este resultado:

function alturaEscaleno(lado1, lado2, base){
    let alturaTriangulo;
    if (lado1 != lado2 && lado1 != base && lado2 != base) {
        alturaTriangulo = Math.sqrt((lado1**2)-((((base**2)-(lado2**2)+(lado1**2))/(2*base))**2));
    } else {
        alert('No es un triangulo escaleno')
    }
    return alturaTriangulo
}

Hice una fórmula que recibe como parámetro los tres lados del triángulo y vuelve un objeto con sus ángulos, perimetro, área y altura

En la imagen se puede ver la letra asignada a cada lado y ángulo.

function calcularTriangulo(ladoA, ladoB, ladoC){
    //Conversion de Radianes a Grados
    let radioGrados = 57.2958;
    /* Calculo de los angulos utilizando la teoria del coseno */
    let anguloBeta = Math.acos((Math.pow(ladoA, 2) - Math.pow(ladoB, 2) - Math.pow(ladoC, 2)) / (-2*ladoB*ladoC)) * radioGrados; //β
    let anguloAlfa = Math.acos((Math.pow(ladoB, 2) - Math.pow(ladoA, 2) - Math.pow(ladoC, 2)) / (-2*ladoA*ladoC)) * radioGrados; //α
    let anguloGamma = Math.acos((Math.pow(ladoC, 2) - Math.pow(ladoB, 2) - Math.pow(ladoA, 2)) / (-2*ladoA*ladoB)) * radioGrados; //γ
    /*Calculo del area usando la formula de Heron */
    let perimetro = ladoA + ladoB + ladoC;
    let semiPerimetro = perimetro / 2;
    let area = Math.sqrt(semiPerimetro *(semiPerimetro - ladoA) * (semiPerimetro - ladoB) * (semiPerimetro - ladoC));
    /*Calculo de la altura conociendo la base y el area */
    let altura = (area * 2) / ladoC;
    /*Variable que almacena las respuestas */
    let repuesta = {
        'anguloα': Math.round((anguloAlfa)* 100) / 100, 'anguloβ' : Math.round((anguloBeta)* 100) / 100, 'anguloγ': Math.round((anguloGamma)* 100) / 100, 'perimetro' : Math.round((perimetro)* 100) / 100, 'area' : Math.round((area)* 100) / 100, 'altura': Math.round((altura)* 100) / 100,
    };
    return repuesta;
}

El resultado obtenido con los valores detallados es:


{
  'anguloα': 75.77,
  'anguloβ': 57.15,
  'anguloγ': 47.09,
  perimetro: 236,
  area: 2570.6,
  altura: 75.61
}

Use esta web como base: clic 🐭

Mi solución al reto 😃
// Calculando la altura de un Triángulo escaleno //

function calcularAlturatrianguloEscaleno(base, lado2, lado3) {
if (base == lado2 || base == lado3 || lado2 == lado3) {
console.warn(‘Este no es un triángulo escaleno’);
} else {
// primero hallamos el semiperímetro que es igual a la suma de los lados sobre 2 //
let semiperimetro = (base + lado2 + lado3 ) / 2;
// la altura será: 2 sobre la base multiplicado por la raíz cuadrada del semiperímetro multiplicado por el semiperímetro menos la base, el semiperímetro menos lado2 y el semíperímetro menos el lado3 //
console.log({
semiperimetro,
base,
lado2,
lado3,
})
return (2/ base) * (Math.sqrt(semiperimetro * (semiperimetro - base) * (semiperimetro - lado2) * (semiperimetro - lado3)));
}
}

Ya lo había intentado en el taller anterior, pero no pude resumir la formula en una función, porque estaba bebé.

function calcularAlturaTriangulo(lado1,lado2, base){
if(lado1!=lado2 && lado1 != base && lado2 != base)
		{const semiperimetro = (base + lado1 + lado2) / 2;
			return (2/ base) * (Math.sqrt(semiperimetro * (semiperimetro - base) * (semiperimetro - lado1) * (semiperimetro - lado2)));
	}else {
		return Math.sqrt((lado1 ** 2) - (base ** 2)/ 4);
	}
};

Ahora me falta poner una condicional para que realmente cumpla con las condiciones del triangulo pero no sé donde ponerla.

Para que el triángulo pueda existir sus lados o segmentos deben cumplir ciertas condiciones:
La regla principal que da origen al triángulo tiene que ver con la longitud de sus lados. Esta plantea que la suma de dos de sus lados debe ser mayor a la longitud del tercer lado.

yo puse otro parametro como ayuda y ya 😄 jajaja

Notes… 😃

function triangleH(side,base){
    if(side == base){
        console.warn('This is not a Isosceles triangle, please verify it');
        return
    };

    return Math.sqrt( (Math.pow(side,2)) - (Math.pow(base,2) / 4) )
};

Bueno, de acuerdo a la documentación que encontre:

function calcularAlturaTrianguloEscaleno(a, b, c) {
    const semiperineo = (a + b + c) / 2

    return (2 / a) * Math.sqrt(semiperineo * (semiperineo - a) * (semiperineo - b) * (semiperineo - c))
}
const calculateTriangleScalene = (side1, side2, side3) => {
	const perimeter = side1 + side2 + side3;
	semiperimeter = perimeter / 2;
	return {
		side1,
		side2,
		side3,
		perimeter,
		semiperimeter,
		area: Math.sqrt(
			semiperimeter *
				(semiperimeter - side1) *
				(semiperimeter - side2) *
				(semiperimeter - side3),
		),
	};
};

Este es mi Aporte

const trianguloEscaleno=(ladoUno,ladoDos,base)=>{
    S=(ladoDos+ladoDos+base)/2
    return h= (2/base)*(Math.sqrt(S*(S-base)*(S*(S-ladoUno))*(S*(S-ladoDos))))
}
console.log(trianguloEscaleno(1,2,3))

Bueno hice el reto aunque el resultado no se si estará bien

function calcularAlturaTrianguloEscaleno(lado1,lado2, base) {
    if (lado1 == lado2 || lado2 == base || base == lado1){
        console.warn(' no es un triangulo escaleno')
    } else {
        // semiPerimetro = (lado1 + lado2 + base) / 2
        const semiPerimetro = (lado1 + lado2 + base) / 2;
        //h = (2 / lado1) * raizcuadrada (semiPerimetro(semiPerimetro - lado1)*(semiPerimetro - lado2)*(semiPerimetro - base)) fórmula de Herón
        const altura = (2 / lado1) * Math.sqrt(semiPerimetro * (semiPerimetro - lado1) * (semiPerimetro - lado2) * (semiPerimetro - base) / 2 );
        return altura
    }
}
// Ahora crear una funcion para calcular la altura de cualquier triangulo escaleno

function alturaTriEscaleno (ladoA, ladoB, ladoC){
    const perimetro = ladoA + ladoB + ladoC;
    const semiPerimetro = perimetro / 2;

    if(ladoA == ladoB || ladoA == ladoC || ladoB == ladoC ){
        console.warn('Este triangulo NO es escaleno')
    } else {
        const h = (2 / ladoA) * Math.sqrt(semiPerimetro * (semiPerimetro - ladoA) * (semiPerimetro - ladoB) * (semiPerimetro - ladoC));
        return h.toFixed(2);
    }
}

Si ven algun detalle a mejorar, seria genial que me lo comentaran. Gracias!!

Intente solucionar el reto por mi cuenta antes de ver esta clase, mi solución se basa en partir por la mitad el triángulo a través de la base, para formar un triángulo rectángulo, entonces usando razones y funciones trigonométricas se calcula la longitud del lado desconocido del nuevo triángulo que sería la altura del triángulo original.

function calcTriangleHeight(b, sides) {
    /*
                 ^
hypotenuse -->  /|\   
               / | \ <-- sides
              /__|__\
       angle°  ^
               | 
              newBase
    */

    const newBase = b / 2;
    const hypotenuse = sides;
    /*
        se despeja el ángulo(α) usando álgebra y la función inversa de cos
        que es arccos ó Cos^-1(coseno elevado a -1)

        despejando el ángulo:
        cos(α) = cateto adyacente / hipotenusa
     	  cos^-1(cos(α)) = cos^-1(cateto adyacente / hipotenusa)
        α = cos^-1(cateto adyacente / hipotenusa)
    */
    const angle = Math.acos(newBase / hypotenuse);

    /*
        teniendo el ángulo, la hipotenusa y sabiendo que:
        sen(α) = cateto opuesto / hipotenusa

        despejamos al cateto opuesto:
        sen(α) * hipotenusa = cateto opuesto
        ordenando:
        cateto opuesto = sen(α) * hipotenusa

        (el cateto opuesto de este nuevo triángulo es la altura del triángulo original)
    */
    const height = Math.sin(angle) * hypotenuse;
    return height;
}

const triangle = {
    sides: 5.4,
    base: 3
}

triangle.height = calcTriangleHeight(triangle.base, triangle.sides);
triangle.area = (triangle.base * triangle.height) / 2;
console.table(triangle);

Resultado: