Playground: Calcula la Altura de un Triángulo Escaleno

Hola

Creo que la altura que piden calcular es respecto al lado1 que seria el primer argumento de la función.

Es importante tener esto en cuenta ya que un triangulo tiene 3 alturas, una respeto a cada lado (Se puede pensar como que rotas el triangulo y ahora tienes otra base)

Aquí esta mi solución:

export function solution(lado1, lado2, lado3) {

  let a = lado1;
  let b = lado2;
  let c = lado3;

  // Si no es escaleno, no continuamos
  if (a == b || b == c || c == a) {
    return false;
  }

  // Si es escaleno, calculamos primero su area
  let s = (a + b + c) / 2;
  let area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

  // Ahora usamos que A = bh/2, por lo que h = 2A/b
  let altura_a = Math.floor(2 * area / a);
  let altura_b = Math.floor(2 * area / b);
  let altura_c = Math.floor(2 * area / c);

  // IMPTE: No se especifica cual de las alturas se quiere, tras probar el codigo conclui que se busca la altura respecto a 'a' como base
  return altura_a;

}

Para calcular las otras alturas, solo se debe cambiar el orden de los datos de entrada a la función:

export function solution(c, a, b) {
  if (a == b || a == c || b == c) { 
    return false;
  }
  const tita = Math.acos(((a * a + c * c - b * b) / (2 * a * c)));
  const altura = Math.round(a * Math.sin(tita))
  return altura
}

Si no les funciona con sacarle los decimales con un toFixed recomiendo usar un Math.floor().

Por que cuando lo hice con toFixed me transformo los numeros en strings entonces no me los daba como correctos.
En cambio con el Math.floor() al resultado tambien le quitaba los decimales pero esta vez los mantenia como integer (numero entero no string)
[Aclaro por que estuve bastante tiempo sin entender por que me daba el resultado como erroneo si en teoria era el mismo numero de resultado]

Aquí mi solución:

export function solution(lado1, lado2, lado3) {
  // Tu código aquí 👈
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    return false;
  } else {
    const sp = (lado1 + lado2 + lado3) / 2;
    return Math.round((2 / lado1) * Math.sqrt(sp * (sp - lado1) * (sp - lado2) * (sp - lado3)));
  }
}

Comparto mi solución, la altura fue calculada mediante el teorema de Pitágoras. Despejando variables.

export function solution(lado1, lado2, lado3) {
  const x = (((lado1 ** 2) + (lado2 ** 2) - (lado3 ** 2)) / (2 * lado1))

  if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
    return false;
  } else {
    const resultado = Math.sqrt((lado2 ** 2) - (x ** 2));

    return Math.trunc(resultado);
  } 
}

Yo un lado lo describiria como base pero creo que cumpli.

export function solution(lado1, lado2, lado3) {
  // Tu código aquí 
  if (lado1 != lado3 && lado2 != lado3 && lado1 != lado2) {
    const S = ((lado1 + lado2 + lado3) / 2);
    const areaTrianguloEscaleno = Math.sqrt((S * (S - lado1) * (S - lado2) * (S - lado3)));
    const alturaTrianguloEscaleno = (2 * areaTrianguloEscaleno) / lado1;
    const alturaSinDecimales = Math.floor(alturaTrianguloEscaleno);
    return alturaSinDecimales;

  } else {
    return false;
  } 
}

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado2 != lado3) {
    let s
    s = (lado1 + lado2 + lado3) / 2
    let altura = (2 / lado1) * Math.sqrt( s*(s-lado1)*(s-lado2)*(s-lado3))
    altura = Math.trunc(altura)
    return altura;

  }
  return false
}

Creo que deberia haber sido mas especifica la Pregunta, sobre que altura querian que se calcule, mi solucion para la consola fue esta, asumiendo un triangulo de lados a, b y c, para cualquier altura,

function solution(a, b, c) {
  // Tu código aquí 👈
  if (a != b && b != c && c != a) {
    return Math.trunc((Math.sin(Math.acos(((a ** 2) + (c ** 2) - (b ** 2)) / (2 * a * c)))) * a);
  } else {
    return false;
} }

