Reto: altura de un triángulo

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.

Estuvo potente la clase

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

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

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

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

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
}

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

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.

JS

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

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

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.

🔥🔥

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

Mi solución al reto:

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

![](

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

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

Muy divertida la prueba, me entretuve leyendo sobre los triangulos y recorde viejos tiempos… hermosos… (notese el sarcasmo)

function alturaTrianguloEscaleno(a,b,c){

    if(a===b || b===c || a===c){
        console.warn("Para que sea Escaleno, sus lados todos distinto ser deben");
    }
    const semiPerimetro = (a + b + c) / 2;
    const area = Math.sqrt((semiPerimetro * (semiPerimetro - a) * (semiPerimetro - b) * (semiPerimetro - c)));
    const h = (2 * area) / b;
    return h;
}
console.log(`Altura de un Escaleno: ${alturaTrianguloEscaleno(3,5,7)}`);
console.groupEnd('Triangulo Escaleno');

Lo hice de la siguiente forma:

function triangleEscaleno(lado1,lado2,base){
  if(base != lado1 && base != lado2 && base>0 && lado1>0 && lado2>0){
    let s=(lado1+lado2+base)/2;
    let a = Math.sqrt(s*(s-lado1)*(s-lado2)*(s-base));
    let h=(2*a)/base;
    return console.log(
      `
      Semiperímetro = ${s};
      Area = ${a};
      Altura = ${h};
    `)
  }else{
    console.warn('¡No son valores validos para un Triangulo Escaleno!')
  }
}

Hello, mi aporte:

function alturaTrianguloEscaleno(a,b,c){

    if(a===b || b===c || a===c){
        console.warn("Para que sea Escaleno, sus lados todos distinto ser deben");
    }
    const semiPerimetro = (a + b + c) / 2;
    const area = Math.sqrt((semiPerimetro * (semiPerimetro - a) * (semiPerimetro - b) * (semiPerimetro - c)));
    const h = (2 * area) / b;
    return h;
}

Hola!! aquí mi solución

function scaleneSquare(aSide,bSide) {
    if (this.aSide == bSide) {
        throw new Error("To create a scalene square the sides must be different");
    }

    this.a = aSide;
    this.b = bSide;
    this.c = Math.sqrt( (aSide**2) + (bSide**2) );

    this.validPythagorasTheorem = function() {
        return Math.round(this.c**2) == Math.round( (this.a**2) + (this.b**2) );
    }
    this.getSemiPerimeter = function() {
        return (this.a + this.b + this.c) / 2;
    }
    this.getHeight = function() {
        let s = this.getSemiPerimeter();
        return (2/this.a) * Math.sqrt( s * (s-this.a)*(s-this.b)*(s-this.c) );
    }
}

Me salió distinto a otros resultados que vi ya que la “formula” que encontré es distinta, aun así el calculo que hace mi calculadora es correcta

function calcularAlturaTrianguloEscaleno(a, b, c){
    if(a == b || a  == c || b == c){
        console.log("No es un triangulo escaleno ya que tienen 2 lados iguales")
    }else{
        const semiP = (a + b + c) / 2;
    const area = Math.sqrt(semiP * (semiP - a) * (semiP - b) * (semiP - c));
    const base = Math.max(a, b, c);
    const altura = (2 * area) / base;
    console.log(altura)
    }   
}

La solucion presentada al reto es considerando la formula de heron para calcular la altura.

 function alturaTrianguloEscaleno(lado1,lado2,lado3){
    let area,semiperimetro,altura;
    if (lado1==lado2 || lado1==lado3 || lado2==lado3){
        console.log('Esto no es un triangulo escaleno');
    }else{
        //según teorema de heron: 
        semiperimetro=(lado1+lado2+lado3)/2;
        console.log(semiperimetro);
        area=Math.sqrt(semiperimetro*(semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-lado3));
        console.log(area);
        altura=2/lado3*area;
        console.log(altura);
        return altura;
    }
 } 

Asi lo hize yo:

Formula:

Codigo:

//El lado1 es tambien la base, por esto debemos de poner primeramente la base, ya que esto altera el resultado si la ponemos en otro lugar.
function calcularAlturaTrianguloEscaleno(lado1_base,lado2,lado3){
    Semiperimetro = (lado1_base + lado2 + lado3) / 2;
    
    // Primero se define que todos los lados sean desiguales
    if (lado1_base == lado2 || lado1_base == lado3 || lado2 == lado1_base || lado2 == lado3 || lado3 == lado1_base || lado3 == lado2){
        console.warn('Este es un triangulo escaleno')
    } else {
        //Primero se hace la operacion dentro de la raiz
        const operacionDentroRaiz = Semiperimetro*(Semiperimetro-lado1_base)*(Semiperimetro-lado2)*(Semiperimetro-lado3);
        //Luego se hace la raiz
        const operacionRaiz = Math.sqrt(operacionDentroRaiz)
        //Por ultimo, para pasar la raiz a decimal se divide 2 entre el lado-base, para luego multiplicarlo por el resultado de la raiz
        return (2/lado1_base) * operacionRaiz;
    }
}

Ejemplo resuelto:

Consola:

Ejemplo resuelto 2:

Consola 2:

Mi aporte 😃
asi lo hice y me parecio de esta manera sencillito, espero les sriva 😄 !!

/* h= (2/a) math.sqrt(S(S-a)(S-b)(S-c)), teniendo en cuenta que S= (lado1 + lado2 
+ lado 3) /2 */

function alturaTrianguloEscaleno(lado1,lado2, lado3){
    if (lado1 === lado2 && lado1 === lado3 && lado2 === lado3){
        console.log('segun las medidas no es un triangulo escaleno');

    }else{ 
        const semiPerimetro = (lado1 +lado2+lado3) / 2;
        return (2/lado1) * (Math.sqrt(semiPerimetro*((semiPerimetro-lado1)*(semiPerimetro-lado2)*(semiPerimetro-lado3))));
    }
};

console.groupEnd('alturaTrianguloEscaleno');

console.group('trianguloEscaleno');

function calcularAlturaTriangulo(base, ladoA, ladoB) {
    // Calculamos el semiperímetro del triángulo
    const  semiperimetro = (base + ladoA + ladoB) / 2;
  
    // Calculamos el área del triángulo usando la fórmula de Herón
    const  area = Math.sqrt(semiperimetro * (semiperimetro - base) * (semiperimetro - ladoA) * (semiperimetro - ladoB));
  
    // Calculamos la altura dividiendo el área por la longitud de la base
    const  altura = (2 * area) / base;
  
    return altura;
  }
  
  // Ejemplo de uso
  const base = 5;
  const ladoA = 7;
  const  ladoB = 9;
  
  const  altura = calcularAlturaTriangulo(base, ladoA, ladoB);
  console.log("La altura del triángulo es: " + altura);
  

console.groupEnd('trianguloEscaleno');

Notas de la clase ✍🏻

// Calcular altura de un triangulo isósceles conociendo los lados iguales y la base
function alturaTrianguloIsosceles(lado1, lado2, base) {
  if (lado1 === lado2 && lado1 !== base) {
    const altura = Math.sqrt(lado1 ** 2 - base ** 2 / 4);
    return altura;
  } else {
    return "No es un triángulo isósceles";
  }
}

// Calcular altura de un triangulo escaleno conociendo los lados
function alturaTrianguloEscaleno(lado1, lado2, base) {
  if (lado1 !== lado2 && lado1 !== base && lado2 !== base) {
    const semiperimetro = (lado1 + lado2 + base) / 2;
    const altura =
      (2 / base) *
      Math.sqrt(
        semiperimetro *
          (semiperimetro - lado1) *
          (semiperimetro - lado2) *
          (semiperimetro - base)
      );
    return altura;
  } else {
    return "No es un triángulo escaleno";
  }
}

Function Iluminati(Juan,DC){
}

AJAJAJ “no quiero sonar como que soy el mesias de las matematicas” El profe Juan David Castro es definitivamente uno de mis idolos

Mii solución al reto, utilizando el teorema de Pitágoras para despejar la variable altura del triangulo

function  calcularTrianguloEscaleno(a,b,c){
	const x = (((a ** 2) + (b ** 2) -(c ** 2))/(2 * a));

	if(a == b || b == c || a == c){
	console.warn ('No es un triangulo escaleno');
} else {
	return Math.sqrt((b ** 2) - (x ** 2));
}
}

function calcularAlturaTrianguloEscaleno(
  lado1Escaleno,
  lado2Escaleno,
  ladoBaseEscaleno,
) {
  const semiPerimetro = (lado1Escaleno + lado2Escaleno + ladoBaseEscaleno) / 2
  return (
    2 / ladoBaseEscaleno *
    Math.sqrt(
      semiPerimetro *
        (semiPerimetro - ladoBaseEscaleno) *
        (semiPerimetro - lado1Escaleno) *
        (semiPerimetro - lado2Escaleno),
    )
  )
}

//Reto Clase 4: Altura de triangulo Escaleno

function calcularAlturaTrianguloEscaleno(lado1, lado2, base) {
    if (lado1 != base && lado2 != base && lado1!=lado2) {
        // h = (2 * areaTrianguloEscaleno) / base 
        // areaTrianguloEscaleno = raizcuadrada((S * (S - lado1)*(S - lado2) * (S - base)))
        // Formula Heron ==> S = ((lado1 + lado2 + base) / 2)

        const S = ((lado1 + lado2 + base) / 2);
        const areaTrianguloEscaleno = Math.sqrt ((S * (S - lado1) * (S - lado2) * (S - base)));
        const alturaTrianguloEscaleno = (2 * areaTrianguloEscaleno) / base ;
        return alturaTrianguloEscaleno; 

    } else {
        console.warn ('Este no es un triangulo Escaleno');
    }
}

Estuve leyendo sobre las distintas formas de calcular la altura no solo conociendo los tres lados sino con otros parametros y lo pase a codigo. El divertido fue con un lado y un angulo ya que descubri que tenia que hacer un paso mas para pasar a radianes el angulo dado.

function calcularAlturaTrianguloEscaleno(base, lado1, lado2) {
    if (base == lado1 || base == lado2) {
        console.warn('Este no es un triangulo escaleno')
    } else {
        const semiperimeter = (base + lado1 + lado2) / 2;
        return (2 / base) * Math.sqrt(semiperimeter * (semiperimeter - base) * (semiperimeter - lado1) * (semiperimeter - lado2)) 
    } 
}

function calcularTrianguloEscalenoLadoAngBase(ladoLateral, anguloBase) {
    const anguloBaseRadianes = anguloBase * (Math.PI / 180)
    return ladoLateral * (Math.sin(anguloBaseRadianes));
}

function calcularTrianguloEscalenoAreaBase (area, base) {
    return (2 * area) / base;
}```

Mi solucikon es:

function calcularAlturaCualquierTriangulo(a,b,c) {
  return ((Math.sin(Math.acos(((a ** 2) + (c ** 2) - (b ** 2)) / (2 * a * c) ))) * a);
}

calcularAlturaCualquierTriangulo(2, 4, 5);

function AlturaEscaleno(lado1,lado2,lado3) {
    if (lado1==lado2 || lado1==lado3 ||lado3==lado2) {
        console.warn("Rompiste las matemáticas");
    }else{
        let semiperimetro= (lado1+lado2+lado3)/2;
        let altura= (2/lado1)*Math.sqrt(semiperimetro*(semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-lado3));
        if (altura==0) {
            console.warn("Rompiste la desigualdad triangular");
        }
        return altura;
    }
}

Para los curiosos aqui estan los tipos de triangulos y los terminos que usa 😃

// ---------------- TRIANGULO ESCALENO ---------------------------
// altura=2/ladoA raizCuadrada S(S-ladoA)(S-ladoB)(S-ladoC)
// S=ladoA+ladoB+ladoC/2

function calcularAlturaTrianguloEscaleno(ladoA, ladoB, ladoC){
const semiPerimetro = (ladoA+ladoB+ladoC)/2;
const raizCuadrada = Math.sqrt(semiPerimetro*(semiPerimetro-ladoA)(semiPerimetro-ladoB)(semiPerimetro-ladoC));
const result = ((2/ladoA) * (raizCuadrada));
return result;
}

Completado!!

const zonaDerecha = 6
const zonaIzquierda = 4
const baseEscaleno = 7

let semiPerimetro = (zonaDerecha + zonaIzquierda + baseEscaleno) / 2

const alturaEscaleno = (2 / baseEscaleno) * Math.sqrt(semiPerimetro * (semiPerimetro - baseEscaleno) * (semiPerimetro - zonaIzquierda) * (semiPerimetro - zonaDerecha))

console.log({
    zonaDerecha,
    zonaIzquierda,
    baseEscaleno,
    semiPerimetro,
    alturaEscaleno
})

function CalcularAlturaEscaleno(ladoDerecho, ladoIzquierdo, base){
    const semiPerimetro = (ladoDerecho + ladoIzquierdo + base) / 2

    return{
        Altura_Escaleno: (2 / base) * Math.sqrt(semiPerimetro * (semiPerimetro - base) * (semiPerimetro - ladoIzquierdo) * (semiPerimetro - ladoDerecho))
    }
}

function calculoHaltura (ladoA, ladoB, ladoC) {
let S = (ladoA + ladoB + ladoC ) / 2 ;
let h = 0;
console.log(S)
return{
h : 2 * Math.sqrt(S * (S-ladoA) * (S-ladoB) * (S-ladoC) ) / ladoA
}
}
console.log(calculoHaltura(12, 15, 14))

Esta es mi solución, Tomé en cuenta las condiciones a cumplir para que sea Escalano.

baseEs.addEventListener('change', ()=>{
    let lado1Es =  Number(lado1Esc.value);
    let lado2Es =  Number(lado2Esc.value);
    let baseEsc =  Number(baseEs.value);
    
    if(lado1Es > 0 && lado2Es > 0 && baseEsc > 0 ||
        lado1Es != lado2Es ||  lado2Es != baseEsc ||
        lado1Es != baseEsc){
            
            let semiPerimetro = (lado1Es + lado2Es + baseEsc) / 2;
            let sA = semiPerimetro - baseEsc;
            let sB = semiPerimetro - lado1Es;
            let sC = semiPerimetro - lado2Es;
            let raiz = semiPerimetro * sA * sB * sC;
            let altura = 2 / baseEsc * Math.sqrt(raiz);
            
            alturaEsc.innerHTML = "La altura del triángulo escaleno es " + altura;
            
        }else if(lado1Es == 0 || lado2Es == 0 || baseEsc == 0){
            alturaEsc.innerHTML = "Las medidas no pueden ser 0";

        }else if(lado1Es == lado2Es ||  lado2Es == baseEsc || lado1Es == baseEsc){
            alturaEsc.innerHTML = "Los lados no pueden ser iguales";
        }
        
    })

Mi solucion al Reto

Mi code:

// Function to calculate the height in a isosceles 
function calculateScaTriangleHeight(a, b, c) {
    if(a == b || a == c || b == c) {
        console.warn("It isn't a scalene triangle");
    }
    else {
        return {
            height: Math.sqrt(c ** 2 - ((c ** 2 - a ** 2 + b ** 2) / (2 * b)) ** 2)
        }
    }
}

function altura(a,b){
    let lado =Math.pow(a,2);
    let base = Math.pow(b,2);
    let raiz = (Math.sqrt(lado-(base/4))).toFixed(2);
    return raiz;
}
console.log(altura(4,4));

Mi solución del reto:

function calcularAlturaTrianguloEscaleno(lado1, lado2, base) {
    if (lado1 == lado2 || lado1 == base || lado2 == base) {
        console.warn('Este no es un triángulo Escaleno');
    } else {
        const sp = (lado1 + lado2 + base) / 2;
        return (2 / lado1) * Math.sqrt( sp * (sp - lado1) * (sp - lado2) * (sp - base) );
    }
}

Reto resuleto aqui mi codigo

function calcularAlturaTrianguloEscaleno(lado1, lado2, base) {
    const s = (lado1 + lado2 + base)/ 2 // s = Semiperimetro

    if( lado1 == lado2 || lado1 == base || lado2 == base) {
        console.warn('Este no es un triangulo escaleno');
    } else {
        return 2/lado1*(Math.sqrt(s*(s - lado1)*(s - lado2)*(s - base)));
    }
}

Yo lo logre con la formula de Heron y este es el codigo

function calcularAlturaTrianguloEscaleno(lado1, lado2, base) {
  const perimetro = (lado1 + lado2 + base) / 2;
  
  if (lado1 == lado2 || lado1 == base || lado2 == base) {
    console.warn("Este no es un triangulo escaleno");
  } else {
    return 2 / base * Math.sqrt(perimetro * (perimetro - base) * (perimetro - lado1) * (perimetro - lado2) );
  }
}

Yo logre hacerlo asi, aunque no tenia idea de que era un semiperimetro hasta que lo busque en google para esta clase.

function calcularAlturaTrianguloEscaleno(a, b, c){
    if (a == b || b == c || c == a) {
        console.warn('Este no es un triangulo escaleno');
    } else {
        //Formula H(altura)/ 2/a raizcuadrada de s*(s-a)*(s-b)*(s-c)
        //Formula S(semiperimetro)/ (a+b+c)/2
        const s = (a+b+c) / 2;
        return 2/a * Math.sqrt( s*(s-a) * (s-b) * (s-c) );
    }
}

siguiendo el reto de hallar la altura con el teorema de Pitágoras: hallar hipotenusa ósea la altura:
Mi solución:

//Triangulo escaleno: altura, base

function calcularAlturaEscaleno(a,b) {
    const h = Math.sqrt((a**2) + (b**2))

    if (a == b || a == h || b == h) {
        console.warn('Este no es un triangulo escaleno')
    } else {
        console.log(h)
    }
}

function calcularAlturaTrianguloEscaleno(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    console.warn("Este no es un triangulo escaleno")
  } else {
    // h = 2/lado1 raizcuadrada(semiperimetro(semiperimetro - lado1) (semiperimetro - lado2) (semiperimetro - lado3))
    const semiperimetro = (lado1 + lado2 + lado3) / 2
    const altura = 2/lado1 * Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))
    return altura
  }
}

Solucion:

function calcularAlturaTrianguloEscaleno(lado1, lado2, base){
    const semiPerimetro = (lado1 + lado2 + base) / 2;
    if(lado1 == lado2){
        console.warn("Este es un triangulo isosceles");
    }else{
        return (2 / base) * Math.sqrt(semiPerimetro * (semiPerimetro - base) * (semiPerimetro - lado1) * (semiPerimetro - lado2));
    }
}

Usando el teorema de Pitágoras y remplazando ambas ecuaciones hallamos la Altura de nuestro triangulo escaleno

Paso 1
Halle el ángulo existente entre el lado a y lado c, con el teorema de cosenos
Paso 2
Con la función trigonométrica seno del ángulo hallado, se puede calcular la altura
Paso 3
Cálculo base * altura /

function calcularAreaTriangulo(a,b,c){
    // ------- Paso 1 -------------
    const tita = Math.acos( ( (a*a+c*c-b*b) / (2*a*c) ));
    // ------- Paso 2 -------------
    const altura = a * Math.sin(tita);
    // ------- Paso 3 -------------
    return ({
        altura,
        area: (c*altura)/2
    })
}

Aca esta mi soluciòn al reto, tuve que googlear la formula y me sirvio para refrescar / recordar contenido interesante 😄

Primero validar que los 3 lados sean distintos, y luego emplear los datos para hallar la altura con la fomrula de la imagen,

function calchTrianguloEsca(a,b,c) {

  if ( a !== b && b !== c && c !== a ) {

      let perimetroEsca = a + b + c;
            
      let sp = perimetroEsca / 2 ; 
      
      let hTrianguloEsca = ( 2 / a ) * ( Math.sqrt( sp * ( ( sp - a ) * ( sp - b ) * ( sp - c ) )) );

      return hTrianguloEsca;
  }

  else {

      console.warn("Todos los lados de un triangulo escaleno, deben ser de distintas longitudes");
  }
} 

Estuvo emocionante este reto

Reto cumplido

function scaleneTriangle (lado1 , lado2, lado3) {
    const semiperimetro = (lado1 + lado2 + lado3 ) / 2;
    const area = Math.sqrt(semiperimetro*(semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-lado3));
    const perimeter = lado1 + lado2 + lado3;
    const height = ( 2 / lado1 ) * area;
    return {
        dataArea: area,
        dataPerimeter: perimeter,
        datoheight : height
    }
}

Sí los lados de un triángulo isósceles miden lo mismo, entonces solo necesito solicitar el valor de uno de los lados y la base.

¿Estoy bien?

console.group("Calcular la altura de un triángulo isósceles");
//Fórmula: h=|a^2 - b^2/4| (| representan la raíz cuadrada)
function alturaTrianguloIsosceles(a, b) {
    return {
        altura: Math.sqrt(Math.pow(a, 2) - (Math.pow(b, 2) / 4)).toFixed(2)
    }
}

console.log(alturaTrianguloIsosceles(3, 2));
console.groupEnd("Calcular la altura de un triángulo isósceles");

yo busque como sacar la formula de la altura y me encontré con la formula de Heron, aquí les comparto el link a la pagina y mi solución

https://www.neurochispas.com/wiki/altura-de-un-triangulo-escaleno/

function alturaEscaleno(a, b, c) { // a es la base
  const s = (a + b + c)/2; // semiperimetro
  const altura = (2/a*Math.sqrt(s*(s - a) * (s - b) * (s - c)));
  return altura;
}

Está es mi solución:

  function calcularAlturaTriangulo(ladoA, ladoB, ladoC) {
const semiPerimetroTriangulo = (ladoA + ladoB + ladoC) / 2
            if (ladoA == ladoB || ladoA == ladoC || ladoA == ladoC || ladoB == ladoC) {
                console.warn('Este no es un triángulo escaleno');
            }
            else {
                return 2/ladoA * Math.sqrt(semiPerimetroTriangulo*(semiPerimetroTriangulo-ladoA)*(semiPerimetroTriangulo-ladoB)*(semiPerimetroTriangulo-ladoC))
            }

        }

Aqui está el reto cumplido

Por aca comparto mi solucion luego de una fuerte googleada para obtener la formula😂

const hasDuplicatedValues = array => {
    const set = new Set(array)
    
    return set.size !== array.length
}

const calculateScaleneTriangleHeight = (sideA, sideB, base) => {
    if (hasDuplicatedValues([sideA, sideB, base])) {
        console.warn('This is not a scalene triangle')
        return
    }
    
    const semiperimeter = (sideA + sideB + base) / 2
    const height = (2 / base) * Math.sqrt(
        semiperimeter *
        (semiperimeter - base) *
        (semiperimeter - sideA) *
        (semiperimeter - sideB)
    )

    return height
}

function alturaEscaleno(a,b,c) {
  const S = (a + b + c) / 2;
  const h = (2/a) * Math.sqrt(S * ((S-a) * (S-b) * (S-c)) )
  return h;
}

console.log(alturaEscaleno(6,8,10)); // 8

Reto 🎯

function calcularAlturaTrianguloEscaleno(ladoA,ladoB,ladoC){
    const semiperimetro = ((ladoA + ladoB + ladoC) / 2);
    return{
        altura:(2/ladoA) * Math.sqrt(semiperimetro*(semiperimetro-ladoA)*(semiperimetro-ladoB)*(semiperimetro-ladoC))
    }
}

Mi solución supone que se saben los 3 datos para hallar y calcular la altura del 🔺triangulo escaleno 🔺, dejo sitio web donde ofrecen alternativas mas retantes para llegar al mismo resultado con la menor cantidad de datos sabidos.

NeuroChispas 🧠

function calcularAlturaTrianguloEscaleno(lado1,lado2,ladoBase) {
    if(lado1 == lado2 || lado2 == ladoBase || ladoBase == lado1) {
        console.warn ('lados iguales, no es triangulo escaleno')
    } else {
        /*
            semiperimetro = (lado1 + lado2 + ladoBase) / 2
            altura = 2/lado1 * Math.sqrt(semiperimetro * (semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-ladoBase))
        */
        const semiperimetro = (lado1 + lado2 + ladoBase) / 2
        return {
            altura: 2 / ladoBase * Math.sqrt(semiperimetro * (semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-ladoBase)) 
        }
        
    }
}

Esta fue mi solución al reto:

saqué la fórmula para calcular la altura de esta página: https://www.neurochispas.com/wiki/altura-de-un-triangulo-escaleno/#2-formula-de-la-altura-de-un-triangulo-escaleno

¿Sabían que el teorema de pitagoras es mas hermoso y más completo si lo vemos geometricamente?. Podemos poner cualquier figura, no solo un cuadrado, a los lados del triangulo y sus áreas siempre cumplen el teorema de pitagoras. Es decir, la suma de las áreas de cualquier figura, colocadas proporcionalmente sobre la base y altura de un triangulo rectángulo, suman al final el área que tendria la misma figura proporcional en tamaño si se colocara sobre la hipotenusa. Podríamos poner un fractal si quisiéramos (No solo un simple cuadrado) e igualmente se cumpliría el teorema de pitagoras. Por ejemplo:

Les recomiendo usar la fórmula de Heron en el cálculo del área del triángulo así se olvidan de la base, la altura, el tipo del tríangulo, pitágoras, la hipotenusa, y todos esos traumas de la infancia que menciona juan 😄

🤓 Yo me recuerdo cuando me enseñaron a despejar formulas en el colegio, se me quedó tan bien que hasta me llevaron a las olimpiadas de matemáticas donde competí contra estudiantes de ingeniería y matemáticas puras. Obviamente perdí, pero quedé en 13er lugar, y aprendí un montón estudiando para ese test. Es muy bonito recuerdo de mi colegio.

🤓 Para calcular la altura sabiendo los tres lados me basé en esta web. Y mi resultado fue este:

function calCucularAlturaEscaleno(lado1, lado2, lado3) {
	let semiperimetro = (lado1 + lado2 + lado3) / 2;

	return (
		(2 / lado1) *
		Math.sqrt(
			semiperimetro *
				(semiperimetro - lado1) *
				(semiperimetro - lado2) *
				(semiperimetro - lado3)
		)
	);
}

// RETO#1 - Triángulo Escaleno (Todos sus lados son diferentes)
// Descripción: Sabiendo lo que miden los 3 lados, encuentra
// la altura.
const lado1Base = 6;
const lado2 = 8;
const lado3 = 10;

// Ecuaciones:
// h = ((2/lado1Base)*(Math.sqrt(s*(s-lado1Base)*(s-lado2)*(s-lado3)));
// s = ((lado1Base+lado2+lado3) / 2);

function calcAlturaEscaleno(lado1Base, lado2, lado3) {
    if (lado1Base != lado2 && lado2 != lado3 && lado1Base != lado3) {
        const s = ((lado1Base+lado2+lado3) / 2);
        return ((2/lado1Base)*(Math.sqrt(s*(s-lado1Base)*(s-lado2)*(s-lado3))));
    } else {
        console.log('Este no es un triángulo Escaleno');
    }
}

function semiperimetro(lado1Base, lado2, lado3) {
    return ((lado1Base+lado2+lado3) / 2);
}

console.log(calcAlturaEscaleno(lado1Base, lado2, lado3));

no fue facil pero lo logre, deje l as formulas y la logica comentada para quien pueda necesitarla

function triangle_height (side1, side2, base){
    // to find the height we can do it with 
    // area = (1/2)*(base)*(height); or better
    // say: height = area / ((1/2) * base);
    // now how we get the area, that's with  
    // area = square root of ( semi-perimeter * (semi-perimeter - side1) * (semi-perimeter - side2) * (semi-perimeter - side3))
    // and the semi-perimeter = (side1 + side2 + side3) / 2
    const s_perimeter = (side1 + side2 + base) / 2;
    const area = Math.sqrt( s_perimeter * (s_perimeter - side1) * (s_perimeter - side2) * (s_perimeter - base));
    const height = area / ((1/2) * base);
    return height
}

console.log(triangle_height(3,5,7));

Yo no soy muy bueno en matematicas, asi que decidi buscar la formula en internet y resolverlo yo mismo. En esta pagina van a encontrar la formula para sacar la altura de un triangulo escaleno (teniendo o no todos los lados) y tambien una seccion donde tienen ejercicios y sus respuestas, lo cual les puede servir para practicar. Yo realice el ejercicio numero 2 y este fue el resultado:

const ladoA = 6
const ladoB = 8
const ladoC = 10
const semiperimetro = (ladoA + ladoB + ladoC) / 2
const alturaTriangulo = 2 / ladoA * Math.sqrt(semiperimetro*(semiperimetro-ladoA)*(semiperimetro-ladoB)*(semiperimetro-ladoC))

Se que tambien es posible realizar una funcion donde inserte los parametros en lugar de una variable con todos esos datos, pero fue lo primero que se me vino a la mente para realizar el ejercicio. Ahora voy a realizar la funcion 😃

function calcTriEsc(lado1, lado2, base)
{
const semiperimetro = (base + lado1 + lado2)/2;
if(lado1 == lado2 || lado1 == base || lado2 == base) {
console.warn(“esto ni de pedo es un triangulo escaleno”)
} else {
return {
altura: (2 / base) * Math.sqrt(semiperimetro * (semiperimetro - lado1)* (semiperimetro * (semiperimetro - lado2)) * (semiperimetro *(semiperimetro - base))),
}
}
}

Mi solución al Reto:

<code> //Formula para Calcular la Altura de un Triangulo Escaleno

function alturaEscaleno(ladoA, ladoB, ladoC) {
    const semiperimetro = (ladoA+ladoB+ladoC)/2
    const altura =   2 / ladoA * Math.sqrt(semiperimetro*(semiperimetro-ladoA)*(semiperimetro-ladoB)*(semiperimetro-ladoC));

    return "La Altura del triangulo escaleno es " + altura
}
alturaEscaleno(6, 8, 10);

No entendí mucho de donde salieron exactamente los datos pero con las formulas puedo pasarlo a js

function calcularEscaleno(a, b, c){

    const s = (a+b+c)/2;
    const h = (2/a)*(Math.sqrt(s*( s - a )*( s - b )* ( s - c )));
    
    return `La altura es: ${h} m`;

}

CÓDIGO FINAL TRIÁNGULOS

.
Solo queria dejar mi código final que encapsula todo los visto con respecto a los triángulos. Utilice una clase, en donde para crear un nuevo triángulo, introduces el valor de sus 3 lados y halla:

.

• Cual de todos los lados es la hipotenusa.
• Su perímetro.
• Su área (Sin importar que tipo de triángulo sea).
• Sus 3 alturas (Sin importar que tipo de triángulo sea), tomando como bases el cateto a, cateto b y la hipotenusa.

.

class Triangle {
    constructor(side1, side2, side3) {
        this._allSides = [side1, side2, side3];

        this._cathetusA = null;
        this._cathetusB = null;
        this._hypotenuse = null;

        this._perimeter = null;
        this._area = null;

        this._heights = {};
    }

    get allSides() {
        // orders the array from largest to smallest
        return this._allSides.sort((a, b) => b - a);
    }

    get cathetusA() {
        return this.allSides[2]
    }

    get cathetusB() {
        return this.allSides[1]
    }

    get hypotenuse() {
        // Biggest side
        return this.allSides[0]
    }

    get perimeter() {
        return this.hypotenuse + this.cathetusA + this.cathetusB;
    }

    get area() {
        const s = this.perimeter / 2;
        const area = Math.sqrt(s * (s - this.hypotenuse) * (s - this.cathetusA) * (s - this.cathetusB));
        return area;
    }

    get heights() {
        return {
            heightBaseCathetusA: this.area / this.cathetusA * 2,
            heightBaseCathetusB: this.area / this.cathetusB * 2,
            heightBaseHypotenuse: this.area / this.hypotenuse * 2,
        }
    }

    get all() {
        return {
            cathetusA: this.cathetusA,
            cathetusB: this.cathetusB,
            hypotenuse: this.hypotenuse,
            perimeter: this.perimeter,
            area: this.area,
            heights: this.heights,
        }
    }
}

const triangle = new Triangle(3, 4, 5);
console.table(triangle.all);

Yo lo hice así:

Java Script

const a =document.getElementById("a");
const b =document.getElementById("b");
const c =document.getElementById("c");
const button = document.getElementById("operacion");
const result = document.getElementById("result");


button.addEventListener("click",calcheight);
function calcheight(){
    const x = Math.pow(Number(a.value),2);
    const z = Math.pow(Number(c.value),2);
    const y = Math.pow(Number(b.value),2);
    
    const distance = ( y - x + z ) / ( 2 * Number(b.value) );
    const height = (Math.sqrt( x - (Number(b.value)-distance)**2 )).toFixed(2);
    
    result.innerText = "" ;   
    result.append(String(height));
    console.log(height);
}

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Altura Triángulo escaleno</title>
    <link rel="stylesheet" href="./css/style.css">
</head>
<body>
    <main>
        <input type="text" id="a">
        <input type="text" id="c">
        <input type="text" id="b">
        <img src="https://s1.significados.com/foto/triangulo-1_bg.jpg" alt="escaleno">
        <button id="operacion">Calcular</button>
        <p id="result"></p>
    </main>
    <script src="./js/main.js"></script>
</body>
</html>

css

*{
    box-sizing: border-box;
    margin: 0;
    padding: 0;
}
html{
    font-size: 62.5%;
}
main{
    width: 100vw;
    font-size: 1.2rem;

}
main img {
    width: 500px;
    height: 319px;
    margin: 0 calc(50% - 250px);    
    
}
#a {
    width: 150px;
    height: 75px;
    background-color:lightgoldenrodyellow;
    position: absolute;
    left: calc(50% - 200px);
    top: 80px;
    text-align: center;
}
#c {
    width: 150px;
    height: 75px;
    background-color: lightgray;
    position: absolute;
    left: calc(50% + 150px);
    top: 80px;
    text-align: center;
}
#b {
    width: 150px;
    height: 75px;
    background-color: lightgreen;
    position: absolute;
    left: calc(50% - 30px);
    top: 320px;
    text-align: center;
}
#operacion{
    position: absolute;
    left: calc(50%);
    width: 100px;
    height: 30px;
    top: 410px;
    
}
#result{
    width: 100px;
    height: 30px;
    position: absolute;
    top: 450px;
    background-color: lightpink;
    left: calc(50% );
    font-size: 2rem;
    text-align: center;
}

Solución!

function scaleneTriangleHeight(base, side2, side3) {
    const semiPerimeter = ((base + side2 + side3) / 2);
    console.log(semiPerimeter);
    if(base == side2 || base == side3 || side2 == side3) {
        console.warn("this is not an scalene triangle")
    } else {
    return (2 / base) * (Math.sqrt(semiPerimeter * ((semiPerimeter-base)*(semiPerimeter-side2)*(semiPerimeter-side3))));
    }
}

Fue muy bacano acordarme de toda la matemática necesaria para cumplir el reto.

Código:

const pow = (pow: number) => Math.pow(pow, 2)
const heightOfScaleneTriangle = (hickA:number, hickC: number, hickBase: number) => 
  Math.sqrt( pow(hickC) - pow((pow(hickC) - pow(hickA) + pow(hickBase))/(2 * hickBase)));

const height = heightOfScaleneTriangle(10, 8, 6)
console.log(' ─> height: ', height)
// ─> height: 8

Done:
.
.

function calculateScaleneTriangle(side1, side2, base) {
    if (side1 != side2 && side1 != base && side2 != base){
        const numerator = (base**2 + side2**2) - side1**2;
        const denominator = 2 * base;
        const quotient = Math.pow((numerator / denominator), 2);
        const determinant = side2**2 + quotient;
        return {
            height: Math.sqrt((determinant)).toFixed(2),
        }
    }
    else {
        console.warn('This is not a scalene triangle')
    }
}

Lo hice de esta manera aplicando unas validaciones concatenadas.
sin embargo el triangulo escaleno, tiene más de una altura. dependiendo de como lo mires.
pero en este código encontré una de esas alturas.

function calcularAlturaTrianguloEscaleno(l1,l2,l3){
    if((l1 != l2) && (l2 != l3) && (l3 != l1)){
        return  ((2/l1) * ((Math.sqrt(((l1 + l2 + l3) / 2) * (((l1 + l2 + l3) / 2) - l1) * (((l1 + l2 + l3) / 2) - l2 ) * (((l1 + l2 + l3) / 2) - l3) ))))
        
    } else {
        console.warn("este no es un triangulo escaleno, alguno de los lados son iguales");
    }
}

<code> 
function alturaTrianguloEscaleno (ladoA,ladoB,ladoC){
 const s = (ladoA+ladoB+ladoC)/2
const altura= ladoA/2 * Math.sqrt(s*(s-ladoA)*(s-ladoB)*(s-ladoC))
   return "la altura del  triangulo escaleno es: " + altura;
}

alturaTrianguloEscaleno(3,4,5);

Usé la siguiente fórmula:

Donde S es el semiperímetro, o sea la suma de los 3 lados entre 2 (a + b + c) / 2. Traducido a código se ve así:

let altura_a = (2 / lado_a) * Math.sqrt(S * (S - lado_a) * (S - lado_b) * (S - lado_c));

Luego comencé a hacer una app para calcular más cosas funcional. Iré actualizándola conforme vaya aprendiendo más, pero puedes verla aquí: https://github.com/ssaldana-dev/figuras-geometricas-calc💚

¡Hazme un Pull request y colaboremos! 🚀 sería genial para practicar.

Mi funcion!

function calcularAlturaTrianguloEscaleno(lado1,lado2,lado3) {

  const semiperimetro = (lado1 + lado2 + lado3)/2;
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    console.warn("Este no es un triángulo escaleno");
  }
  else {
    return Math.sqrt(semiperimetro * (semiperimetro - lado1)*(semiperimetro - lado2)*(semiperimetro - lado3)) * (2/lado1);
  }
}

lo logre, de una manera sencilla y elegante jeje

function alturaEscaleno(a, b, c) {
    let perimetro = (a + b + c) / 2;
    if (a == b && b == c || a == b || b == c) {
        alert("no es un triangulo escaleno, escoge 3 valores diferentes");
    } 
     return{
        altura: (2 / a) * (Math.sqrt(perimetro*(perimetro - a)*(perimetro - b)*(perimetro - c))),
    } 
}

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 🐭

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

Les envio mi resolucion

function trianguloEscaleno (ladoIz, ladoDer, baseEscal) {
const s = (ladoIz + ladoDer + baseEscal)/2
const raiz = Math.sqrt(s*(s- ladoIz)(s - ladoDer)(s - baseEscal))

if (ladoIz == baseEscal || ladoDer == baseEscal || ladoDer == ladoIz) { 
    console.warn("no es un triangulo Escaleno")
} else {
    return (2/baseEscal)*raiz
}

}

Yo lo hice de la siguiente forma.

function calcularTrianguloEscaleno(lado1, lado2, base) {

/* Para calcular la altura de un triangulo del cual conocemos sus lados y base, usamos la formula de Heron y luego despejamos, pero antes... Tenemos que calcular el semiperimetro del triangulo, luego, usar dicha informacion para obtener el area y por ultimo, la altura del triangulo 
*/

    const semiPerimetro = (lado1 + lado2 + base)

    const area = Math.sqrt (semiPerimetro * (semiPerimetro - lado1)) * (semiPerimetro - lado2) * (semiPerimetro - base)


    if (lado1 === lado2 || lado1 == base || lado2 == base){
        console.warn("No se puede formar un triángulo escaleno con estos valores")} else {
            console.log({
                semiPerimetro,
                area,
        
            })
            return console.log("la altura del triangulo escaleno es " + (2 * area)/ base )
        }

    }

Función para calcular la altura del triángulo escaleno.

function AlturaTrianguloEscaleno(){
    let l1 = prompt(`Ingrese el valor del lado 1 en cm.`);
    l1 = parseInt(l1);
    let l2 = prompt(`Ingrese el valor del lado 2 en cm.`);
    l2 = parseInt(l2);
    let l3 = prompt(`Ingrese el valor del lado 3 en cm.`);
    l3 = parseInt(l3);

    if(l1 == l2 || l1 == l3 || l2 == l3){
        alert('los valores digitados no pueden ser iguales ya que es un triángulo escaleno y todos sus lados son diferentes.');
        return;
    }

    let semiperimetro = (l1 + l2 + l3) / 2;

    let baseTriangulo = (2 / l1) * Math.sqrt(semiperimetro * (semiperimetro - l2) * (semiperimetro - l3));

    let areaTriangulo = Math.sqrt(semiperimetro * (semiperimetro - l1) * (semiperimetro - l2) * (semiperimetro - l3));

    let altura = (2 * areaTriangulo) / baseTriangulo;

    alert('La altura del triángulo escaleno es: ' + altura);
}