Reto: altura de un triángulo

Taller Práctico de JavaScript: Matemáticas y Estadística Básica

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Práctico de JavaScript?
08:20 min

Matemáticas en JavaScript

Porcentajes

Estadística básica

Análisis de salarios

Próximos pasos

30
Toma el Taller Práctico de JavaScript: Videojuegos
04:27 min

Tomar examen

Reto: altura de un triángulo

Todos los cursos GRATIS

Se acaba en:

00díasd:00hrsh:00minm:00segs

Juan Jose Sepulveda Calderon

Estudiante

Hace 4 años

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.

Juan Castro

Profesor

Hace 4 años

:clap:

Aaron Carhuaricra

Estudiante

Hace 3 años

Hola compañero, lo que pasa es que aqui hay un problema que me di cuenta cuando uso las 2 formulas (la que sacaste por este calculo y la de Heron) y es que cuando usas esta formula es necesario saber las posiciones de los lados laterales, me refiero a cual esta en la izquiera y cual en la derecha sino la formula cambiaria, por el contrario la formula de Heron solo usa semi perimetros y lo unico que debes tener en claro es cual es la base (que siempre es el lado mas grande paraa poder tener un angulo recto al momento de trazar la altura "h")

Ezequiel Dastolfo

Jorge A. Torres

Estuvo potente la clase

Santiago Forero Zapata

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

Jorge Arias Argüelles

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

JUAN CAMILO CAMPO TANGARIFE

una pregunta, amigo, por qué haces el sort? para determinar que a va a ser elado menor?

Hello JuanCa!! Si señor, cómo dices... el sort lo uso para ordenar de menor a mayor.

Gustavo Liendo

Reto exitoso!!! les dejo por acá si quieren checar el código para guiarse un poco ;)

console.group('TrianguloEscaleno');

function calcularTrianguloEscaleno(a, b, c) {
    const Semiperimetro = (a + b + c ) /2 ;

    if (a == b && a == c ) {
        console.warn('Este no es un triangulo escaleno.')
    }
    else {
        H = ((2/a) * (Math.sqrt(Semiperimetro * (Semiperimetro - a) *(Semiperimetro - b) * (Semiperimetro - c))));
        console.log('La altura "H" = ' + H) ;
    }
}


console.groupEnd('TrianguloEscaleno');

Luis E. Gama Ramirez

Hola bro, estuve checando tu codigo, pero no entendi esta parte.

H = ((2/a) * (Math.sqrt(Semiperimetro * (Semiperimetro - a) *(Semiperimetro - b) * (Semiperimetro - c))));

Mmm... Se supone que uno de los Semiperimetros (a,b,c) es la altura que se busca, entonces por que ponerla en la operacion. Si solo se buscan dos valores.

Me podrias explicar. '?

Hola si claro, mira cuando estuve y el semiperimetro es un valor que necesitamos para hallar la altura H. te dejo un capture para que te guíes mejor.

Carlos López

Aprendí mejor el teorema de Pitágoras en los minutos que lo explicó juan que en todo mi bachillerato

Sebastian Pacheco Lopez

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
}

Remix Zapata

Aprovechando que vengo del curso de POO básico, usé lo estudiado para hacer esto

class Triangle {
    constructor({
        lado1,
        lado2,
        ladoBase,
        height,
    }) {
        this.lado1 = lado1;
        this.lado2 = lado2;
        this.ladoBase = ladoBase;
        this.height = height;
    }

    getHeight() {
        return this.height;
    }

    getPerimeter() {
        const perimeter = this.lado1 + this.lado2 + this.ladoBase;
        return perimeter;
    }

    getArea() {
        const area = (this.ladoBase * this.getHeight()) / 2;
        return area;
    }
}

class ScaleneTriangle extends Triangle {
    constructor(props) {
        super(props);
    }

    getHeight() {
        // h = 2 / ladoBase Raiz(S(S-a)(S-b)(S-c))
        // S = SemiPerimeter
        const S = (this.lado1 + this.lado2 + this.ladoBase) / 2;
        const height = (2 / this.ladoBase) * Math.sqrt(S * (S - this.lado1) * (S - this.lado2) * (S - this.ladoBase));
        return height;
    }

    getArea() {
        const area = 0.5 * this.ladoBase * this.getHeight();
        return area.toFixed(2);
    }
}

class IsoscelesTriangle extends Triangle {
    constructor(props) {
        super(props);
    }

    getHeight() {
        const height = Math.sqrt((this.lado1 ** 2) - (this.ladoBase ** 2) / 4);
        return height;
    }

    getArea() {
        const area = 0.5 * this.ladoBase * this.getHeight();
        return area.toFixed(2);
    }
}