y para conformidad de la consola solo cambie de posicion las variables de esta forma:

export function solution(c, a, b) {
  // Tu código aquí 👈
  if (a != b && b != c && c != a) {
    return Math.trunc((Math.sin(Math.acos(((a ** 2) + (c ** 2) - (b ** 2)) / (2 * a * c)))) * a);
  } else {
    return false;
  }
}

Asi codifiqué mi solución :

function alturaEscaleno(lado1, lado2, lado3) {
  let a = lado1;
  let b = lado2;
  let c = lado3;
  let sp = (a + b + c) / 2;

  if (a === b || b === c || c === a) {
    return false;
  } else {
    let area = Math.sqrt(sp * (sp - a) * (sp - b) * (sp - c));
    let altura = (2 * area) / a;

    return Math.floor(altura);
  }
}

Así me salió bien

function calcularAlturaEscaleno (ladoA, ladoB, ladoC) {
    if(ladoA == ladoB || ladoB == ladoC || ladoA == ladoC) {
        return false;
    } else {
    const S = (ladoA + ladoB + ladoC) / 2;
    return Math.trunc( (2 / ladoA) * Math.sqrt(S * (S - ladoA)*(S - ladoB)*(S - ladoC)) );
    }
}

MI SOLUCIÓN

LÓGICA

¡Hola! ¿Qué tal todo?
Les muestro mi pequeña solución

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado1 != lado3 && lado2 != lado3) {
    return Math.floor(Math.sqrt(lado2 ** 2 - ((((lado2 ** 2) + (lado1 ** 2) - (lado3 ** 2)) / (2 * lado1)) ** 2)));
  }
    return false;
}

MI solución !

Tuve un problema al inicio ya que estaba aplicando el Math.floor directamente en el return a altura, lo cual en la consola normal no genera inconveniente, sin embargo, aquí si es necesario aplicarlo especificamente a la formula de la constante altura.

Y que les puedo decir, si se ve mejor 😃 jajaja.

function  solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado1 == lado3 || lado3 == lado2) {

    return false;

  } else {

    let semiPerimetro = (lado1 + lado2 + lado3) / 2;
    const formula = ((semiPerimetro - lado1) *          (semiPerimetro - lado2) * (semiPerimetro - lado3) * semiPerimetro);
    const raizCuadrada = Math.sqrt(formula);
    const altura = Math.floor(2 / lado1 * raizCuadrada);

    return altura;
  }

}

export function solution(lado1, lado2, lado3) {
  const s = (lado1 + lado2 + lado3) / 2;
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    return false;
  } else {
    return Math.trunc(2 / lado1 * (Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3))))
  }
}

Aquí no funciona, no se porque. Pero está probado en la consola y funciona perfectamente!! 😉

Aquí dejo mi aporte 😃

function alturaEscaleno(base, b, c) {
    const semiPerimetro = (base + b + c) / 2;
    const area = Math.sqrt(semiPerimetro * (semiPerimetro - base) * (semiPerimetro - b) * (semiPerimetro - c));

    if (base != b && base != c && b != c) {
        return Math.round((2 * area) / base);

    } else {
        return false;
    }
}

ez

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado2 != lado3 && lado3 != lado1) {
    const S = (lado1 + lado2 + lado3) / 2;

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

  return false;
}

Tras muchas vueltas, me gusto como quedó este código

function solution(lado1, lado2, lado3) {
  return lado1 == lado2 || lado2 == lado3 || lado3 == lado1
    ? false
    : Math.floor(
        (2 *
          Math.sqrt(
            ((lado1 + lado2 + lado3) / 2) *
              ((lado1 + lado2 + lado3) / 2 - lado1) *
              ((lado1 + lado2 + lado3) / 2 - lado2) *
              ((lado1 + lado2 + lado3) / 2 - lado3)
          )) /
          lado1
      );
}

