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;

}

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]

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
}

REVISANDO UNA HORA PORQUE NO CORRE MI CÓDIGO Y VEO QUE EL PLAYGROUND NO ACEPTA OTRO NOMBRE DE FUNCIÓN QUE NO SEA SOLUTION😫😜…es todo por hoy creo 🤯🥴

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

Valió la pena el reto anterior 😅

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

Que gran ejercicio, me hizo ver algunas cosas que me faltaban en mi codigo, con la ayuda de los aportes de los demas pude ver que se debia usar Math.floor para llegar a un numero entero, y ademas usar el (return false;).

Asi me quedo:

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

}

Esta fue mi solucion pero no entiendo por que aqui en el playGround me retorna un error, en vs code y en la consola me da el resultado esperado. !!AYUDA¡¡

<export function solution(lado1, lado2, lado3) {
  // Tu código aquí 👈
  const semiperimetro = (lado1 + lado2 + lado3) / 2

  if (lado2 == lado3) {
    return false
  } else {
    return Math.round((2 / lado1) * (Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3))))
  }
}
> 

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

}

<code> 

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

export function solution(lado1, lado2, lado3) {
// Tu código aquí 👈
let semiperimetro = ((lado1 + lado2 + lado3) / 2)
if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
return false
} else {
//h=2/a raizCuadrada((s)(s-a)(s-b)(s-c))
return Math.floor(((2 / lado1) * (Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3)))))
}
}

export function solution(lado1, lado2, lado3) {
// Tu código aquí 👈

if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
  return false;
} else {
  let s = (lado1 + lado2 + lado3) / 2;
  let area = Math.sqrt(s * (s - lado1) * (s - lado2) * (s -   lado3))
  let h = Math.floor((2 * area) / lado1);

  return h;
}

}

solution(16, 8, 10);
solution(6, 8, 8);

sabiendo que la altura se calcula desde el lado 1 esta fue mi respuesta

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

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

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

export function solution(lado1, lado2, lado3) {


  let s = (lado1 + lado2 + lado3) / 2;
  let h = Math.floor((2 / lado1) * Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3)));

  if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
    return false;
  } else {
    return h;
  }
}

export function solution(lado1, lado2, lado3) {


  if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
    return false;

  } else {



    const Sp = ((lado1 + lado2 + lado3) / 2);
    const area = Math.sqrt(Sp * (Sp - lado1) * (Sp - lado2) * (Sp - lado3))
    const height = Math.floor((area * 2) / lado1);

    return height
    console.log(height)

  }

Me funcionó este código:

function calcularAlturaTrianguloEscaleno(a, b, c) {
  if (a == b || b == c || c == a) {
    return false;
  } else {
    // Calcular el semiperímetro
    var s = (a + b + c) / 2;

    // Calcular el área con la fórmula de Herón
    var area = Math.sqrt(s * (s - a) * (s - b) * (s - c));

    // Calcular la altura con la fórmula general
    var altura = (2 * area) / a;

    return parseInt(altura.toFixed(0));
  }
}

A dia de hoy (06 de octubre del 2023)
le playground o el archivo en el que se aloja se daño!

reto solucionado

Solución 😄…

Esta es la forma en que lo hice:

• Primero, dividir en 2 triángulos rectángulos Tr1 y Tr2.
• Luego los lados B y C son las hipotenusas de sus correspondientes triángulos.
• Armamos un sistema de ecuaciones, donde vemos que podemos igualar las alturas H.
• Resolviendo el sistema obtenemos el valor de X, que es la base del triángulo Tr1.
• Teniendo X podemos encontrar la altura H en cualquiera de las primeras 2 ecuaciones.

export function solution(lado1, lado2, lado3) {
  if (lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
    return false;
  }

  const x = (lado2 ** 2 + lado1 ** 2 - lado3 ** 2) / (2 * lado1);

  return Math.round(Math.sqrt(lado2 ** 2 - x ** 2), 2);
}

Mi aporte del reto anterior que tambien sirvió para este, me base en la formula de Heron y la formula común para hallar el área del triangulo
La explicacion

El codigo

//!Reto -> Tarea
function calcularAlturaTrianguloEscaleno(lado1, lado2, lado3) {
  const S = (lado1 + lado2 + lado3) / 2;
  if (lado1 != lado2 && lado1 != lado3 && lado2 != lado3) {
    const areaTriangulo = Math.sqrt(
      S * (S - lado1) * (S - lado2) * (S - lado3)
    );
    const alturalado3 = (2 / lado3) * areaTriangulo;
    const alturalado1 = (2 / lado1) * areaTriangulo;
    const alturalado2 = (2 / lado2) * areaTriangulo;
    return {
      alturalado1,
      alturalado2,
      alturalado3,
    };
  } else {
    console.warn("No se puede construir un triangulo escaleno");
  }
}

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

