Curso Práctico de JavaScript

Curso Práctico de JavaScript

Juan David Castro Gallego

Juan David Castro Gallego

Reto: matemáticas con JavaScript

9/24

Lectura

Durante este taller aprendimos a calcular el área y perímetro de un triángulo conociendo la longitud de sus 3 lados y también su altura.

En este ejercicio debes crear una función para calcular la altura de un triángulo isósceles.

  • La función debe recibir, como parámetros, la longitud de los 3 lados del triángulo.
  • La función debe validar que la longitud de los 3 lados del triángulo corresponden a un triángulo isósceles.
  • La función debe retornar la altura del triángulo.

Pista: la función Math.sqrt de JavaScript puede ayudarte a calcular raíces cuadradas.

Solución

⚠️ No leas esta sección hasta haber completado los ejercicios anteriores (o al menos hasta haberlo intentado con todas tus fuerzas).

Imagen ridícula de alto
Imagen ridícula de alto
Imagen ridícula de alto
Imagen ridícula de alto

Vamos paso por paso solucionando todos los requerimientos de nuestro ejercicio:

  • La función debe recibir, como parámetros, la longitud de los 3 lados del triángulo.
function alturaTriangulo(ladoA, ladoB, ladoBase) {
    // ...
}
  • La función debe validar que la longitud de los 3 lados del triángulo corresponden a un triángulo isósceles.
function alturaTrianguloIsosceles(ladoA, ladoB, ladoBase) {
    if (ladoA != ladoB) {
        console.error("Los lados a y b no son iguales");
    } else {
        // ...
    }
}
  • La función debe retornar la altura del triángulo.

Para calcular la altura de un triángulo isósceles vamos a dividir nuestro triángulo en dos. Así tendremos dos triángulos iguales, uno de sus nuevos lados tendrá la misma longitud que la altura del triángulo original y calculando la longitud de este lado habremos calculado también la altura.

Altura triángulo JavaScript

En total vamos a resultar con 3 triángulos, pero como los dos triángulo chiquitos son exactamente iguales, es suficiente si trabajamos con solo 2 triángulos (trianguloGrande y trianguloPequeno).

Altura triángulo JavaScript

Creemos estos dos triángulos en JavaScript:

function alturaTrianguloIsosceles(trianguloGrandeLadoA, trianguloGrandeLadoB, trianguloGrandeLadoBase) {
    if (trianguloGrandeLadoA != trianguloGrandeLadoB) {
        console.error("Los lados a y b no son iguales");
    } else {
        let trianguloPequenoLadoA; // PENDIENTE
        const trianguloPequenoLadoB = trianguloGrandeLadoBase / 2;
        const trianguloPequenoLadoBase = trianguloGrandeLadoA;

        // ...

        const trianguloGrandeAltura = trianguloPequenoLadoA;
        return trianguloGrandeAltura;
    }
}

¡Muy bien! Ahora solo debemos seguir la fórmula para hallar la longitud de un lado del triángulo a partir de dos de sus lados (esto en el mundo de las matemáticas es lo que conocemos como teorema de Pitágoras): aˆ2 + bˆ2 = cˆ2.

Altura triángulo JavaScript

Pero la fórmula aún no es exactamente lo que necesitamos. No necesitamos encontrar ladoBase a partir de ladoA y ladoB, sino encontrar ladoA a partir de ladoBase y ladoB.

Para esto debemos “despejar” ladoA, es decir, “mover de lado” cualquier número o variable que esté modificando a ladoA en la fórmula.

Recuerda que lo que en un lado estaba sumando, pasa al otro restando; lo que estaba a un lado restando, pasa al otro sumando; lo que estaba a un lado multiplicando, pasa al otro dividiendo; lo que a un lado estaba dividiendo, pasa al otro multiplicando; lo que estaba a un lado elevando; pasa al otro radicando, y lo que estaba a un lado radicando, pasa al otro lado elevando.

Altura triángulo JavaScript

¡Muy bien! ¡Ya casi terminamos!

Ahora solo nos falta traducir esta fórmula a JavaScript (recuerda la pista que te di, podemos calcular las raíces cuadradas con la función Math.sqrt de JavaScript):

function alturaTrianguloIsosceles(trianguloGrandeLadoA, trianguloGrandeLadoB, trianguloGrandeLadoBase) {
    if (trianguloGrandeLadoA != trianguloGrandeLadoB) {
        console.error("Los lados a y b no son iguales");
    } else {
        const trianguloPequenoLadoB = trianguloGrandeLadoBase / 2;
        const trianguloPequenoLadoBase = trianguloGrandeLadoA;

        const trianguloPequenoLadoBCuadrado = trianguloPequenoLadoB * trianguloPequenoLadoB;
        const trianguloPequenoLadoBaseCuadrado = trianguloPequenoLadoBase * trianguloPequenoLadoBase;

        const trianguloPequenoLadoA = Math.sqrt(trianguloPequenoLadoBaseCuadrado - trianguloPequenoLadoBCuadrado);

        const trianguloGrandeAltura = trianguloPequenoLadoA;
        return trianguloGrandeAltura;
    }
}

__

¡Si llegaste hasta aquí sin hacer trampa, te felicito! Te graduaste casi oficialmente de este primer taller. Ahora tienes mi bendición para pasar a la siguiente clase y empezar el segundo taller.

Respect

Aportes 897

Preguntas 40

Ordenar por:

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

Asi me quedo

function altura(lado1, lado2, base){
    if(lado1 === lado2 && lado1 != base){
        alert('isoceles')
        const altura = Math.sqrt(lado1**2 - base**2/ 4)
        console.log(altura)
    }
    else{
        alert('no lo se')
    }
}
altura(6, 6, 4)

Quiero hacer una aclaración que puede ser de gran ayuda para todos:

  • Recuerden que todo lo que entra en un formulario es tipo string, el input type=“number” lo que hace es que solamente reciba caracteres tipo número. Pero no significa que lo que entra JS lo tome como Number en las funciones.

  • Para ello se debe hacer coerción de lo que queda en los values o hacer la coerción en las funciones mismas al definirlas.

  • Si esto no se hace, el resultado va a ser muy diferente a lo esperado. Por ejemplo la función de perimetro de triángulo. Si ponemos que estos valores trianglePerimeter(5, 5, 5); al llamar la función el resultado será 555

function trianglePerimeter(side1, side2, base) {
    return (side1 + side2 + base);
}
trianglePerimeter(5, 5, 5);
// 555
  • Si hacemos la coerción quedaría así
function trianglePerimeter(side1, side2, base) {
    return (Number(side1) + Number(side2) + Number(base));
}
trianglePerimeter(5, 5, 5);
// 15

Espero les sirva este dato.

Saludos

Si bien no tiene estilo, es funcional!

Ya estaría completado este modulo 😄
Les comparto mi código por si puede ayudar en algo: https://github.com/iJCode1/Curso-Practico-de-JavaScript

Resultado

Muchachos, hay una ley de los triángulos que dice que, un lado no puede ser mayor a la suma de los lados restantes.
Para agregar esa lógica al código, lo realicé de ésta forma:

const calculAltura = function (a, b, c) {
    let A;
    if(a > b && b === c && a >= 2*b || b > a && a === c && b >= 2*a || c > a && a === b && c >= 2*a) {
        alert('Valores fuera de lo real');
    } else if(a > b && a === c || a < b && a === c) {
        A = Math.sqrt(Math.pow(a,2) - Math.pow(b/2, 2));
        return A;
    } else if(a > c && a === b || a < c && a === b) {
        A = Math.sqrt(Math.pow(a,2) - Math.pow(c/2, 2));
        return A;
    } else if(b > a && b === c || b < a && b === c) {
        A = Math.sqrt(Math.pow(b,2) - Math.pow(a/2, 2));
        return A;
    } else {
        alert('El triangulo no es Isósceles');
    }
}   

Resuelto compañeros!!
Éxitos a todos en sus intentos… tengan paciencia siempre.

function calcularAltura(ladoA,ladoB,ladoC){
  let ladosIsometricos; // Lados que tienen mismas medidas y que hacen al triangulo isosceles
  let ladoBase; // Equivalente al lado diferente
  let altura;

  // Comprobamos que el triangulo segun las medidas proporcionadas, exista.
  // Para ello, la propiedad de la existencia de un traingulo nos dice que...
  // La suma de dos de sus lados no puede resultar menor o igual a la medida del tercer lado.
  if(ladoA+ladoB<=ladoC || ladoA+ladoC<=ladoB || ladoB+ladoC<=ladoA) {
    alert('Este triángulo no existe')
  } else { // Buscamos los lados iguales...
      switch(true) {
        case ladoA === ladoB:
          ladosIsometricos = ladoA
          ladoBase = ladoC
        break;
        case ladoA === ladoC:
          ladosIsometricos = ladoA
          ladoBase = ladoB
        break;
        case ladoC === ladoB:
          ladosIsometricos = ladoB
          ladoBase = ladoA
        break;
      }
      // De no exisitir, la variable ladosIsometricos no se inicializara
      // Usaremos esto para advertir que el triangulo ingresado no es isosceles
      // De lo contrario, la funcion imprimira la altura
      if(!ladosIsometricos){
        alert('Este no es un triángulo isósceles')
      } else {
        altura = Math.pow((ladosIsometricos**2)-(ladoBase**2)/4,1/2)
        console.log(`La altura es ${altura} unidades!!`) 
      }
    }
}

// ===== Jugamos con valores ======
const sideA = 1
const sideB = 2
const sideC = 3

calcularAltura(sideA, sideB, sideC) // resultado: El triangulo no existe

const sideA = 5
const sideB = 8
const sideC = 5

calcularAltura(sideA, sideB, sideC) // resultado: La altura es 3 unidades!!

Bien, ahora para la implementación en la página proyecto decidí hacerlo mediante un checkbox para desplegar los inputs necesarios para los cálculos del triángulo isósceles.
Así quedo:

He aquí mi aporte

Dejo mi solución al reto:

function altura (base, lado) {
    console.log({base, lado})
    let altura = Math.sqrt(Math.pow(base/2,2) + Math.pow(lado,2))
    console.log(altura)
}