Mi solución

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado2 != lado3 && lado1 != lado3) {
    const semiperimetro = (lado1 + lado2 + lado3) / 2;
    const aEscaleno = (2 / lado1) * Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))
    return parseInt(aEscaleno)
  }
  else {
     return false
   }
}

Mi Solucion despues de varios intentos y muchos errores, la matematica no es mi fuerte, pero miedo no le tengo xD, lo peor que puede pasar es que me equivoque y solo con los errores es que aprendemos. Despues de mucho googlear, di con la formula de Eron que es mucho mas facil que con el teorema de pitagoras

function calcularAlturaEscaleno(lado1,lado2,lado3){
    
    if(lado1 === lado2 || lado2 === lado3 || lado3 === lado1){
        return false
    }else{
        let semiPerimetro = (lado1 + lado2 + lado3) / 2
        let area = Math.sqrt(semiPerimetro * (semiPerimetro - lado1) * (semiPerimetro - lado2) * (semiPerimetro - lado3))
        let altura = ((area * 2) / lado1)
        return Math.floor(altura)
    }
}

export function solution(a, b, c) {

  if (a == b || b == c || c == a) {
    return false
  } else {
    let s = (a + b + c) / 2;
    let area = Math.sqrt(s * ((s - a) * (s - b) * (s - c)));
    let altura = (2 * area) / a;
    return Math.trunc(altura);
  }
}

Mi respuesta. aunque no se por que con tofixed me devolvía como un string el numero de la respuesta. “4” en vez de 4

function calcularEscaleno (lado1,lado2,lado3){
    const semiperimetro = (lado1+lado2+lado3)/2;
    const resultado = (2/lado1)*(Math.sqrt(semiperimetro*(semiperimetro-lado1)*(semiperimetro-lado2)*(semiperimetro-lado3)));
    if (lado1==lado2 || lado1==lado3||lado2==lado3){
        return false
    } else {
        return Math.trunc(resultado)
    }
};

Mi solución (teniendo como base el lado1)

JS

export function solution(lado1, lado2, lado3) {
  const semiperimetro = (lado1 + lado2 + lado3) / 2;
  if (lado2 == lado1 && lado2 == lado3 && lado1 == lado3 || lado2 == lado1 && lado2 != lado3 && lado1 != lado3 || lado2 == lado3 && lado2 != lado1 && lado1 != lado3 || lado2 != lado1 && lado2 != lado3 && lado1 == lado3) {
    return false;
  } else {
    return Math.floor((2 / lado1) * (Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))));
  }
}

Aunque un poco diferente la lógica pero salió…😃
en el else le coloque un “console.warn” en vez de retornar un “false”…

Mi sandbox fue mi editor de codigo por comodidad, pero aqui mi solucion:

function trianguloEscaleno(lado1, lado2, lado3){
    if (lado3 == lado1 || lado3 == lado2 || lado1 == lado2){
        return false;
    }else{
        // altura = (2 / lado1) raizcuadrada(Semiperimetro(Semiperimetro - lado1) *(Semiperimetro - lado2) * (Semiperimetro - lado3))
        // Semiperimetro = (lado1 + lado2 + lado3)/2
        const Semiperimetro = (lado1 + lado2 + lado3)/2
        return altura = (2 / lado1) * (Math.sqrt(Semiperimetro * (Semiperimetro - lado1) *(Semiperimetro - lado2) * (Semiperimetro - lado3)))
    }
}

console.log(trianguloEscaleno(16, 8, 10))
console.log(trianguloEscaleno(6, 6, 6))

Hacia mucha falta estos retos, que bueno que ahora existan dentro de los cursos de la plataforma

dasajdkahskjdas te amo formula de herón ❤️

Lo hice de esta forma =)

function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado2 == lado3 || lado3 == lado1) {
    return false;
  } else {
    const semiperimetro = ((lado1 + lado2 + lado3) / 2);
    const altura = (
      (2 / lado1)
      *
      Math.sqrt(
        semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3)
      )
    )
    return Math.round(altura);
  }
}