💚💚💚

Hello, calculo la altura de todos los lados, si les interesa, aqui el code

function calcTriangEscaleno(lado1, lado2, base) {
  if(lado1 == lado2 || lado1 == base || lado2 == base) {
    console.warn("Los lados del triangulo escaleno deben ser diferentes");
  } else {
    const s = (lado1 + lado2 + base) / 2;
    const area = Math.sqrt(s *
      (s - lado1) *
      (s - lado2) *
      (s - base)
      );
      console.log(area);
    const alturaLado1 = 2/lado1 * area;
    const alturaLado2 = 2/lado2 * area;
    const alturaLadoBase = 2/base * area;
    return console.log(
      `
      Altura lado 1 = ${alturaLado1}
      Altura lado 2 = ${alturaLado2}
      Altura base = ${alturaLadoBase}
      `
    );
  }
}

function calcularAlturaTrianguloEscaleno(lado1, lado2, lado3){
    if (lado1 == lado2 || lado1 == lado3 || lado3 == lado2 || lado2 == lado3) {
        return false;
    } else {
        let semiperimetro = (lado1 + lado2 + lado3) / 2;
        let resultadosinTratar = (2/lado1) * Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * ( semiperimetro - lado3))
        return Math.floor(resultadosinTratar)
    }
}

Esta es mi solución al reto.
*
*
*
*
*
*
*
*

export function solution(lado1, lado2, lado3) {
  // Base es el lado de mayor medida
  if ((lado1 === lado2) || (lado1 === lado3) || (lado2 === lado3)) {
    return false;
  } else {
    // S = Semiperimetro
    // ha = altura respecto al lado1
    const S = (lado1 + lado2 + lado3) / 2;
    const ha = (2 / lado1) * Math.sqrt(S * (S - lado1) * (S - lado2) * (S - lado3));
    return Number(ha.toFixed(0));
  }
}

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

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

  let h = Math.floor(2 * area / a);

  return h;
}