class EquilateralTriangle extends Triangle {
    constructor(props) {
        super(props);
    }

    getHeight() {
        // h = ( Raiz(3) * lado1 ) / 2
        const height = (Math.sqrt(3) * this.lado1) / 2;
        return height;
    }

    getArea() {
        const area = (this.ladoBase * this.getHeight()) / 2;
        return area.toFixed(2);
    }
}




const myIsoscelesTriangle = new IsoscelesTriangle({
    lado1: 14,
    ladoBase: 12,
})

const myScaleneTriangle = new ScaleneTriangle({
    lado1: 10,
    lado2: 12,
    ladoBase: 14,
});

const myEquilateralTriangle = new EquilateralTriangle({
    lado1: 45,
});

Erika Nathaly Bernal Morales

Reto logrado!!! 💪😀💻🚀

Teniendo la fórmula, pensé en las posibles combinaciones que NO son triángulos escalenos como por ejemplo: 444, 464, 446, 644 y la que SÍ 456 (TODOS los lados diferentes). Esto para hacer la validación y así obligar a los usuarios a colocar valores distintos.

function calcularAlturaTrianguloEscaleno(lado1, lado2ybase, lado3) {
	const semiperimetro = (lado1 + lado2ybase + lado3) / 2;
	if (lado1 == lado2ybase && lado1 == lado3 && lado2ybase == lado3 || lado1 == lado2ybase && lado1 != lado3 && lado2ybase != lado3 || lado1 == lado3 && lado1 != lado2ybase && lado2ybase != lado3 || lado1 != lado2ybase && lado1 != lado3 && lado2ybase == lado3) {
		console.warn('Este no es un triángulo escaleno');
	} else {
		return ((2 / lado2ybase) * (Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2ybase) * (semiperimetro - lado3))));
	}
}

Javier Luján Blanco

Me ha costado un rato, pero al final ha salido!! Saludos!!

Nestor Rios Garcia

Lo he hecho técnicamente igual:

function scalaneTriangleheight(side1, side2, side3) {
    if (side1 == side2 || side1 == side3 || side2 == side3) {
        console.warn('Este no es un triangulo escaleno');
    } else {
        // Heron formula
        const perimeter = side1 + side2 + side3;
        const S = perimeter / 2;
        const heightSide1 = (2 / side1) * (Math.sqrt( S * (S - side1) * (S - side2) * (S - side3) ) );
        const heightSide2 = (2 / side2) * (Math.sqrt( S * (S - side1) * (S - side2) * (S - side3) ) );
        const heightSide3 = (2 / side3) * (Math.sqrt( S * (S - side1) * (S - side2) * (S - side3) ) );
    
        const result = `Triangle sides: ${side1}, ${side2}, ${side3},  | height Side1: ${heightSide1}, height Side2: ${heightSide2}, height Side3: ${heightSide3},`
        console.log(result);
    }
}

Elizabeth Vega Rosas

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.

Porque estabas bebé :joy:

¡Dentro del primer condicional puedes escribir otro condicional donde hagas las validaciones que faltan, Eliza!

Misael Arena

🔥🔥

function trianguloEscaleno(base, lado1, lado2){

    const semiperimetro = (base + lado1 + lado2) / 2;

    if(base == lado1 && base == lado2){

        console.warn('No es un triangulo escaleno');
    }
    else{

        altura = ((2 / base) * Math.sqrt(semiperimetro * (semiperimetro - base) * (semiperimetro- lado1) *(semiperimetro- lado2)));
    }

    console.log('La altura del traindulo es = ' + altura.toFixed(2));
};

Sebastián Ricardo Ochoa Pete

Mi solución al reto:

Edwin Miguel Orellana Sotomayor

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

Ramon Deras

Hace 2 años

function calcularAlturaTrianguloEscaleno(lado1, lado2, lado3) { const semiPerimetro = (lado1+lado2+lado3)/2); const resul1 = (semiPerimetro - lado1); const resul2 = (semiPerimetro - lado2); const resul3 = (semiPerimetro - lado3); const resul4 = (semiPerimetro * ((resul1 * resul2) * resul3));

// Resultado Altura

return (2/lado1) * (Math.sqrt(resul4))

}

Nestor Luis Álvarez Rojas

Una pregunta que me surge a partir del código que utilizaste, pues la división del 4 me parece que está fuera de los paréntesis correctos.

Tu código:

Math.sqrt( (lado1 ** 2) - ( (base ** 2) ) / 4 );

La opción que me tiene inquieto:

Math.sqrt( (lado1 ** 2) - ( (base ** 2) / 4 ) );

Kevin J. Zea Alvarado