La solución que yo encontré es la siguiente:

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado2 != lado3 && lado1 != lado3) {
    var s = (lado1 + lado2 + lado3) / 2;
    var area = Math.sqrt(s * (s-lado1) * (s-lado2) * (s-lado3))
    var h = (2 * area) / lado1;
    return Math.floor(h);
  } else {
    return false;
  }
}

Mi solucion:
Para calcular la altura necesitamos el area, pero para calcular el area necesitamos el semiperímetro.
entonces la formula termina siendo algo asi:
// s(semi_perimeter) = (a + b + c) / 2
// Area = sqrt(s * (s - a) * (s - b) * (s - c))
y finalmente la altura es asi: // h = 2 * (triangle area) / (base length)

La prueba requiere que devuelvas el numero sin decimales. es por eso que utilice la funcion Math.Floor, la cual reduce o agranda el numero a el valor mas cercano.

function calculateHeightScaleneTriangle(sideA, sideB, sideC){
    if (sideA !== sideB && sideA !== sideC && sideB !== sideC) {
        // s(semi_perimeter) = (a + b + c) / 2
        const s = (sideA + sideB + sideC) / 2; // semi_perimeter
        
        // Area = sqrt(s * (s - a) * (s - b) * (s - c))
        const area = Math.sqrt(s * (s - sideA) * (s - sideB) * (s - sideC));
        
        // h = 2 * (triangle area) / (base length)
        const height = 2 * (area) / sideA;
        return Math.floor(height);
    } else{
        return false
    };
};

Bueno después de un tiempo salió!!
podía ahorrarme las const a, b, c pero siento que quedo mas legible asi (?
Fórmula que es derivada de la formula de Herón

<
function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    return false;
  } else {
    const s = (lado1 + lado2 + lado3) / 2;
    const p = 2 / lado1;
    const a = s - lado1;
    const b = s - lado2;
    const c = s - lado3;

    const altura = Math.floor((p) * (Math.sqrt(s * (a) * (b) * (c))));
    return altura;
  }
}
> 

Aqui mi solucion:

function calcularAlturaTrianguloescaleno(lado1,lado2,lado3){

 if(lado1 != lado2 && lado2 != lado3){

 const semiP= (lado1 + lado2 + lado3)/2
 const area= Math.sqrt(semiP*(semiP-lado1)*(semiP-lado2)*(semiP-lado3))  

let alturaL1= Math.floor((area * 2)/lado1);
let alturaL2= Math.floor((area * 2)/lado2);
let alturaL3= Math.floor((area * 2)/lado3);
return console.log({
    alturaL1,
    alturaL2,
    alturaL3
    })
  }else{
  return false
  }
}

me gusto, hace rato no me entretenia haciendo fórmulas matemáticas en el pc, me recuerda tiempos aquellos…

export function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
    return false;
  } else {
    const semiP = ((lado1 + lado2 + lado3) / 2);//semiperimetro
    return Math.trunc((2 / lado1) * (Math.sqrt((semiP) * ((semiP - lado1) * (semiP - lado2) * (semiP - lado3)))));
  }
}

function solution(lado 1, lado2, lado3){
  if (lado1 == lado2 || lado2 == lado1 || lado2 == lado3) {
    return false
  }
  else {
    return Math.round(Math.sqrt(Math.pow(lado2, 2) * (1 - Math.pow(lado1 / (lado2 + lado3), 2))));
  }
}

Para utilizar el aporte, Lado2 debe ser el menor, Lado3 debe ser el intermedio y Lado1 el mayor.

Solo cambie las variables de lugar

Mi solucion es parecida a la de los demás

<code> export function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    return false;
  } else {
    /*semiperimetro S = (lado1 + lado2 + lado3) / 2 */
    const semiperimetro = (lado1 + lado2 + lado3) / 2;

    /*altura h= (2/lado1) *raiz cuadrada (S(S-lado1) (S-b)(S-c)*/
    return Math.trunc((2 / lado1) * Math.sqrt(semiperimetro * ((semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))));
  }
}