function solution(lado1, lado2, lado3) {
  if (lado1 !== lado2 && lado2 !== lado3 && lado3 !== lado2) {
    // calculating the semiperimeter
    const semiperimeter = ((lado1 + lado2 + lado3) / 2)

    // calculating the area using the Heron's formula
    const area = Math.sqrt(semiperimeter * (semiperimeter - lado1) * (semiperimeter - lado2) * (semiperimeter - lado3))

    // calculating the height
    const height = ((2 * area) / lado1)
    const int = parseInt(height)

    return int
  }
  else {
    return false
  }
   

GG
Spoilers…
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function solution(lado1, lado2, lado3) {
  // Verificación de que los valores pueden formar un triángulo
  if (lado1 >= (lado2 + lado3) || lado2 >= (lado1 + lado3) || lado3 >= (lado1 + lado2)) {
    console.log("Los valores proporcionados no pueden formar un triángulo.");
    return;
  }

  const semiperimetro = (lado1 + lado2 + lado3) / 2;
  const S = semiperimetro;
  if (lado1 != lado2 && lado1 != lado3 && lado2 != lado3)  // Validación de triángulo escaleno
  {
    const perimetroEscaleno = lado1 + lado2 + lado3;
    const area = parseInt(Math.sqrt(S * (S - lado1) * (S - lado2) * (S - lado3)));
    const altura = parseInt((2 * area) / lado1);

    console.log({
      perimetroEscaleno,
      area,
      altura,
    })

    return altura
  } else {
    return false
  }

}```

Me da error en la prueba pero el código funciona correctamente, creo que es por que prioriza el lado1. no lo se.

export function solution(a, b, c) {
  const contorno = a + b + c;
  const Base = Math.max(a, b, c);
  const Lado2 = Math.min(a, b, c);
  const Lado1 = contorno - (Base + Lado2);
  const Base2 = (((Lado1 ** 2) + (Base ** 2)) - (Lado2 ** 2)) / (Base * 2);
  console.log({
    contorno,
    Base,
    Base2,
    Lado1,
    Lado2,
  })
  if (a == b || b == c || c == a) {
    return false
  } else {
    const altura = Math.sqrt((Lado1 ** 2) - (Base2 ** 2))
    return Math.trunc(altura)
  }
}

Si!!! 😄

export function solution(lado1, lado2, lado3) {
  // Tu código//s = semiperimetro
  const s = (lado1 + lado2 + lado3) / 2;
  //Área = √(s * (s - a) * (s - b) * (s - c))
  const area = Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3))
  const altura = (2 * area) / lado1;


  if (lado1 == lado3 || lado1 == lado2 || lado2 == lado3) {
    return false;
  } else {
    //Altura = (2 * Área) / Base
    return Math.floor(altura);
  }
}

export function solution(baseA, ladoB, ladoC) {
if (baseA != ladoB && ladoB != ladoC) {
const S = (baseA + ladoB + ladoC) / 2;
const L = baseA / 2;
const h = Math.sqrt((S) * ((S - baseA) * (S - ladoB) * (S - ladoC)));
const altura = Math.floor(h / L);
return altura;
} else {
return false;
}

}

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

let altura = Math.floor(((2 * area) / base))
return altura;
}

Por favor no coloque la respuesta aqui dejen que la peña lo haga sin ayuda
GRACIAS

Para realizaer el ejercicio podemos usar la formula de Heron para calcular el area
h= (2/a)* raiz(s(s-a)(s-b)(s-c)
para esa formula necesitamos calcular el semiperimetro s
s = (a+b+c)/2

export function solution(lado1, lado2, lado3) {
// creamos constantes para nombrar a,b,c los lados del triangulo
  let a = lado1;
  let b = lado2;
  let c = lado3;

  if (a == b || b == c || c == a) {//verificamos que los lados no sean iguales 
    return false;// si son iguales que retorne falso
  } else { 
    let s = (a + b + c) / 2;//formula semiperimetro
    let raiz = Math.sqrt(s * (s - a) * (s - b) * (s - c));//hacemos la parte de la raiz
    let fraccion = 2 / a;
    let h = Math.floor(fraccion * raiz);//con math.floor redondeamos

    return h;
  }
}

Se me hizo muy dificil este ejercicio, tuve que investigar bastante😂.

// Paso 1: Calcular semipermetro: s = (a + b + c) / 2;
// Paso 2: Formula de heron: Área (A) = √(s(s - a)(s - b)(s - c));
// Paso 3: Escoger la base (Yo escogi la más grande)
// Paso 4: calcular altura: altura = (2 * Área) / basea.

function calcularAlturaTrianguloEscaleno(lado1, lado2, lado3) {
    
    if (lado1 !== lado2 && lado1 !== lado3 && lado2 !== lado3) {
    // ( semiperimetro )
    const s = (lado1 + lado2 + lado3) / 2;

    //area (formula de heron)
    const area = Math.sqrt(s * (s - lado1) * (s - lado2) * (s - lado3));

    // base (Escogi la base con más longitud)
    const base = Math.max(lado1, lado2, lado3)

    // Altura
    const altura = (2 * area) / base ;
        
    return altura

    } else {
        console.warn("No es un triangulo escaleno, vuelve a introducir los datos")
    }
}

My solution 👇🏻

export function solution(side1, side2, side3) {
  if (side1 === side2 || side2 === side3 || side3 === side1) {
    return false;
  }

  const semiperimeter = (side1 + side2 + side3) / 2;
  const squareRoot = Math.sqrt(
    semiperimeter *
    (semiperimeter - side1) *
    (semiperimeter - side2) *
    (semiperimeter - side3)
  );

  const height = (2 / side1) * squareRoot;
  const heightRounded = Math.round(height);
  return heightRounded;
}

Le eh estado dando vueltas al problema este y no me da cuando le hago una búsqueda del valor más grande de los tres lados para asignarla como base ya que la base siempre toma el primer lado lo cual está mal debe ser el más grande.

function solution(lado1, lado2, lado3) {
  // Tu código aquí 👈
  let base; 
  let s=(lado1+lado2+lado3)/2;
  if (! (lado1 == lado2 && lado1 == lado3 && lado2 == lado3 )) {
    if (lado1 > lado2) {
      if (lado1 > lado3) {
        base = lado1;
        console.log({base:base});
        return Math.floor((2/base)*Math.sqrt(s*(s-base)*(s-lado2)*(s-lado3)))
      } else {
        base = lado3;
        console.log({base:base});
        return Math.floor((2/base)*Math.sqrt(s*(s-base)*(s-lado1)*(s-lado2)))
      }
    } else {
      if (lado2 > lado3) {
        base = lado2;
        console.log({base:base});
        return Math.floor((2/base)*Math.sqrt(s*(s-base)*(s-lado1)*(s-lado3)))
      }else{
        base = lado3;
        console.log({base:base});
        return Math.floor((2/base)*Math.sqrt(s*(s-base)*(s-lado2)*(s-lado1)))
      }
    }
  } else{
    return false
  }
}

Jajajaj… después de como varios intentos, me doy cuenta de que estaba recibiendo el resultado como string y no como número, por eso estaba mal 🤦‍♀️… Lo resolví metiendo en una variable a la altura, quitándole los decimales (no redondeando) con parseInt:

me sale el siguiente error al momento de hacer pruebas:
“Cannot read properties of undefined (reading ‘apply’)”

pero realice pruebas en consola del navegador y funciona bien, envió código espero que les sirva.

export function trianguloEscaleno(ld1, ld2, ld3) {
  
  if (ld1 == ld2 || ld2 == ld3 || ld3 == ld1) {
    return false;
  }
  let s = (ld1 + ld2 + ld3) / 2;
  let area = Math.sqrt(s * (s - ld1) * (s - ld2) * (s - ld3));
  let altura = (2 / ld1) * area;
  return Math.round(altura);

}

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

My solution

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

No me funcionó 😢
Este es mi código:

export function solution(lado1, lado2, lado3) {

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

const catElevado2 = Math.pow(lado2, 2);
const catElevado3 = Math.pow(lado3, 2);
const baseElevado = Math.pow(lado1, 2);
const baseX2 = lado1 * 2;

return Math.trunc((catElevado2 + baseElevado - catElevado3) / baseX2);

} else {
return false;
}

}

Hola les dejo aquí mi solución.

export function solution(lado1, lado2, lado3) {
// Tu código aquí 👈
if (lado1 == lado2 || lado2 == lado3 || lado1 == lado3) {
return false;
}
else {
//Calculamos el semiperimetro
const semiPerimetro = (lado1 + lado2 + lado3) / 2;
//Calculamos la altura
const altura = Math.trunc((2 / lado1) * (Math.sqrt(semiPerimetro * (semiPerimetro - lado1) * (semiPerimetro - lado2) * (semiPerimetro - lado3))));
return altura;
}
}

Aquí mi solución:

.
.
.
.
.
.
.
.
.

// clase 5: Playground (Calcula la Altura de un Triángulo Escaleno)
function Playground1(side1, side2, side3) {
    if (side1 == side2 || side1 == side3 || side2 == side3) {
        return false
    } else {
        // Heron formula
        const S = (side1 + side2 + side3) / 2;
        const height = Math.floor((2 / side1) * (Math.sqrt( S * (S - side1) * (S - side2) * (S - side3) ) ));
        return height
    }
}
Playground1(16,8,10) // 4 
Playground1(6,6,6) // false

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

  let s = (a + b + c) / 2;

  let area = Math.sqrt(s * (s - a) * (s - b) * (s - c));
  let base = a;

  let altura = (2 * area) / base;

  if (a == b || a == c || b == c) {
    return false;
  } else
    return Math.floor(altura);

};

mi solución utilizando sistema de ecuaciones y teorema de Pitágoras

MI SOLUCION

<
export function solution(lado1, lado2, lado3) {
  // Tu código aquí 👈
  if (lado1 == lado2 || lado2 == lado3 || lado3 === lado1) {
    return false;

  } else {
    const perimetroS = ((lado1 + lado2 + lado3) / 2);

    const altura = Math.floor(2 / lado1 * Math.sqrt(perimetroS * (perimetroS - lado1) * (perimetroS - lado2) * (perimetroS - lado3)));

    return altura;
  }
}

solution(16, 8, 10);> 

Ya que el primer lado que se ingresa funciona como la base
entonces debe ser el lado más largo,
al cumplir estás reglas los datos,
podemos definir 3 ecuasiones (no lineales, un dolor):

1. a = (a_1)^2 + (a_2)^2
2. b^2 = (a_1)^2 + h^2
3. c^2 = (a_2)^2 + h^2

Como son cuadraticas no hay certeza que se pueda resolver como si fueran lineales,
pero al jugar con las ecuaciones se puede lograr un resultado:

• h = sqrt( c^2 - ((a^2 - b^2 + c^2) / (2 * a))^2 )

export function solution(a, b, c) {
  if (a === b || a === c || b === c) return false;

  const partLeft = Math.pow(c, 2);

  const partRightTop = Math.pow(a, 2) - Math.pow(b, 2) + partLeft;
  const partRightBottom = 2 * a;
  const partRight = Math.pow((partRightTop / partRightBottom), 2);

  const heightDecimal = Math.sqrt((partLeft - partRight));
  return Math.floor(heightDecimal);
}

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