function isosceles (l1, l2, l3) {
    if ((l1 === l2 && l1 != l3) || (l1 == l3 && l1 != l2) || (l2 == l3 && l1 != l3)){
        l1 === l2
            ? altura(l3, l1)
            : l1 === l3
                ? altura(l2, l1)
                : altura(l1, l3)
    }
}

isosceles(2,1,1)

Listo ya quedo, no se porque al principio estaba tratando de sacar el área jajaj hasta que leí bien y era la altura jaja.

si lado 1= 5, lado 2 = 5 y la base 8. La altura debe de ser de 3

Aquí mi código, me ayudo un poco con el tema de los enteros y flotantes haber tomado el curso de programación básica. 😃 Va excelente este curso.

//Esta función se llama al dar click al botón "Calcular altura" basándonos del HTML del ejercicio previo :)
function calcularAltura() {
    const inputUno = document.getElementById("inputLadoUno");
    const ladoUno = parseFloat(inputUno.value);
    const inputDos = document.getElementById("inputLadoDos");
    const ladoDos = parseFloat(inputDos.value);
    const inputLadoBase = document.getElementById("inputBase");
    const base = parseFloat(inputLadoBase.value);

    if (ladoUno === ladoDos) {
        if (ladoUno > 0 && base > 0) {
            const sumaLados = ladoUno+ladoDos;
            if (base < sumaLados) {
                //Para usar Pitágoras a2 + b2 = c2
                const c = ladoUno;
                const b = base/2;
                const a = Math.sqrt((c*c) - (b*b));
                alert("La altura es de: " + a + "cm");
            }
            else {
                alert("La base es mayor o igual a la suma de los lados, no existe altura.");
            }
        }
        else {
            alert("Los lados tienen que ser mayor a cero incluyendo la base");
        }
    }
    else {
        alert("Los lados 1 y 2 tienen que ser el del mismo tamaño");
    }
}

Aquí está el mío… JavaScript

Dejo el reto con TS:

const isocelesTriangle = (sideA: number, sideB: number, base: number) => {
    if(sideA === sideB) {
        const b: number = base / 2; // half base
        const h: number = (sideA * sideA) - (b * b); // hypotenuse 
        const height: number = Math.sqrt(h);
        console.log(`The height of the isoceles triangle is: ${height}`);
    } else {
        console.log(`The indicate sides not correspond of a isoceles triangle`)
    }
}
isocelesTriangle(5,5,8)

Yo lo hice un poco diferente primero hice una función que calcula la altura de un triangulo isósceles

function alturaisosceles(lado,base){
    const altura = Math.sqrt(lado**2 - (base/2)**2)
    return altura
}

y después verifique los lados

function cal_alturaisosceles (){
    const inputbase = document.getElementById("medida_base-isosceles")
    const inputlado1 = document.getElementById("medida_lado1-isosceles")
    const inputlado2 = document.getElementById("medida_lado2-isosceles")
    const baseisosceles = inputbase.value
    const ladoisosceles1 = inputlado1.value
    const ladoisosceles2 = inputlado2.value 
    
    if (ladoisosceles1 == ladoisosceles2) {
        altura = alturaisosceles(ladoisosceles1,baseisosceles)
        alert("La altura de tu trianguolo es de " + altura + "cm")
    }
    else{
        alert ("los lados 1 y 2 no son iguales")
    }   
}

la verdad no se si es trampa jajajajaja

Así quedo mi solución, realice tres calculadoras para triángulos, una para el equilátero, otra para el isósceles y una tercera que permite realizar cálculos con cualquier triángulo teniendo el dato de altura.

Les comparto mi solución:

var lado1, lado2, lado3;

function alturaTriangulo(lado1, lado2, lado3){
    var isoceles = false;
    var a,b;
    var altura = 0;

    if (lado1 == lado2 && lado1 != lado3){
        isoceles = true;
        a = lado1;
        b = lado3;
    } else if (lado1 == lado3 && lado1 != lado2) {
        isoceles = true;
        a = lado1;
        b = lado2;
    } else if (lado2 == lado3 && lado2 != lado1) {
        isoceles = true;
        a = lado2;
        b = lado1;
    } else {
        isoceles = false;
    }

    if (isoceles){
        altura = Math.sqrt(Math.pow(a, 2)-(Math.pow(b, 2)/4));
        return console.log("La altura de tu triámgulo es: " + altura);
    } else {
        console.log("Lo siento pero tu triángulo no es isósceles");
    }
}

lado1 = parseFloat(prompt("Digita la medida del lado 1 de tu triángulo"));
lado2 = parseFloat(prompt("Digita la medida del lado 2 de tu triángulo"));
lado3 = parseFloat(prompt("Digita la medida del lado 3 de tu triángulo"));

alturaTriangulo(lado1, lado2, lado3);

Hice el código con html para hacerlo un poco más interactivo.
Además quise añadir que evaluara si el triángulo es equilátero, isóceles o escaleno en función de los parámetros que pongamos. Calcula la altura y el área por separado, los datos salen en la consola del navegador.
Les dejo el código de html y js:

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">
    <style>
        body{
            font-family: Verdana, Geneva, Tahoma, sans-serif;
        }
        p{
            font-family: Arial, Helvetica, sans-serif;
        }
    </style>
    <title>calcular tirangulo isóceles</title>
</head>
<body>
    <h1>Vamos a calcular la <strike>rosalía</strike> altura de un triángulo isóceles</h1>
    <section>
        <label for="">
            <p>
                <input type="number" id="Lado1"> Lado 1
            </p>
            <p>
                <input type="number" id="Lado2"> Lado 2
            </p>
            <p>
                <input type="number" id="Base"> Base
            </p>
            <p>
                <button type="button" onclick="calcularAltura()">Calcular altura</button>
                <button type="button" onclick="calcularArea()">Calcular área</button>
            </p>
        </label>
    </section>
    <script src="triangulos.js"></script>
</body>
</html> 

JS

const lado1 = document.getElementById("Lado1");
const lado2 = document.getElementById("Lado2");
const base = document.getElementById("Base");

function evaluar(cateto1, cateto2, cateto3) {
    var tipo_de_triangulo;
    
    if(cateto1 == cateto2 && cateto1 == cateto3){
        tipo_de_triangulo = "Equilátero";
        console.log("Es Equilátero")
        return tipo_de_triangulo;
    }

    else if(cateto1 == cateto2){
        tipo_de_triangulo = "Isóceles";
        console.log("Es Isóceles");
        return tipo_de_triangulo;
    }
    else{
        tipo_de_triangulo = "Escaleno";
        console.log("Es Escaleno");
        return tipo_de_triangulo;
    }
}



// Cálculo de Altura

// alturaNormal significa que es equilátero o isóceles 
function alturaNormal(cateto, base){
    base = base / 2;
    const altura = Math.sqrt((cateto ** 2) - (base ** 2))
    console.log("Altura: " + altura)
    return altura;
}


function alturaEscaleno(cateto1, cateto2, cateto3){
    // Formula de Herón (tienes la medida de los 3 lados)
    // Var s (es la mitad del perímetro del triangulo) / s= (a+b+c)/2
    // 1/2bh (b = lado b) (h = alturaEscaleno)
    
    const s = (cateto1 + cateto2 + cateto3) / 2;
    const areaEscaleno = Math.sqrt(s * (s - cateto1) * (s - cateto2) * (s - cateto3))
    
    var h;
    const alturaEscaleno = Math.sqrt(s * (s - cateto1) * (s - cateto2) * (s - cateto3)) / ( 3 / 2 )
    
    console.log("Area: " + areaEscaleno);
    console.log("Altura: " + alturaEscaleno);
}


// Cálculo de Área

function areaNormal(cateto, base) {
    const h = alturaNormal(cateto, base);
    const area = (base * h) / 2;
    return area;
}

function areaEscaleno(cateto1, cateto2, base) {
    const s = (cateto1 + cateto2 + cateto3) / 2;
    const areaEscaleno = Math.sqrt(s * (s - cateto1) * (s - cateto2) * (s - cateto3))
    return areaEscaleno;
}



// Triggers

function calcularAltura(){
    const tipo = evaluar(lado1.valueAsNumber, lado2.valueAsNumber, base.valueAsNumber);

    if(tipo != "Escaleno"){
        let altura = alturaNormal(lado1.valueAsNumber, base.valueAsNumber)
    }
    else{
        let altura = alturaEscaleno(lado1.valueAsNumber, lado2.valueAsNumber, base.valueAsNumber)
    }
}

function calcularArea(){
    const tipo = evaluar(lado1.valueAsNumber, lado2.valueAsNumber, base.valueAsNumber);

    if(tipo != "Escaleno"){
        let area = areaNormal(lado1.valueAsNumber, base.valueAsNumber)
        console.log("El área es: " + area)
    }
    else{
        let area = areaEscaleno(lado1.valueAsNumber, lado2.valueAsNumber, base.valueAsNumber)
        console.log("El área es: " + area)
    }
}

Hola, yo hice un poquito mas cortita la función, use if ternarios para que quede mas facil de leer uwu

    function alturaTriangulo(lado1,lado2, base){
        const teoremaPitagoras = Math.sqrt(lado1**2 - ((base/2) ** 2));
        const isoceles = lado1 === lado2 && base < lado1 + lado2 ? true : false;

        return altura = isoceles === true?  teoremaPitagoras : "revisa que los lados sean iguales, y la base menor a la suma de los lados";
    }

Se la puede hacer mas corta, pero pienso que queda mas fácil de leer de esta forma owo.
Quedo perron o no?

//Código de Triangulo Isósceles
function alturaIsosceles(base, lado){
    const paso_1 = (lado**2) - (base / 2)**2;
    const altura = Math.sqrt(paso_1);
    return altura;
}

function calcularAlturaIsosceles(){
    const input1 = document.getElementById('InputIsosceles_6')
    const input2 = document.getElementById('InputIsosceles_7')
    const input3 = document.getElementById('InputIsosceles_8')
    const value1 = input1.value;
    const value2 = input2.value;
    const value3 = input3.value;
    const base = parseFloat(value1);
    const lado1 = parseFloat(value2);
    const lado2 = parseFloat(value3);

    if (lado1 === lado2) {
        const altura = alturaIsosceles(base, lado1)
        alert(altura + ' cm')
    }else{
        alert('Los triangulos isósceles tienen dos lados iguales.')
    }
}