Hola, Nestor. 👋 Excelente observación. Para tener un mejor orden y lectura, lo recomendado es que el / 4 esté dentro como la opción que propones.

Julián Castrillón

Exactamente iba a realizar la misma pregunta, ya que de esta forma el resultado si es notablemente diferente.

Sonia Mendoza

![](

Esta en mi funcion;

function calcularAlturaDeTrianguloEscaleno(ladoA, ladoB, ladoC){
    if(ladoA!==ladoB && ladoA!==ladoC && ladoB!==ladoC ){
        const s = (ladoA + ladoB + ladoC)/2;
        const alturaA = ((2/ladoA) * Math.sqrt((s)*(s-ladoA)*(s-ladoB)*(s-ladoC)));
        const alturaB = ((2/ladoB) * Math.sqrt((s)*(s-ladoA)*(s-ladoB)*(s-ladoC)));
        const alturaC = ((2/ladoC) * Math.sqrt((s)*(s-ladoA)*(s-ladoB)*(s-ladoC)));
        console.log({s, alturaA, alturaB, alturaC });
        return(`La altura del triangulo escaleno respecto a la cara "a" es: ${alturaA.toFixed(2)}cm, respecto a la cara "b" es: ${alturaB.toFixed(2)}cm, respecto a la cara "C" es: ${alturaC.toFixed(2)}cm`)
    } else{
        console.warn('Este no es un triangulo escaleno');
    }
}
calcularAlturaDeTrianguloEscaleno(12,15,16);

Bastian Maurico Landskron Silva

function calcularTrianguloEscaleno(a, b, c) {
    if (a <= 0 || b <= 0 || c <= 0) {
        return "Los lados del triángulo deben ser valores positivos.";
    }

    if (a + b <= c || a + c <= b || b + c <= a) {
        return "No es un triángulo válido. La suma de dos lados debe ser mayor que el tercer lado.";
    }

    const semiperimetro = (a + b + c) / 2;
    const area = Math.sqrt(semiperimetro * (semiperimetro - a) * (semiperimetro - b) * (semiperimetro - c));

    return {
        tipo: "Escaleno",
        perimetro: a + b + c,
        area: area.toFixed(2)
    };
}

const ladoA = parseFloat(prompt("Ingresa la longitud del primer lado:"));
const ladoB = parseFloat(prompt("Ingresa la longitud del segundo lado:"));
const ladoC = parseFloat(prompt("Ingresa la longitud del tercer lado:"));

const resultado = calcularTrianguloEscaleno(ladoA, ladoB, ladoC);

console.log("Tipo de triángulo:", resultado.tipo);
console.log("Perímetro:", resultado.perimetro);
console.log("Área:", resultado.area);

function esTrianguloEscaleno(a, b, c) {
    if (a <= 0 || b <= 0 || c <= 0) {
        return "Los lados del triángulo deben ser valores positivos.";
    }

    if (a === b || a === c || b === c) {
        return false;
    }

    if (a * a + b * b === c * c || a * a + c * c === b * b || b * b + c * c === a * a) {
        return true;
    }

    return false;
}

const ladoA = parseFloat(prompt("Ingresa la longitud del primer lado:"));
const ladoB = parseFloat(prompt("Ingresa la longitud del segundo lado:"));
const ladoC = parseFloat(prompt("Ingresa la longitud del tercer lado:"));

if (esTrianguloEscaleno(ladoA, ladoB, ladoC)) {
    console.log("El triángulo es escaleno.");
} else {
    console.log("El triángulo no es escaleno.");
}

Reto: altura de un triángulo

Introducción

¿Ya tomaste el Curso Práctico de JavaScript?

Matemáticas en JavaScript

Fórmulas matemáticas en JavaScript

Math en JavaScript

Reto: altura de un triángulo

Playground: Calcula la Altura de un Triángulo Escaleno

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Playground: Encuentra el ID

Estadística básica

Qué es promedio, moda y mediana

Calculando el promedio

Método reduce

Calculando la mediana en una lista impar

Calculando la mediana en una lista par

Método sort

Calculando la moda: objetos a partir de arrays

Calculando la moda: arrays a partir de objetos

Playground: Transforma Objetos en Arrays

Promedio Ponderado en JavaScript: Fórmulas y Casos de Uso

PlatziMath: clases y métodos estáticos

Análisis de salarios

Cómo estructurar información en proyectos de software

Análisis salarial con JavaScript

Proyección salarial personal

Reestructurando información sobre la marcha

Salarios empresariales

Proyección de salarios por empresas

Top 10% de salarios

Análisis de la Mediana Salarial con HTML, CSS y JavaScript

Próximos pasos

Toma el Taller Práctico de JavaScript: Videojuegos

Todos los cursos GRATIS