![](

• El ejercicio está considerando como la base al lado
  
  

_

• Es importante distinguir la base porque en la fórmula de la altura de un triángulo escaleno, esta base realiza un paso importante y único en comparación a los demás lados.
  
  

para redondear y evitar los decimales yo use Math.round(x), la cual acerca al numero entero mas cercano :

export function solution(lado1, lado2, lado3) {
  let altura = 0;
  let perimetro = (lado1 + lado2 + lado3) / 2;
  if (lado1 == lado2 && lado1 == lado2) {
    return false;
  } else {
    altura =
      (2 / lado1) *
      Math.sqrt(
        perimetro *
        (perimetro - lado1) *
        (perimetro - lado2) *
        (perimetro - lado3)
      );
    return parseInt(altura.toFixed(0));
  }
}

export function solution(lado1, lado2, lado3) {
  if (lado1 === lado2 || lado2 === lado3 || lado1 === lado3) {
    return false;
  }
  let s = (lado1 + lado2 + lado3) / 2;
  let area = Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3));
  return Math.round(area / (1 / 2 * lado1));
}

here is my code, it’s not very clean but I hope it will be useful.

export function solution(lado1, lado2, lado3) {
  if (lado1 !== lado2 && lado1 !== lado3 && lado2 !== lado3) {
    const s = (lado1 + lado2 + lado3) / 2;
    let altura = (2 / lado1) * Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3))
    return Math.round(altura)
  }
  else return false // T  u código aquí 👈
}

se considera como base al lado 1:

export function solution(lado1, lado2, lado3) {
if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
return false;
} else {
const se = (lado1 + lado2 + lado3) / 2;
let altura = ((2 / lado1) * Math.sqrt(se * (se - lado1) * (se - lado2) * (se - lado3)));
let re = Math.floor(altura);
return re
}
}

Si te sirve y te ayuda a entender por favor usa este codigo, libremente!

export function solution(lado1, lado2, lado3) {
  let a = lado1;
  let b = lado2;
  let c = lado3;

  // validamos los lados 👈
  if (a === b | b === c | c === a) {
    return false
  }

  // calculamos su area
  let semiPer = (a + b + c) / 2;
  let area = Math.sqrt(semiPer * (semiPer - a) * (semiPer - b) * (semiPer - c));

  // obtenemos la altura
  let altA = Math.floor(2 * area / a);
  let altB = Math.floor(2 * area / b);
  let altC = Math.floor(2 * area / c);

  return altA;
}

export function solution(lado1, lado2, lado3) {
  let Sp = (lado1 + lado2 + lado3) / 2;

  if (lado1 != lado2
    && lado2 != lado3
    && lado3 != lado1) {
    return Math.floor(
      (2 / lado1) * Math.sqrt(
        Sp * (Sp - lado1) * (Sp - lado2) * (Sp - lado3)
      ) // Math sqrt
    ) // Math floor;
  } else {
    return false
  } // Conditionals
}

solution(16, 8, 10); // return 4
solution(6, 6, 6); // false

Mi aporte

export function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado2 == lado3 || lado1==lado3) {
    return false;
  } else {
    const a = lado3;
    const b = lado1;
    const c = lado2;
    const x = (c ** 2 - a ** 2 + b ** 2) / (2 * b);
    const h = Math.floor(Math.sqrt(c ** 2 - x ** 2));
    return h;
  }
}

Mi humilde aporte:

export function solution(a, b, c) {
  // Array de valores únicos
  const uniqueSides = Array.from(new Set([...arguments]));

  // Comparamos el length de los argumentos orignales
  //  vs el de valores únicos. Deben ser iguales.
  if ([...arguments].length !== uniqueSides.length) {
    return false;
  }

  // Calc semeiperímetro
  const S = (a + b + c) / 2;

  // Fórmula de Herón
  const h = (2 / a) * Math.sqrt(S * ((S - a) * (S - b) * (S - c)));

  return Math.floor(h);
}