Les comparto como resolví el reto:

function alturaTrianguloIsosceles (lado1, lado2, base) {
    if (lado1 === lado2 && lado1 != base ){
    const altura =  lado1 * lado2;
    const altura2 = base / 2;
    const altura3 = altura2 * altura2;
    const altura4 = altura - altura3;
    return Math.sqrt (altura4);
    } else {
        console.log ("Ingresaste mal los datos")
    }
     
};

alturaTrianguloIsosceles (13, 13, 10);

Hola! como estan ? este es mi codigo! lo unico que me dio pereza fue calcular la altura y puse un calculo random 😃 jajaja, pero lo otro… it works well

<section>
            <h2>calcula el area y perimetro de un triangulo isoceles</h2> 
            <form>
               <label for="inputTrianguloIsocelesLado1 inputTrianguloIsocelesLado2 inputTrianguloIsocelesBase">
                   escride cuanto quieres que midan los lados y la base del triangulo isoceles
               </label> 
               <input id="inputTrianguloIsocelesLado1" type="number" placeholder="escribe el numero que tu quieras para el lado 1 del triangulo isoceles" />
               <input id="inputTrianguloIsocelesLado2" type="number" placeholder="escribe el numero que tu quieras para el lado 2 del triangulo isoceles" />
               <input id="inputTrianguloIsocelesBase" type="number" placeholder="escribe el numero que tu quieras para la base del triangulo isocles" />
               <button type="button" onclick="CalcularAltura()">
                   calcula la altura!
               </button>
    
            </form>
            </section>
// calculo del triangulo isoceles

console.group("triangulo isoceles");

function TrianguloIsoceles(LADO, LADO2, BASE) {
	var lado2 = LADO2;
	var lado1 = LADO;
	var base = BASE;
	if (lado1 === lado2) {
		console.log("si tiene 2 lados iguales entonces no es un traingulo isoceles!")
	} else {
	console.log("los lados del triangulo son " + lado1 + " y " + lado2 );
	console.log("la base del triangulo es " + base);

	const alturaIsoceles =  (Number((lado2 * lado1)/ base)); 
	console.log("la altura del triangulo isoceles es " + alturaIsoceles);
 };			
};

function CalcularAltura() {
	var inputTriangulo = document.getElementById("inputTrianguloIsocelesLado1");
	var inputTriangulo2 = document.getElementById("inputTrianguloIsocelesLado2");
	var inputTrianguloIsocelesBase = document.getElementById("inputTrianguloIsocelesLado1");
	
	var valueTriangulo = inputTriangulo.value;
	var valueTriangulo2 = inputTriangulo2.value;
	var valueTrianguloIsocelesBase = inputTrianguloIsocelesBase.value;

	var altura = TrianguloIsoceles(valueTriangulo, valueTriangulo2, valueTrianguloIsocelesBase);
	console.log(altura);
	document.write(altura);

	
}

Me costó un montón leí mucho código de ustedes antes de poder entender bien y que funcionara. Gracias, recibo sugerencias.

// Isosceles
function alturaTrianguloIsosceles(lado1, lado2, base) {
    if (lado1 !== lado2) {
        alert("The sides are not equal")
    }
    else{
        //Construimos los nuevos lados cortando el triangulo al medio
        //El lado mas chico es la base dividida al medio
        const ladoTiny2 = base / 2;

        //La base pasa a ser el lado 1
        const baseTiny = lado1;

        const ladoTiny2Cuadrado = ladoTiny2 * ladoTiny2;
        const baseTinyCuadrado = baseTiny * baseTiny;

        //El lado restante es igual a la altura del triangulo mayor. 
        //Conseguimos esta restando la raiz cuadrada de la nueva base y el lado
        const ladoTiny1 = Math.sqrt(baseTinyCuadrado - ladoTiny2Cuadrado);
        const altura = ladoTiny1;
        return altura;
        
    }
}
console.groupEnd();

//Isosceles 
function calculateIsoscelesHeight() {
    const input1 = document.getElementById("inputIsosceles1");
    const input2 = document.getElementById("inputIsosceles2");
    const inputBase = document.getElementById("inputIsoscelesBase");
   
    const value1 = Number(input1.value);
    const value2 = Number(input2.value);
    const valueBase = Number(inputBase.value);

    const height = alturaTrianguloIsosceles(value1, value2, valueBase);
    alert(height);
}

siu.

Buenas quiero compartir mi codigo, por si les sive de ayuda a alguien

// Declaramos una funcion con la formula de calcular la altura, la pueden buscar en internet 

function calcularAlturaTriangulo(lado1,lado2,){

    const altura = Math.sqrt((lado1 * lado1) - ((lado2 * lado2) / 4))

    console.log(altura);
}

// Declaramos una funcion para pasarle los lados y la base y con un if verificamos si es o no isóceles, 
// en caso de que si lo sea llamamos a la funcion antes declarada usando los parametros de lado1 y lado2 
function alturaTrianguloIso(lado1,lado2,base) {

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

        calcularAlturaTriangulo(lado1,lado2);

    }else{
        return "El triangulo no es Isóceles";
    }
    
}

Saludos! este fue mi resultado, busque varias opciones y lo acorte al final lo maximo posible

function altura(lado1, lado2, base){
  if (lado1 === lado2 && lado1 !== base){
    const altura = Math.sqrt((lado1**2 - base**2 )/4);  
    return altura;}
  else{
    console.log("intruduzca valores diferentes");
  }
}

saludos profe JuanDC ya pase esta parte

Creé un código que reciba los 3 lados en cualquier orden, sin saber cual es la base, y los analice si corresponden a un triangulo, si es un triangulo isosceles, y cual es su altura. Les dejo el código:

function alturaTriangulo(lado, base) {
    return Math.sqrt((lado * lado) - ((base * base)/4));
}

function calcularAlturaTriangulo() {
    const input1 = document.getElementById("inputTriangulo01");
    const lado1 = Number(input1.value);
    const input2 = document.getElementById("inputTriangulo02");
    const lado2 = Number(input2.value);
    const input3 = document.getElementById("inputTriangulo03");
    const lado3 = Number(input3.value);

    if (((lado1 + lado2) < lado3) || ((lado2 + lado3) < lado1) || ((lado1 + lado3) < lado2)) {
        alert("No es un triangulo!")
    }
    else { 
        switch (true){
            case (lado1 === lado2 && lado1 != lado3):
                const altura = alturaTriangulo(lado1, lado3)
                alert(altura + "Cm.")
                break;
            case (lado2 === lado3 && lado2 != lado1):
                const altura2 = alturaTriangulo(lado2, lado1)
                alert(altura2 + "Cm.")
                break;
            case (lado1 === lado3 && lado1 != lado2):
                const altura3 = alturaTriangulo(lado1, lado2)
                alert(altura3 + "Cm.")
                break;
            default:
                alert("No es un triangulo isosceles!")
        }
    }   
}

/*
Lado 1 = a
Lado 2  = b
Base = c
*/
function altura(a,b,c){  
    if(a === b && a != c){
        const h = (Math.pow(a,2) - (Math.pow(b,2)) / 2);
        const altura = Math.sqrt(h);
        alert("El triangulo es isosceles y la altura es: " + altura);
    }
    else
        alert("No es un triangulo isosceles");
}
altura(5,5,4);

Arme una pequeña función para identificar el tipo de triangulo, puede ser de utilidad para calcular altura, perímetro y área de cada tipo de triangulo de acuerdo a sus lados n_n