La prueba tiene un error

Hola, no entiendo porque en el Playground no sale el resultado correcto; en la consola corre bien.

Esto me sale en el Playground:

Me frustra mucho cuando mi codigo lo corro en la consola y da bien pero en el playground no, quedo 💔

El test que no me pasaba es el de los numero enteros, para eso utilicé Math.trunc, que le quita los decimales a el resultado.

export function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
    return false;
  } else {
    const semiPermimetro = (lado1 + lado2 + lado3) / 2;
    return Math.trunc((2 / lado1) * Math.sqrt(semiPermimetro * (semiPermimetro - lado1) * (semiPermimetro - lado2) * (semiPermimetro - lado3)))
  }
}

Mi respuesta

export function solution(a, b, c) {
  if (a === b || a === c || b === c) {
    return false;
  }
  const sp = (a + b + c) / 2;
  const area = Math.sqrt(sp * (sp - a) * (sp - b) * (sp - c));
  return Math.floor(2 * area / a);
}

export function solution(lado1, lado2, lado3) {
if (lado1 != lado2 && lado1 != lado3 && lado2 != lado3) {
let s = (lado1 + lado2 + lado3) / 2;
let h = 2/lado1*(Math.sqrt(s*(s - lado1)(s - lado2)(s - lado3)
))
let altura = Math.round(h);
return altura
} else {
return false
}
}

Excelente quiz, muy bueno el ejercicio. así lo hice yo.

Aca mi Solucion

export function solution(lado1, lado2, lado3) {
  const semiPerimetro = (lado1 + lado2 + lado3) / 2
  if (lado1 === lado2 || lado1 === lado3)return false
  {
    return Math.floor((2 / lado1) * (Math.sqrt(semiPerimetro * (semiPerimetro - lado1) * (semiPerimetro - lado2) * (semiPerimetro - lado3))));
  }
}

aqui esta mi aporte no sabia del Math.floor pero lo hice con .toFixed(0) tambien funciona.

function solution(lado1, lado2, lado3) {
    if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
        return false;
    } else {
        const s = (lado1 + lado2 + lado3) / 2;
        return H = ((2 / lado1)*Math.sqrt(s*(s - lado1)*(s - lado2)*(s - lado3))).toFixed(0);
    };
}
calcularTrianguloAlturaEscaleno(16,8,10)

Mi solucion 😀

export function solution(lado1, lado2, lado3) {
  if (lado1 != lado2 && lado1 != lado3 && lado2 != lado3) {
    let semiperimetro = (lado1 + lado2 + lado3) / 2;
    let altura = (2 / lado1) * (Math.sqrt((semiperimetro) * ((semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))))

    return Number(altura.toFixed(0));
  } else {
    return false
  }
}

Ha mi código hacia lo mismo.
Solo que el nombre de las variables eran palabras…
Chale…

No supe bien como hacer y pase por varios procesos para hallar la fórmula, luego yo retorne un console.warn indicando que si eran iguales no era un escaleno, cuando debía devolver un false 😅 Después en la validación lo hice bien, pero me faltaba validar que lado2 === lado3 jeje

ya corregido con eso, pues creo que sí sale:

console.group("Calcular la altura de un triángulo escaleno (Todos los lados son diferentes)");

function alturaTrianguloEscaleno(lado1, lado2, lado3) {
    const semiperimetro = (lado1 + lado2 + lado3) / 2;

    //Fórmula: h = 2/a | S(S-a)(S-b)(S-c)|
    if (lado1 === lado2 || lado1 === lado3 || lado2 === lado3) {
        //console.warn("Este no es un triángulo escaleno.");
        return false;
    } else {
        return {
            altura: Math.floor((2 / lado1) * (Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))))
        }
    }
}

console.log(alturaTrianguloEscaleno(16, 8, 10));
console.log(alturaTrianguloEscaleno(6, 6, 6));


console.groupEnd("Calcular la altura de un triángulo escaleno (Todos los lados son diferentes)");