function tipoTriangulo(lado1, lado2, lado3){
    if ((lado1 === lado2)&& (lado1 === lado3)) {
        console.log("Es equilatero")
    } else if (
        ((lado1 === lado2)&&(lado1!=lado3))||
        ((lado2 === lado3)&&(lado2!=lado1))||
        ((lado3 === lado1)&&(lado3!=lado2))){
        console.log("es isoseles")
    } else {
        console.log("es escaleno")
    }
function alturaIsoceles(ladoA,ladoB,base){
    if(ladoA!=ladoB){
        console.error("Los lados a y b no son iguales");
    }else{
        //triangulo pequeño 
        const ladoAP = base/2;
        const hipotenusaP = ladoA;
        const ladoBP = (hipotenusaP**2)-(ladoAP**2);
        const alturaIsoceles = (ladoBP)**0.5;
        return alturaIsoceles;
    }
}

Así quedó mi función:

function calcularAlturaTrianguloIsosceles(lado1, lado2, base) {
    if (lado1 === lado2) {
        var lado1, lado2 = a;
        var base = b;
        return h = Math.sqrt((a * a) - (b * b) / 4);
    } else {
        alert("Esto no es un triangulo isosceles");
    }
}

así quedo mi tarea.

function alturaIsoceles(lado1, lado2, base) {
    lado1 = parseInt(prompt("Cual es el lado a?"));
    lado2 = parseInt(prompt("Cuanto es el lado b?"));
    base = parseInt(prompt("Cuanto es el la base"));

    if (lado1 === lado2 && lado1 != base) {
        console.log("es isoceles");
        var altura = Math.sqrt((lado1 * lado1) - (base * base / 4));
        console.log("la altura del triangulo es: " + altura);
    } else {
        console.log("No es isoceles");
    }

}

Mi solución 😃
En caso de que en la primera función retorne falso la segunda función valida ese resultado y si es falso nos imprime en pantalla que ese no es un triángulo isósceles


// Código del triángulo isósceles
function isoTriangleHeight(sideA, sideB, base){

    if(sideA === sideB && sideB != base){
        return Math.sqrt((sideA**2) - ((base**2)/4));

    }else{
        return false;
    }
}
// Triangulo Isosceles
function calculateIsoTriangle(){
    const inputSideA = document.getElementById("InputIsoTriangleSideA");
    const valueSideA = Number(inputSideA.value);

    const inputSideB = document.getElementById("InputIsoTriangleSideB");
    const valueSideB = Number(inputSideB.value);

    const inputBase = document.getElementById("InputIsoTriangleBase");
    const valueBase = Number(inputBase.value);

    //Altura
    const height = isoTriangleHeight(valueSideA, valueSideB, valueBase);
    if (height != false){
        const heightRes = document.getElementById("ithResult");
        heightRes.innerHTML = height.toFixed(2) + " cm";
    }else{
        const heightRes = document.getElementById("ithResult");
        heightRes.innerHTML = "No es un triángulo isósceles";
    }
}

Que opinan?

Listooooooo

function isosceles_measures() {
    const side = document.getElementById("isosceles_side").value
    const base = document.getElementById("isosceles_base").value
    if (String(side).length === 0 || String(base).length === 0) {
        window.alert("Write all values for triangle!")
    } else {

        const height = calculate_isosceles_height(base, side)
        write_html("isosceles_height", `The height is ${(height)}`)
        write_html("isosceles_area", `The area is ${calculate_isosceles_area(base, height)}`)
        write_html("isosceles_perimeter", `The perimeter is ${calculate_isosceles_perimeter(base, side)}`)
    }
}

calculate_isosceles_height(4, 3)

function calculate_isosceles_height(base, side) {
    const new_base = base / 2
    return Math.sqrt(Math.pow(side, 2) - Math.pow(new_base, 2))
}

function calculate_isosceles_area(base, height) {
    return (base * height) / 2
}

Así quedó el mio.
Geometry Crack

Mobile

Tablet

Laptop

![](

Dejo mi codigo por aquí
HTML:
<h2>Calcula la altura de un triangulo Isósceles </h2>
<form action="">
<label for=“InputTrianguloIscoceles”>
Escribe cuanto mide el lado A de tu Triangulo
</label>
<input id=“InputTrianguloIscoceles” type=“number”>
<label for=“InputTrianguloIscoceles2”>
<br> Escribe cuanto mide el lado B de tu Triangulo
</label>
<input id=“InputTrianguloIscoceles2” type=“number”>
<label for=“InputTrianguloIscoceles3”>
<br> Escribe cuanto mide el lado C de tu Triangulo
</label>
<input id=“InputTrianguloIscoceles3” type=“number”>
<button type=“button” onclick=“calcularAlturaIscoceles()”>
Calcula la altura del triangulo Isósceles
</button>

JS:

//Calcula la altura de un triangulo Isósceles.

function alturaTrianguloIscoceles(lado1, lado2, base){
    	return Math.sqrt((lado1*lado2)-((base*base)/4));
}

function calcularAlturaIscoceles(){
	const input = document.getElementById("InputTrianguloIscoceles");
	const value = parseInt(input.value);
	const input2 = document.getElementById("InputTrianguloIscoceles2");
	const value2 = parseInt(input2.value);
	const input3 = document.getElementById("InputTrianguloIscoceles3");
	const value3 = parseInt(input3.value);
	if(value==value2 && value!=value3 && value2!=value3){
    	const altura = alturaTrianguloIscoceles(value, value2, value3);
    	alert("El calculo de la altura es: "+ altura);
	}else{
    	alert("Los lados A y B no son iguales, no es un triangulo Iscoceles");
	}

}

function alturaTriangulo(a, b, base){
    if(a == b){
        //return Math.sqrt((a*a) - ((base/2)*(base/2)));
        return Math.sqrt(Math.pow(a,2) - Math.pow(base/2,2));
    }
    else{
        console.error("los lados a y b no son iguales");
        return "el triángulo no es isósceles";
    }

}
function calcularAlturaTriangulo(){
    const input1 = document.getElementById("InputTrianguloLado1");
    const lado1 = input1.value;
    const input2 = document.getElementById("InputTrianguloLado2");
    const lado2 = input2.value;
    const input3 = document.getElementById("InputTrianguloBase");
    const base = input3.value;
    const altura = alturaTriangulo(lado1, lado2, base);
    alert("La altura es de: " + altura);
} 


¡Reto realizado! 😄

function alturaTriangulo(lado1, lado2, ladoBase) {
  if (lado1 === lado2 && lado1 !== ladoBase) {
    const altura = Math.sqrt(lado1 ** 2 - (ladoBase / 2) ** 2);
    return altura;
  } else {
    alert("No estás agregando los lados de un triángulo isósceles");
  }
}

function areaTriangulo(lado1, lado2, ladoBase,) {
  return (ladoBase * alturaTriangulo(lado1, lado2, ladoBase)) / 2;
}

aqui les dejo mi validación de como lo hice

 function alturaIso(lado1, lado2, base){
     const altura = Math.sqrt((lado1 * lado2) - ((base/2) * (base/2)));
     if(lado1 === lado2 && lado1 != base){
        return altura;
     }
     else{
         alert("ingresa un tringulo isoceles válido");
     }
    
    
 }

 function calcularAlturaIso(){
     const inputlado1 = document.getElementById("InputTrianguloLadoiso1");
     const inputlado2 = document.getElementById("InputTrianguloLadoiso2");
     const inputbase = document.getElementById("InputTrianguloBaseiso");
     const valuelado1 = parseInt(inputlado1.value);
     const valuelado2 = parseInt(inputlado2.value);
     const valuebase = parseInt(inputbase.value);

     const alturaiso = alturaIso(valuelado1, valuelado2, valuebase);
     alert(alturaiso);
 }

Reto Cumplido:

JS:

function trianguloObject(l1,l2,l3) {
    this.l1 = parseFloat(l1);
    this.l2 = parseFloat(l2);
    this.l3 = parseFloat(l3);
}

function tomarValoresDelTriangulo(){
    var l1 = document.getElementById("input--lado1").value;
    var l2 = document.getElementById("input--lado2").value;
    var l3 = document.getElementById("input--lado3").value;
    var cosoTriangular = new trianguloObject(l1,l2,l3);
    return cosoTriangular;
}

function reto1Triangulo() {
    var triangulo = tomarValoresDelTriangulo();
    var esIsosceles = false;
    var ladoIgual;
    var ladoDiferente;
    switch(true) {
        case triangulo.l1 == triangulo.l2:
            esIsosceles = true;
            ladoIgual = triangulo.l1;
            ladoDiferente = triangulo.l3;
            break;
        case triangulo.l1 == triangulo.l3:
            esIsosceles = true;
            ladoIgual = triangulo.l1;
            ladoDiferente = triangulo.l2;
            break;
        case triangulo.l2 == triangulo.l3:
            esIsosceles = true;
            ladoIgual = triangulo.l2;
            ladoDiferente = triangulo.l1;
            break;
        default:
            esIsosceles = false;
    }
    if(!esIsosceles) {
        alert("No es un triángulo Isosceles");
    }
    else {
        var altura = Math.sqrt(Math.pow(ladoIgual,2) - Math.pow(ladoDiferente/2,2));
        alert(`ES UN TRIÁNGULO ISOSCELES \nSu Altura: ${altura} cm`);
    }
}

Mi humilde aporte querido Platziverso!

¡Cumplido!
Aún no leo la solución de David. Antes les comparto la mía.

Mi función verifica que el triángulo sea isósceles, sin importar el orden en que las dimensiones de sus aristas fueron ingresadas, retorna el valor de los lados que son iguales y, en base a éste valor, calcula la altura del triángulo. Use uina función anidada.

function triangleHeight(){
    const traingleEdgeOne = document.getElementById("triangle_edge_one");
    const traingleEdgeTwo = document.getElementById("triangle_edge_two");
    const traingleEdgeThree = document.getElementById("triangle_edge_three");
    const edgeOneValue = parseInt(traingleEdgeOne.value);
    const edgeTwoValue = parseInt(traingleEdgeTwo.value);
    const edgeThreeValue = parseInt(traingleEdgeThree.value);
    
    function calculateHeight(equalEdgesValue){
       var heightValue = (equalEdgesValue**2 - (equalEdgesValue/2)**2)**(1/2);
       alert(heightValue);
    }

    if (edgeOneValue == edgeTwoValue) {
        calculateHeight(edgeOneValue);
    }
    else if (edgeOneValue == edgeThreeValue){
        calculateHeight(edgeOneValue);
    }
    else if (edgeTwoValue ==  edgeThreeValue){
        calculateHeight(edgeTwoValue);
    }
    else {
        alert("Su triángulo no es isóceles, por lo que no pudimos calcular la altura del mismo.")
    }
}
// ISOSCELES TRIANGLE

function heightIsoscelesTriangle(side, base) {
	if (side * 2 <= base) {
		console.log(`The double of the length of the side must be greater than the base's`);
	} else {
		const hypotenuse = side;
		const cathetus = base / 2;
		const height = Math.sqrt(hypotenuse ** 2 - cathetus ** 2);
		return console.log(height);
	}
}
function altura(lado1, lado2, base){
    if(lado1===lado2 && lado1!=base){
        console.log("Es un triangulo isoceles")
    }
    else{ console.log("No eres un trianfo Isoceles XD")}

    var acumulador=Math.sqrt((lado1*lado2)-(base*base)/4)
    return acumulador
} 

 altura(10,14,12);

Les comparto mi código simple y funcional:
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>Figuras Geométricas | Curso Práctico de JavaScript</title>
  </head>
  <body>
    <header>
      <h1>Figuras geométricas</h1>
      <p>Este es el primer taller del curso práctico de JavaScript</p>
    </header>
    <section>
      <h2>Calcula el área y perímetro de un cuadrado</h2>
      <form>
        <label for="InputCuadrado"
          >Escribe cuánto mide cada lado de tu cuadrado</label
        >
        <input type="number" id="InputCuadrado" />
        <button type="button" onclick="calcularPerimetroCuadrado()">
          Calulcar Perímetro
        </button>
        <button type="button" onclick="calcularAreaCuadrado()">
          Calulcar Área
        </button>
      </form>
    </section>
    <section>
      <h2>Calcula el área y perímetro de un triángulo</h2>
      <form>
        <label for="InputTrianguloLado1"
          >Escribe cuánto mide el lado 1 de tu triángulo</label
        >
        <input type="number" id="InputTrianguloLado1" />
        <label for="InputTrianguloLado2"
          >Escribe cuánto mide el lado 2 de tu triángulo</label
        >
        <input type="number" id="InputTrianguloLado2" />
        <label for="InputTrianguloBase"
          >Escribe cuánto mide la base de tu triángulo</label
        >
        <input type="number" id="InputTrianguloBase" />
        <button type="button" onclick="calcularPerimetroTriangulo()">
          Calulcar Perímetro
        </button>
        <button type="button" onclick="definirTipoTriangulo()">
          Calulcar Área
        </button>
      </form>
    </section>
    <section>
      <h2>Calcula el área y perímetro de un círculo</h2>
      <form>
        <label for="InputCiculo"
          >Escribe cuánto mide el radio de tu círculo</label
        >
        <input type="number" id="InputCiculo" />
        <button type="button" onclick="calcularPerimetroCirculo()">
          Calulcar Perímetro
        </button>
        <button type="button" onclick="calcularAreaCirculo()">
          Calulcar Área
        </button>
      </form>
    </section>
    <script src="./figuras.js"></script>
  </body>
</html>

JavaScript

//Código del cuadrado

//perimetro cuadrado
const perimetroCuadrado = (lado) => lado * 4;

//area cuadrado
const areaCuadrado = (lado) => lado * lado;

//Código del triángulo

//perimetro triangulo
const perimetroTriangulo = (lado1, lado2, base) => lado1 + lado2 + base;

//area triangulo isosceles
const areaTrianguloIsosceles = (base, altura) => (base * altura) / 2;

//area triangulo equilatero
const areaTrianguloEquilatero = (lado) =>
  (Math.sqrt(3) / 4) * Math.pow(lado, 2);

//Código del círculo

//circunferencia
const perimetroCirculo = (radio) => radio * 2 * Math.PI;

//area circulo
const areaCirculo = (radio) => Math.PI * (radio * radio);

//interactuar con HTML
//imprimir perimetro de cuadrado
function calcularPerimetroCuadrado() {
  const inputLado = parseFloat(document.getElementById("InputCuadrado").value);
  const perimetro = perimetroCuadrado(inputLado);
  alert(perimetro);
}

//imprimir area de cuadrado
function calcularAreaCuadrado() {
  const inputLado = parseFloat(document.getElementById("InputCuadrado").value);
  const area = areaCuadrado(inputLado);
  alert(area);
}

//imprimir el perimetro del triangulo
function calcularPerimetroTriangulo() {
  const inputLado1 = parseFloat(
    document.getElementById("InputTrianguloLado1").value
  );
  const inputLado2 = parseFloat(
    document.getElementById("InputTrianguloLado2").value
  );
  const inputBase = parseFloat(
    document.getElementById("InputTrianguloBase").value
  );
  const perimetro = perimetroTriangulo(inputLado1, inputLado2, inputBase);
  alert(perimetro);
}

//definir el tipo de triangulo y calcular su area
function definirTipoTriangulo() {
  const inputLado1 = parseFloat(
    document.getElementById("InputTrianguloLado1").value
  );
  const inputLado2 = parseFloat(
    document.getElementById("InputTrianguloLado2").value
  );
  const inputBase = parseFloat(
    document.getElementById("InputTrianguloBase").value
  );
  if (inputLado1 == inputLado2 && inputLado1 != inputBase) {
    //triangulo isosceles
    const altura = calcularAlturaTriangulo(inputLado1, inputBase);
    const area = areaTrianguloIsosceles(inputBase, altura);
    alert(area);
  } else if (inputLado1 == inputLado2 && inputLado1 == inputBase) {
    //triangulo equilatero
    const area = areaTrianguloEquilatero(inputBase);
    alert(area);
  } else {
    alert(`Los lados del triángulo deben ser iguales`);
  }
}

//calcular altura del triangulo isosceles
function calcularAlturaTriangulo(lado, base) {
  const baseReal = base / 2;
  //l^2 = b^2 + a^2
  //l^2 - b^2 = a^2
  //sqr(l^2 - b^2) = a
  const altura = Math.sqrt(Math.pow(lado, 2) - Math.pow(baseReal, 2));
  return altura;
}

//imprimir el perimetro de un circulo
function calcularPerimetroCirculo() {
  const inputRadio = parseFloat(document.getElementById("InputCiculo").value);
  const perimetro = perimetroCirculo(inputRadio);
  alert(perimetro);
}

//imprimir el perimetro de un circulo
function calcularAreaCirculo() {
  const inputRadio = parseFloat(document.getElementById("InputCiculo").value);
  const area = areaCirculo(inputRadio);
  alert(area);
}

Buen ejercicio para empezar a soltar los dedos

function alturaTriangulo(lado1, lado2, base){
    if(lado1==lado2 && lado1!=base){
        const altura = Math.sqrt(lado1**2-base**2/4)
        alert("Es un Triangulo Isoceles de altura: "+ altura)
    }else{
        alert("No es un triangulo Isoceles")
    }
}

Así me quedo Platzinautas:

function triangleHeigth(side1, side2, base) {
    if (side1 == side2 && side1 != base){
        // is isosceles
        const heigth = Math.sqrt((side1)**2 - (base/2)**2);
        return heigth
    }
}

El mio así me quedo.

const inputLado1TrianguloHTML = document.getElementById('inputTriangulo1');
const inputLado2TrianguloHTML = document.getElementById('inputTriangulo2');
const inputBaseTrianguloHTML = document.getElementById('inputTrianguloBase');


const calcularAlturaTrianguloIsoceles = () => { 
    const valorLado1 = parseInt(inputLado1TrianguloHTML.value);
    const valorLado2 = parseInt(inputLado2TrianguloHTML.value);
    const valorBase = parseInt(inputBaseTrianguloHTML.value);

    if( valorLado1 == valorLado2 && valorLado1 != valorBase ) {
        let altura = Math.sqrt((valorLado1 ** 2) - ((valorBase / 2) ** 2));
        let alturaFixed = altura.toFixed(2);
        alert(
`Es un triangulo isoceles! 
Su altura es ${alturaFixed}`
);
        } else { 
            alert('No es un isoceles.');
        }
}

Mi función quedó así:

function calcHeightTriangleIsc(
  sidea,
  sideb,
  sidec,
) {
  const result = (sidea + sideb + sidec) / 3;
  if (result !== sidea) throw new Error("Los lados deben ser iguales");
  const divisibleTriangule = sidea ** 2;
  const exponencialA = (sidea / 2) ** 2;

  return Math.sqrt(divisibleTriangule - exponencialA);
}

Nota ☢☢🚧: Haciendo pruebas en la función del profe encontré en error debido a que solo se están calculando dos lados iguales cuando deberían de ser todos los lados iguales(esto es propio de un triángulo isosceles o equilatero).

Aquí les dejo las pruebas en consola:

Lo arme así. Con dos alert para especificar mejor el detalle y el parseInt para asegurar que ingrese como numero.

Quiero compartir mi funcion minimalista

<function hIsosceles(l1,l2,b)
{
    if(l1===l2){
        return Math.sqrt((l1*l1)-((b*b)/4));
    }
    else{
        return "no es isosceles"
    }
}> 

Comparto mi resultado.

const isoscelesTriangle = (side1, side2, base) => {
    if (side1 === side2 && side1 != base) {
        let height = Math.sqrt( (side1 * side2) - ((base / 2) ** 2) )
        console.log(`La altura del triangulo isosceles es: ${height}`)
    } else {
        console.log(`No es un triangulo isosceles`)
    }
}

isoscelesTriangle(8, 8, 5)
			**Reto cumplido**
const calcularAlturaIsoceles = (lado1, lado2, base) =>{

    if(lado1 == lado2 && (lado1 && lado2) != base){
        console.log("es un isoceles");

        console.log(Math.sqrt((lado1 * lado2) - (base/2)**2  ))

    } else {
        console.log("no es un isoceles");
    }

}
calcHeightTriangle = (aSide, bSide, base) => {
  if (aSide !== bSide) {
    alert(`Triangle is not ISOSCELES`);
  } else {
    return Math.floor(Math.sqrt(Math.pow(aSide, 2) + Math.pow(base / 2, 2)));
  }
};

[](function altura (lado1, lado2, base){
const resultado = Math.sqrt((lado1)**2-(base/2)**2);
alert(resultado);
};

altura()😉

Me extendi un poco pero asi quedo
https://darko-132.github.io/figuras-geometricas/

// calculo de medidas del cuadrado
function cuadrado(){
    let m= document.getElementById("mcu").value;
    let a= m*2
    let p= m*4

    if(m>0){
        document.getElementById("acu").value=a.toFixed(2)+"Cm^2"
        document.getElementById("pcu").value=p.toFixed(2)+"Cm"
    }else{
        alert("inserte un numero valido")
    }

}
// calculo de medidas del triangulo
function triangulo(){
    const a =parseInt(document.getElementById("a").value);
    const b =parseInt(document.getElementById("b").value);
    const c =parseInt(document.getElementById("c").value);
    var tT =document.getElementById("tTriangulo").innerHTML;
    // equilatero
     if(a===b && b===c && c===a){
         let raiz= Math.sqrt(3)
         let h= (a*raiz)/4
         let ar= (h*a)/2
         let p= a*3
         document.getElementById("atr").value=ar.toFixed(2)+"Cm^2";
         document.getElementById("at").value=h.toFixed(2)+"Cm";
         document.getElementById("pt").value=p.toFixed(2)+"Cm";
         console.log(h)
        
        document.getElementById("tTriangulo").innerHTML="Es un triangulo equilatero"  
     }
     //isoceles
     else if(a===b && a!==c || b===c && b!==a || c===a && c!==b){
        let p=a+b+c;
             
        if(a===b && a!==c){
            let ar=(c/4)*Math.sqrt(4*(a*a)-(c*c))
            let h= 2*(ar/c)
            document.getElementById("at").value=h.toFixed(2)+"Cm";
            document.getElementById("atr").value=ar.toFixed(2)+"Cm^2";
        }
        else if(b===c && b!==a){
            let ar=(a/4)*Math.sqrt(4*(b*b)-(a*a))
            let h= 2*(ar/a)
            document.getElementById("at").value=h.toFixed(2)+"Cm";
            document.getElementById("atr").value=ar.toFixed(2)+"Cm^2";   
        }
        else if(c===a && c!==b){
            let ar=(b/4)*Math.sqrt(4*(a*a)-(b*b))
            let h=2*(ar/b)
            document.getElementById("at").value=h.toFixed(2)+"Cm";
            document.getElementById("atr").value=ar.toFixed(2)+"Cm^2";   
        }
        document.getElementById("pt").value=p.toFixed(2)+"Cm";
        document.getElementById("tTriangulo").innerHTML="Es un triangulo isoceles"
     }
     // escaleno
     else if(a!==b!==c){
         let p=a+b+c;
         let s= p/2
         let ar= Math.sqrt(s*(s-a)*(s-b)*(s-c))
         let h= (2/c)*ar
         document.getElementById("at").value=h.toFixed(2)+"Cm";
         document.getElementById("atr").value=ar.toFixed(2)+"Cm^2";   
         document.getElementById("pt").value=p.toFixed(2)+"Cm";
         document.getElementById("tTriangulo").innerHTML="Es un triangulo escaleno"
     }    
}
// calculo de medidas del circulo
function circulo(){
    let d= document.getElementById("mc").value;
    let PI= Math.PI
    let expd= Math.pow(d,2)
    let r= d/2
    let expr= Math.pow(r,2)
    let a= PI*expr
    let p= PI*expd

    if(d>0){
        document.getElementById("rc").value=r.toFixed(2)+"Cm"
        document.getElementById("ac").value=a.toFixed(2)+"Cm^2"
        document.getElementById("pc").value=p.toFixed(2)+"Cm"
    }else{
        alert("inserte un numero valido")
    }
}

function calcAlturaTriangulo(){

// Aqui tomo los valores introducidos

const entrada1 = document.getElementById("inputTriangulo1");
const valor1 = entrada1.value;
const entrada2 = document.getElementById("inputTriangulo2");
const valor2 = entrada2.value;
const entrada3 = document.getElementById("inputTriangulo3");
const valor3 = entrada3.value;

//aqui verifico si es triangulo isoseles, se Hace el calculo y se muestra

if ((valor1>0 && valor2>0 && valor3>0 && (valor1/valor2)===1) ) {
    const altura = Math.sqrt((valor1*valor1)-((valor3*valor3)/4));
    alert("La altura del triangulo es: " + altura);
} else {
    alert("No es trangulo isoseles, por favor verifica");
}

}

Bajo la premisa de la formula para sacar la altura de un triángulo isósceles según la pagina:

function alturaTriangulo(ladoa,ladob,baset) {
const altura=Math.sqrt((ladoaladoa)-((basetbaset)/4));
if(ladoa=ladob && baset!=ladoa && baset!=ladob)
{
return alert("La altura del Triángulo Isóseles: "+altura);;
}else{
alert(“Lo que ingresaste no es un Triángulo Isóseles”);
}
}

De esta manera me quedo:

let calcularAltura = function(ladoT1, ladoT2, ladoTb){
    let ladoTriangulo1 = Number(ladoT1);
    let ladoTriangulo2 = Number(ladoT2);
    let baseTriangulo = Number(ladoTb);

    if(ladoTriangulo1 === ladoTriangulo2 && ladoTriangulo1 != baseTriangulo){
        let result = Math.sqrt(ladoTriangulo1 ** 2 - baseTriangulo ** 2 / 4);
        alert (`La altura es de ${result}`);
    }else {
        alert('Haz introducido algo mal');
    }
}

Reto:

  • Primero IDENTIFICO si hay igualdad en dos números (DE LO CONTRARIO SERÍAN ESCALENOS)

  • Luego veo si los lados iguales IDENTIFICADOS no son iguales al otro lado (DE LO CONTRARIO SERÍAN EQUILATEROS)

  • Luego miro si la suma de los dos lados iguales es mayor al lado diferente que sería la base, que puede ser lado1, lado2 o lado3 (DE LO CONTRARIO NO FORMARÍA UN TRIÁNGULO)

function alturaTriangulo (lado1, lado2, lado3) {
    if (lado1 == lado2 && lado1 != lado3) {

        const media = (lado3 / 2);
        altura = Math.sqrt((lado1 * lado1) - (media * media));

        if (lado1 + lado2 > lado3) console.log(altura);
        else console.log('No es un triángulo');

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

        const media = (lado2 / 2);
        altura = Math.sqrt((lado1 * lado1) - (media * media));

        if (lado1 + lado3 > lado2) console.log(altura);
        else console.log('No es un triángulo');

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

        const media = (lado2 / 2);
        altura = Math.sqrt((lado1 * lado1) - (media * media));
        
        if (lado2 + lado3 > lado1) console.log(altura);
        else console.log('No es un triángulo');

    } else {
        console.log('No es un triángulo isósceles');
    }
}

alturaTriangulo(8, 8, 10); //6.244997998398398

Hice esta función que valida cada uno de los tres triángulos según sus lados.
¡Espero les sirva!

function highIsocelesTriangle(side, secSide, base){
	if (side !== secSide) {
        console.log("Tu triangulo no es Isoceles");
	}
	else{
		let c=base/2;
		let high=Math.sqrt((c*c)+(side*side));
	    return high;
	}
	
}
highIsocelesTriangle(4, 4, 6);

Reto: Triangulo isósceles

function alturaTrianguloIsosceles(lado1, lado2, base){    
    //Formula = h = √ a^2 - ((b^2) / 4)
    if (lado1 != lado2) {
        return "Lado1 y Lado 2 deben de ser iguales";
    } else {
        const alturaTriangulo = Math.sqrt((lado1*lado1) - ((base*base)/4));
        return alturaTriangulo;
    }
}

Hago uso del método Math.pow para elevar dando como primer parámetro el número a elevar (base) y como segundo parámetro (despues de la coma) el exponente.
Ej: Math.pow(3,2) esto es 3 elevado a 2 lo que sería 9.

function isosceles(ladoA, ladoB, base){
    if (ladoA === ladoB){
        const altura = Math.sqrt( Math.pow(ladoA, 2) - (Math.pow(base/2, 2)) );
        return altura;
    }
    else{ return "No es un triangulo isósceles"};

}

console.log(isosceles(3,3,4));
const height = (sideA, sideB, base) => {
    if (sideA === sideB && sideA != base) {
        alert("Your triangle is isosceles!")
        const height = (Math.sqrt(sideB **2 ) - ((base/2) **2 ));
        console.log(height);
    }
    else {
        alert("Try it again, your triangle is not isosceles!")
    }
}

Así lo hice.

const raiz = Math.sqrt

function alturaIsosceles (lado1, lado2, base) {
    if (lado1 === lado2) {
        let resultado = raiz(((lado1 * lado2) - ((base/2) * (base/2))));
        alert(resultado);
    }
    else {
        alert("Los lados 1 y 2 no son iguales")
    }
}

Así me quedo el reto! 😄

const calcularAlturaIsosceles = () => {
    const lados = document.querySelectorAll('input.ladoTriangulo')
    
    if (lados[0].value != lados[1].value) 
        return alert(
            `La medida no corresponde a un tríangulo isósceles porque 
				${lados[0].value}cm es diferente a ${lados[1].value}cm`
        )

    const altura = Math.sqrt( (lados[0].value ** 2 ) - ( (lados[2].value / 2 ) ** 2) )

    return alert(`La altura tríangulo isósceles es: ${altura}cm`)
}

Así es como lo hice

const trianguloIsosceles = (ladoA, LadoB, Base) => {
    if(ladoA == LadoB && LadoB !== Base){
        let altura = Math.sqrt((Base / 2) **2 + ladoA **2).toFixed(2);
        console.log(`La altura de tu triángulo isósceles es: ${altura}`)
    }   
   else {
      console.log('No es un triángulo isósceles');
}
trianguloIsosceles(18, 18, 8)

//Console
  //La altura de tu triángulo isosceles es: 18.44
const validarAlturaTipoTriangulo = (a, b, c) => {
    const tipoTriangulos = ['Equilatero', 'Isósceles', 'Escaleno'];
    let valorTipo = 0; 
    let h = 0;
    if (a === b && a === c) {
        valorTipo = 0;
        h = Math.sqrt(3*a)/2;
    } else if ((a === b && a !== c) || (a === c && a !== b) || (b === c && a !== b)) {
        if (a === b) {
            h = Math.sqrt(Math.pow(a, 2) - (Math.pow(c, 2) / 4));
        } else if (a === c) {
            h = Math.sqrt(Math.pow(a, 2) - (Math.pow(b, 2) / 4));
        } else {
            h = Math.sqrt(Math.pow(b, 2) - (Math.pow(a, 2) / 4));
        }
        valorTipo = 1;
        
    } else {
        valorTipo = 2;
        h = (a * b)/ c;
    }
    const tipoTriangulo = tipoTriangulos[valorTipo];
    return { valorTipo, tipoTriangulo, altura: h.toFixed(2)};
}
function isoscelesTriangleHeight(side1, side2, side3) {
    if (side1 == side2 && side1 != side3) {
        const height = Math.sqrt((side1**2) - ((side3**2) / 4));
        return height;
    } if (side1 == side3 && side1 != side2) {
        const height = Math.sqrt((side1**2) - ((side2**2) / 4));
        return height;
    } if (side2 == side3 && side2 != side1) {
        const height = Math.sqrt((side2**2) - ((side1**2) / 4));
        return height;
    } else {
        return "Not an isosceles triangle"
    }
}

Ahi esta el mio(Acepto aportes hacia mi codigo)

function calculaTrianguloIsoceles(lado1,lado2,base){
     if(lado1===lado2 && lado1 != base){
         const altura = (Math.sqrt(lado1**2 -(base**2/4)))
         console.log("Es un triangulo isoceles y su altura es: "+altura)
     }else{
        console.log("los lados no son iguales")
     }
}

yo lo hice de la siguiente forma:

const alturaTriangulo = (lados, base)  => Math.sqrt(((Math.pow(lados, 2))-(Math.pow((base / 2),2))));

const validarTrianguloIsosceles = (ladoA, ladoB, base) =>{

    if((ladoA === ladoB) && ladoA  !== base) return console.log(`Es un trinagulo isósceles y su altura es: ${alturaTriangulo(ladoA, base).toFixed(2)}`);

    return console.log("No es un trinagullo Isósceles");
}

validarTrianguloIsosceles(6, 6, 8);

Buen dia campeones… Excelente reto,

la formula para calcular la altura,

const perimeterOfTheTriangle = (side1, side2, side3) => parseFloat(side1) + parseFloat(side2) + parseFloat(side3);
const triangleArea = (base, height) => (parseFloat(base) * parseFloat(height)) / 2;
const isoscelesHeight = (side1, side2, side3) => Math.sqrt(side1 * side2 - (side3 ** 2) / 4);

y asi me quedo…

// Calcular altura de un triángulo isóceles
// Dos lados iguales, uno desigual
// h = Raíz cuadrada de ( lado igual ^2 ) - (lado desigual^2 / 4)
function alturaTrianguilo(lado1, lado2, lado3){
    //Buscamos cuales son los lados iguales
    if(lado1 == lado2){
        const ladoIgual = lado1; 
        const ladoDesigual = lado3;
    }else if(lado1 == lado3){
        const ladoIgual = lado1;
        const ladoDesigual = lado2;
    }else{ //lado2 == lado3 
        const ladoIgual = lado2; 
        const ladoDesigual = lado1;
    }
    // Devolvemos el cálculo de la altura del triángulo
    return Math.sqrt(
        (ladoIgual * ladoIgual) - ((ladoDesigual * ladoDesigual) / 4)
    )

}

Así quedo el codigo del ejercicio:

function verificarIsosceles() {
    let lado = document.getElementById("ValorLado").value;
    let lado2 = document.getElementById("ValorLado2").value;
    let base = document.getElementById("base").value;
    if(lado == lado2) {
        let altura = Math.sqrt(lado * lado - Math.pow(base/2, 2));
        alert("la altura del triangulo es: " + altura)
    }
    else{
        alert("no es un triangulo isoceles");
    }
}

Yo lo realicé así:

function alturaIsosceles(lado1, lado2, base){
    if(lado1 == lado2){
        altura = Math.sqrt(Math.pow(lado1, 2)-(Math.pow(base,2)/4));
        return alert("la altura del triángulo isósceles es: " + altura);
    }else
    return alert("No es un triángulo isósceles");
} 

Así quedó mi código

let lados = []
function agregarMedidasIsosceles() {
    const input = document.getElementById('InputTrianguloIsosceles').value;
    lados.push(parseFloat(input));
    if (lados[2] > 0) {
        calcularIsosceles(lados[0], lados[1], lados[2]);
        calcularAltura(lados[0], lados[2]);
    }
}

function calcularIsosceles(lado1, lado2, base) {
    if (lado1 === lado2 && lado1 != base) {
        alert('Es isosceles');
    } else (console.log('No es isosceles, ingrese los lados nuevamente.'));
}

function calcularAltura(lado1, base) {
    let altura = Math.sqrt(lado1 ** 2 - ((base ** 2) / 4));
    console.log(`La altura del triangulo es ${altura}`);
}
function alturaIsoceles(lado1, lado2, base){
    return Math.sqrt((lado1 * lado1) - (base * base) / 4);
}

function isoceles(){
    const input1 = document.getElementById("ladoA");
    const value1 = Number(input1.value);
    const input2 = document.getElementById("ladoB");
    const value2 = Number(input2.value);
    const input3 = document.getElementById("baseIsoceles");
    const value3 = Number(input3.value);

    const altura = alturaIsoceles(value1, value2, value3);
    if(value1 != value2){
        alert("No es un triangulo isocles")
    }else{
        alert("La altura es de: "+ altura);
    }
} 

SPOILER ALERT creo que mi opción es menos espagueti:

// función para calcular altura. Noten que solo pido la altura de uno de los lados.
function alturaTrianguloIsoceles(lado,base){
    alturaA = (lado ** 2) - ((base / 2) ** 2)
    return Math.sqrt(alturaA);
}

// Función para llamar a la función matemática a partir de los inputs y hacer la validación (sólo se puede utilizar el boton "calcular altura triangulo isoceles" si ambos lados son iguales).
function calcularAlturaTrianguloIsoceles(){
    const inputT1 = document.getElementById("inputTriangulo1");
    const inputT2 = document.getElementById("inputTriangulo2");
    const inputTB = document.getElementById("inputTrianguloB");
    const valueT1 = inputT1.value;
    const valueT2 = inputT2.value;
    const valueTB = inputTB.value;
    if (valueT1 === valueT2){
        let resultado = alturaTrianguloIsoceles(valueT1,valueTB);
        alert(resultado)
    } else {
        alert("Los lados deben ser iguales para calcular un triángulo isoceles.");
    }
}

![](

Si a alguien se le hizo difícil entender la explicación, o razonamiento del profesor, dejaré cómo logré entenderlo por aquí

  1. Tenemos que tener en cuenta que tenemos un triángulo isósceles, que tiene dos lados iguales y uno diferente. No tenemos su altura. Pero sabemos que la mitad de esté tipo de triangulo, es un triángulo rectángulo y con este podemos obtener la altura.

Para eso revisamos el teorema de Pitágoras, en la que nos habla de que un triángulo rectángulo tiene un ángulo recto (90°) y dos ángulos menores (<90°). Y además, e importante para este ejercicio, los dos lados que forman el ángulo recto son catetos. El lado mayor opuesto al ángulo recto es la hipotenusa.

Entonces revisamos, nuestro triángulo rectángulo del ejercicio

Dónde h(Que sería la altura) y b son los catetos que forman el ángulo recto de (90°), y c es la hipotenusa. Por tanto, no tenemos que buscarla, pero podemos utilizar la fórmula de la hipotenusa para encontrar la altura que es nuestra incógnita.

Realizamos el despeje, y ya podemos usar entonces para calcular.
Entonces, tendríamos que el ladoA es la altura (h);
El lado base© es la hipotenusa, y el ladob(b) es la base.

Espero le sirva a alguien, y si me equivoqué por favor, coméntemelo.
Y aquí mi código,

<function alturaTS(lado1, lado2, base){
            if(lado1===lado2){
                alert("Es isosceles")}
                else{ alert("TIENE QUE SER ISOSCELES")}

            const hy = lado2;
            const ladob= base/2;
            let ladoa;
            
            ladoa = Math.sqrt((hy**2)-(ladob**2));
             altura = ladoa;
             return altura;
            }
        > 

Este es mi función.

function calcularAreaIso(lado1, lado2, lado3) {
    let a = 0;
    let b = 0;
    lado1 === lado2 ? ((a = lado1), (b = lado3)) : a;
    lado2 === lado3 ? ((a = lado2), (b = lado1)) : a;
    lado3 === lado1 ? ((a = lado3), (b = lado2)) : a;

    if (lado1 === lado2 || lado2 === lado3 || lado3 === lado1) {
        console.log("Es un triagulo Isoceles");
        console.log(b);
        let altura = Math.sqrt(a * a - (b / 2) * (b / 2));
        console.log(altura);
    } else {
        console.log("No es un triagulo Isoceles");
    }
}


function alturaTriangulo(a,b,c){
    if(a == b && a != c){
        return Math.sqrt(((a*b) - (c*c)/4))
    }else{
        alert("valores erroneos")
    }
    
}
alturaTriangulo()

Esta es mi solución…

function calcularAlturaTriangulo() {
    const lado1 = parseInt(document.getElementById("input-triangulo-lado1").value);
    const lado2 = parseInt(document.getElementById("input-triangulo-lado2").value);
    const base = parseInt(document.getElementById("input-triangulo-base").value);

    if (lado1===lado2) {
        const alto = alturaTriangulo(lado1,base);
        alert(alto);
    } else {
        alert("Por favor ingresa dos lados iguales");
    }
}

function alturaTriangulo (lado,base) {
    return Math.sqrt((lado * lado) - ((base * base) / 4));
}

function AlturaIsosceles(lado1,lado2,lado3){
if (lado1 === lado2 ) {
if(lado1!=lado3){
const base = lado3;
return altura = Math.sqrt((lado1lado2)-(base/2)(base/2));
}
}
if (lado1 === lado3){
if (lado1!=lado2){
const base =lado2;
return altura = Math.sqrt((lado1lado3)-(base/2)(base/2));
}
}
if (lado2 === lado3){
if (lado2!=lado1){
const base =lado1;
return altura = Math.sqrt((lado2lado3)-(base/2)(base/2));
}
}
else {
console.log(“No es triángulo isoscéles”);
}
};

Este es el resultado en consola

Hola, ya he terminado mi ejercicio.
https://github.com/Mark0Cano/JS_Figures.git
Aún quiero mejorar el diseño conforme vaya aprendiendo css :3.

No se si es más complicado esto… pero lo hice con lo que sé hasta el momento, es válido gente, denme sus opiniones por fa:

HTML

<form action="">
        <label for="lado1">
            Lado 1:
        </label>
        <input id="lado1" type="number"><p></p>
        <label for="lado1">
            Lado 2:
        </label>
        <input id="lado2" type="number"><p></p>
        <label for="lado1">
            Lado 3:
        </label>
        <input id="lado3" type="number"><p></p>
        <button type="button" onclick="alturaTriangulo()">Calcular Altura</button>
    </form>

JS

function alturaTriangulo(){
    const lado1 = document.getElementById("lado1").value;
    const lado2 = document.getElementById("lado2").value;
    const lado3 = document.getElementById("lado3").value;
    if(lado1 === lado2){
        var base = lado3;
        var ladoA = lado1;
        var ladoB = lado2;
        const alturaT = Math.sqrt((ladoA * ladoB)-((base * base)/4));
        alert(alturaT);
    
    }else if(lado2 === lado3){
        var base = lado1;
        var ladoA = lado2;
        var ladoB = lado3;
        const alturaT = Math.sqrt((ladoA * ladoB)-((base * base)/4));
        alert(alturaT);
    
    }else if(lado1 === lado3){
        var base = lado2;
        var ladoA = lado1;
        var ladoB = lado3;
        const alturaT = Math.sqrt((ladoA * ladoB)-((base * base)/4));
        alert(alturaT);
    } else {
        alert("No es un triángulo isósceles, por favor ingresa al menos 2 valores de lado iguales.");
    };
};

Mi respuesta 😄

function esIsoceles(lado1, lado2, lado3) {
    let isoceles = false;
    if (lado1 == lado2) {
        isoceles = true;
    } else if (lado2 == lado3) {
        isoceles = true;
    } else if (lado1 == lado3) {
        isoceles = true;
    }
    return isoceles;
}

function getBase(lado1, lado2, lado3) {
    let base = 0;
    if (lado1 == lado2) {
        base = lado3;
    } else if (lado2 == lado3){
        base = lado1;
    } else {
        base = lado2;
    }
    return base;
}

function alturaTrianguloIsoceles(lado1, lado2, lado3) {
    let altura = 0;
    let base = getBase(lado1, lado2, lado3);
    let catetoAd = base / 2;
    let hipotenusa = lado3;

    if (base != lado1) {
        hipotenusa = lado1;
    } else if (base != lado2){
        hipotenusa = lado2;
    }

    if (esIsoceles(lado1, lado2, lado3)) {
        altura = Math.sqrt((hipotenusa * hipotenusa) - (catetoAd * catetoAd));
    } else {
        console.log("No es isoceles")
    }
    return altura;
}

Mi página hasta el momento con cada calculadora 😁

.

Así me funciona =)

function trianguloIsoceles(ladoA, ladoB, base) {
    if((ladoA === ladoB) && (ladoA != base)){
        return Math.sqrt(ladoA**2 - (base / 2)**2)
    }  
}

function calcularTrianguloIsoceles() {
    const ladoA = parseInt(document.getElementById('dataA').value)
    const ladoB = parseInt(document.getElementById('dataB').value)
    const base = parseInt(document.getElementById('dataC').value)

    const altura = trianguloIsoceles(ladoA, ladoB, base);
    if(altura != undefined) {
        alert(altura);
    }else {
        alert('No es un triangulo isoceles')
    } 
}

function calcularAltura(lado1, lado2, base){
    if (lado1 === lado2 && lado1 != base) {
        alert("Es un triangulo isosceles");
    }
    else {
        alert("No es un triangulo isosceles")
    }
    const altura = Math.sqrt(lado1 ** 2 - base ** 2 / 4);
    return altura;
}

Taller #1

Creo que simplifique mucho las cosas, pero así me quedó. Lo que hice fue forzar un triángulo isósceles haciendo que el usuario solo pueda poner 2 valores, uno de los lados y la base, esto con la justificación de que los triángulos isósceles tienen 2 lados iguales y el otro es distinto que sería la base.

const measure = document.getElementById('measure')
const squareInput = document.getElementById('SquareInput')
const squareOutput = document.getElementById('SquareOutput')
const measure2 = document.getElementById('measure2')
const triangleInput1 = document.getElementById('TriangleInput1')
const triangleInput2 = document.getElementById('TriangleInput2')
const triangleOutput = document.getElementById('triangleOutput')
const measure3 = document.getElementById('measure3')
const circleInput = document.getElementById('circleInput')
const circleOutput = document.getElementById('circleOutput')



//Código del cuadrado
console.group('Squares')

function squarePerimeter (side) {
    return side * 4
}

function squareArea (side) {
    return side * side
}
console.groupEnd()

//Código del triángulo
console.group('Triángulos')

function trianglePerimeter (side1, base) {
    const perimeter = parseFloat(side1 * 2) + parseFloat(base)
    return perimeter
}

function triangleHeight(side1, base) {
    return Math.sqrt(side1 ** 2 - (base / 2) ** 2)
}

function triangleArea (side1, base) {
    const height = triangleHeight(side1, base)
    return (base * height) / 2
}

console.groupEnd()

console.group('Círculos')

//Radio
const circleRadio = 4

//Diámetro
function circleDiameter (radio) {
    return radio * 2
}

//PI
const PI = Math.PI

//Cicunferencia
function circlePerimeter (radio) {
    const diameter = circleDiameter(radio)
    return  diameter * PI 
}

//Área
function circleArea (radio) {
    return (radio * radio) * PI
}

console.groupEnd()

//Interacción con HTML

//SQUARE
function calcSquarePerimeter() {
    const value = squareInput.value

    const perimeter = squarePerimeter(value)
    squareOutput.innerHTML = (`El perímetro del cuadrado es: ${perimeter}${measure.value}`)
}

function calcSquareArea() {
    const value = squareInput.value

    const area = squareArea(value)
    squareOutput.innerHTML = (`El área del cuadrado es: ${area}${measure.value}<sup>2</sup>`)
}

//TRIANGLE
function calcTrianglePerimeter() {
    const value1 = triangleInput1.value
    const value2 = triangleInput2.value

    const perimeter = trianglePerimeter(value1, value2)
    if(value1 === value2) {
        triangleOutput.innerHTML = 'No es un triángulo isósceles'
    } else {
        triangleOutput.innerHTML = (`El perímetro del triángulo es: ${perimeter}${measure2.value}`)
    }
}
function calcTriangleArea() {
    const value1 = triangleInput1.value
    const value2 = triangleInput2.value

    const area = triangleArea(value1, value2).toFixed(2)
    if(value1 === value2) {
        triangleOutput.innerHTML = 'No es un triángulo isósceles'
    } else {
        triangleOutput.innerHTML = (`El área del triángulo es: ${area}  ${measure2.value}<sup>2</sup>`)
    }
}

//CIRCLE
function calcCirclePerimeter () {
    const value = circleInput.value

    const perimeter = circlePerimeter(value).toFixed(4)
    circleOutput.innerHTML = (`El perímetro del círculo es: ${perimeter}${measure3.value}`)
}
function calcCircleArea () {
    const value = circleInput.value

    const area = circleArea(value).toFixed(4)
    circleOutput.innerHTML = (`El área del círculo es: ${area}${measure3.value}<sup>2</sup>`)
}
function calcCircleDiameter () {
    const value = circleInput.value

    const diameter = circleDiameter(value)
    circleOutput.innerHTML = (`El diámetro del círculo es: ${diameter}${measure3.value}`)
}

El resultado del primer taller está en este link https://santiagobr.github.io/curso-practico-javascript/figuras.html y me demoré aprox 4 días dedicandole 3 a 4 horas por día. Quisé de una vez hacer todo el diseño que fue de las cosas que más tarde por cuadrar los media queries y otras cosas, pero me gusto como quedó.

La idea es ingresar las dimenciones de los lados en cuanquier orden. Funciona si hay al menos 2 lados iguales.


const calcularAlturaIso = (lado1, lado2, lado3) =>{
    let base = 0
    let lado
    if(lado1 * lado2 * lado3 <= 0){
        alert('Todos los lados deben tener una longitud mayor a 0.')
    } else {
        // Identificación de la base y comprovación de lados iguales.
        if(lado1 == lado2){
            base = lado3
            lado = lado1
        }else if(lado1 == lado3){
            base = lado2
            lado = lado1
        }else if(lado2 == lado3){
            base = lado1
            lado = lado2
        }
        // Validación de la base y longitud inferior a la suma de los lados restantes.
        if(base == 0 || base >= (lado * 2)){
            alert('¡Error! Un triángulo isosceles, tiene al menos dos lados iguales.')
        } else {
            alert(`La altura del triángulo isosceles es: ${Math.sqrt(Math.pow(lado, 2) + Math.pow((base/2), 2))}`)
        }
    }
}

Buen día Platzinautas.

En la función solo estoy conciderando la regla de que ambos lados tienen que ser iguales, aqui se podria agregar la proporción que estos deben tener, pero dejemos la clase de algebra para otro momento :S

function alturaTrianguloIsoceles(l1, l2, b){
    var height;

    if (l1==l2){
            height = Math.sqrt((l1^2) - ((b^2)/4));
    } else{
        height = 0;
        alert("The sides aren't equals, those measurements do not correspond to a  Isoceles Triangle")
    } 
    return height;

}
function DeterminarTriangulo(lado1, lado2, lado3) {
  // Determina si el primero es igual con algún otro
  if(lado1 === lado2 || lado1 === lado3) {
    if(lado1 === lado2 && lado1 != lado3) {
      alert('Es un triángulo isósceles')
      return calcularAlturaTriangulo(lado1, lado3)
    } else if(lado1 === lado3 && lado1 != lado2) {
      alert('Es un triángulo isósceles')
      return calcularAlturaTriangulo(lado1, lado2)
    }
  } else {
    alert('No es isósceles')
  }
}

function calcularAlturaTriangulo(lado, base) {
  return Math.sqrt(Math.pow(lado, 2) - Math.pow(base / 2, 2));
}

Reto terminado.

//Función que  calcula la altura cuando los lados son ingresados
function alturaIsoTriang(a,b,base) {
  if (a!=b) {
    console.error("Los lados a y b no son iguales");
    alert("Los lados a y b deben ser iguales. Intenta de nuevo");
  } else {
    return Math.sqrt((a*a)-((base*base)/4));
  }
}
//Función que interactúa con HTML
var h='';
function calcularAlturaTriangulo() {
  const inputL1 = document.getElementById("InputLado1");
  const valueL1 = inputL1.value;
  const inputL2 = document.getElementById("InputLado2");
  const valueL2 = inputL2.value;
  const inputB = document.getElementById("InputBase");
  const valueB = inputB.value;
  const altura = alturaIsoTriang(valueL1, valueL2, valueB);
  alert(altura.toFixed(4));
  h= altura;
}

Solución:

function trianguloIsoceles(lado1, lado2, base) {
  let a = lado1;
  let b = lado2;
  let c = base;
  if (a === b && a != base) {
    let d = c / 2;
    let p = Math.pow(b, 2);
    let o = Math.pow(d, 2);
    let h = p - o;
    let u = Math.sqrt(h);
    alert(u);
  } else {
    alert("NO es un triangulo isóceles");
  }
}

trianguloIsoceles(5, 5, 8);