25

#PlatziCodingChallenge Dia 2 - Área de un triángulo

¿Recuerdas tus clases de Geometría?

Es momento de poner ese conocimiento a la práctica. El área de un triángulo se describe de la siguiente manera: A = (b * h) / 2 .

El reto del día de hoy es escribir un programa que tome la base y la altura como parámetros y calcule el área del triángulo. Bonus: El programa debe determinar si el triángulo es isósceles, equilátero o escaleno.

Escribe tu comentario
+ 2
Ordenar por:
5
5725Puntos

En Python ingresando medidas de cada lado:

defcalcula_area(lado1, lado2, lado3):
    area_calculada = (lado1 + lado2 + lado3)/2return area_calculada

defcompara_triangulo(lado1, lado2, lado3):
    lista = [lado1, lado2, lado3]
    contador = 0
    comparador = lado1
    for elemento in lista:
        if comparador == elemento:
            contador += 1if lado1 != lado2 and lado2 == lado3:
        contador +=1if contador == 3:
        print('Triangulo equilatero')
    elif contador == 2:
        print('Triangulo isoseles')
    if contador == 1:
        print('Triangulo escaleno')

defrun():
    lado1 = int(input('Ingresa la longitud del primer lado del triangulo: '))
    lado2 = int(input('Ingresa la longitud del segundo lado del triangulo: '))
    lado3 = int(input('Ingresa la longitud del tercer lado del triangulo: '))
    area = calcula_area(lado1, lado2, lado3)
    print('El area del triangulo es: ' + str(area))
    compara_triangulo(lado1, lado2, lado3)
    

if __name__ == "__main__":
    run()
1
17784Puntos
8 meses

Es que los inputs debían ser base y altura, a mi no me salio :’(

1
16088Puntos
6 meses

Hola!

Me parece que estás calculando el semiperimetro de un triangulo escaleno y no el area.

1
4719Puntos
6 días

A pesar del pequeño detalle de que la formula esta mal, me encanto la forma de condicionar los ciclos del for.

4
562Puntos

Reto día 2 completado ✅

escrito en JavaScript

var base = parseInt(prompt("¿cual es la base del triangulo?"));
var altura = parseInt(prompt("¿cual es la atura del triangulo?"));
var lado_a = parseInt(prompt("cual es la medida del lado a"));
var lado_b = parseInt(prompt("cual es la medida del lado b"));
var tipo_de_triangulo;
var area;

// edta  funcion halla el area del triangulofunctionareaCalculator () {
  area = base * altura / 2;
  document.write("El area de triagulo es: " + area + "<br />");
}

functiontypeCalculator () {
  if (lado_a == lado_b && lado_b == base) {
    tipo_de_triangulo = "Equilatero";
    document.write("El tipo de triangulo es: " + tipo_de_triangulo);
  }
  elseif (lado_a == lado_b && lado_b !== base) {
    tipo_de_triangulo = "Isosceles";
    document.write("El tipo de triangulo es: " + tipo_de_triangulo);
  }
  else {
    tipo_de_triangulo = "Escaleno";
    document.write("El tipo de triagulo es: " + tipo_de_triangulo);
  }
}
areaCalculator();
typeCalculator();
4
10650Puntos

Mi codigo en C++

#include<iostream>usingnamespacestd;

 intmain(){
     cout << "Area de un triangulo"<<endl<<endl;
    int b,a,h,l,l1;

    cout<<"Escribe la base de tu triangulo ";
    cin>>b;
    cout<<"Dame a altura del triangulo ";
    cin >> h;
    cout<<"Dame cuanto mide el lado derecho ";
    cin>>l;
    cout<<"Ahora escribe cuanto mide el lado izquierdo ";
    cin >> l1;

    a= (b*h)/2;

    cout<<"El area de tu triangulo es de "<<a<<endl;

    if (b==l1 && l1==l)
    {
        cout<<"Tu trianguilo es Equilatero :D"<<endl;
     }
    elseif (l1==l || l==b || b==l1)
    {
        cout<<"Tu triangulo es Isoceles :D "<<endl;
    }
    else 
    {
        cout<< " Tu triangulo es Escaleno :D " <<endl;
    }
    return0;
 }```
4
55577Puntos

Python in da house 😄

defrun():

    base = int(input("What's the base of your triangle? "))
    height = int(input("What's the height of your triangle? "))
    triangle_area = (base * height) / 2if base == height:
        print("Your triangle is equilateral")
    else:
        print("Your triangle is isosceles")
    print("and it's area is " + str(triangle_area)) 

if __name__ == '__main__':
    run()
1
6461Puntos
7 meses

Que la base sea igual a la altura no significa que sea equilátero, la última parte es complicada solamente conociento b y h 😕

2
10269Puntos
7 meses

Yo busqué un poco para saber en base al área cómo se sacaría si es equilatero. Claro, si la altura supera o disminuye cierto límite es iscóseles. Pero no encontré cómo sacar si es escaleno sin que el usuario ingrese el valor de los lados. Me parece imposible, sino que alguien me explique.

Yo hice esto:

functionArea(b, h) {
    let A = (b * h) / 2console.log(A)
    let tiposTriangulos = (b, h) => {
        let Promedio = (h * 100) / b
        if (floor(Promedio) == 86) {
            console.log('El Triángulo es Equilatero')
        } else {
            console.log('El triángulo es Iscóseles')
        }
    }
    tiposTriangulos(b, h)
}

Porque si el promedio de la base y la altura es igual a floor(86,67) entonces se puede saber, pero no Equilatero.

4
3631Puntos

Vi un poco tarde el reto pero igual cuenta jaja, esta escrito en python.

Captura de pantalla (37).png
Captura de pantalla (41).png
Captura de pantalla (39).png

3
4009Puntos

Lo logré, con la ayuda de un compañero pero lo logré. Gracias al compañero Cristhian Castro, aquí va mi solución, está hecha con **html **y javascript: (Nota, el mío no tiene el bonus del tipo de triángulo)

<!--HTML5--><!DOCTYPE html><htmllang="es"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Document</title></head><body><h1>Comprueba/calcula el área de un triángulo</h1><section><p><inputtype="text"id="base">Ingresa la base (b)</p><p><inputtype="text"id="altura">Ingresa la altura (h)</p><p><inputtype="submit"value="CALCULAR"id="enviar"></p></section><scriptsrc="pruebaarea.js"></script></body></html>
/*Javascript*/var boton = document.getElementById("enviar");
boton.addEventListener("click", areaCalc);

functionareaCalc () 
{
    var b = document.getElementById("base");
    var h = document.getElementById("altura");
    var entero_base = parseInt(b.value,10);
    var entero_altura = parseInt(h.value,10);
    var area = parseInt((entero_base*entero_altura)/2)
    alert("El area de tu triángulo es " + area);
}


1
24108Puntos
7 meses

Buen resultado, poco a poco lo lograras completar con el bonus.

3
11824Puntos

No encontre una forma de buscar el tipo de un triángulo con solo la base y su altura por ello se pide un lado para poder definirlo

staticvoid Main() {
    Console.Write("Digite Base del Triangulo: ");
    float baseTriangulo= float.Parse(Console.ReadLine());
    
    Console.Write("Digite Altura del Triangulo: ");
    float alturaTriangulo= float.Parse(Console.ReadLine());
    
    float unLado=0;
    Console.Write("Desea conocer el typo de Triangulo, ");
    Console.Write("Digite el valor de un lado (no la base), si no digite 0: ");
    unLado= float.Parse(Console.ReadLine());
    
    while(unLado !=0 && unLado<alturaTriangulo){
        Console.WriteLine("si no desea saber el typo digite 0: ");
        Console.Write("El valor de un lado no puede ser menor a "+
                        alturaTriangulo+"(altura):  ");
                        
        unLado= float.Parse(Console.ReadLine());
    }
    //Console.Clear();float area = CalcularAreaTriangulo(baseTriangulo, alturaTriangulo);
    
    if(unLado !=0){
        float elOtroLado=getLadoFaltante(baseTriangulo, alturaTriangulo, unLado);
        
        Console.WriteLine("{0,12}{1,6}{2,8}{3,6}{4,6}{5,6}",
                        "Tipo", "Area", "Altura",
                        "Base", "Lado1", "Lado2");
        Console.WriteLine("{0,12}{1,6}{2,8}{3,6}{4,6}{5,6}",
                        TipoTriangulo(baseTriangulo, elOtroLado, unLado),
                        area, alturaTriangulo, baseTriangulo, unLado,
                        elOtroLado);
    }else{
     Console.WriteLine("{0,6}{1,8}{2,6}",
                        "Area", "Altura","Base");
     Console.WriteLine("{0,6}{1,8}{2,6}",
                        area, alturaTriangulo, baseTriangulo);
    }
    
  }
  
  staticfloat getLadoFaltante(float baseTriangulo, float alturaTriangulo, float lado){
      double baseTrianguloRectangulo = Math.Sqrt(Math.Pow(lado,2)
                                        -Math.Pow(alturaTriangulo,2));
      if(baseTrianguloRectangulo==baseTriangulo){
          return alturaTriangulo;
      }else{
          return (float)Math.Round(Math.Sqrt(Math.Pow(alturaTriangulo,2)+
                                                Math.Pow((baseTriangulo-baseTrianguloRectangulo),
                                                        2)),
                                            1);
      }
  }
  
  staticString TipoTriangulo(float baseTriangulo, float lado1, float lado2){
      if(baseTriangulo == lado1 && baseTriangulo == lado2 && lado2 == lado1){
          return"Equilátero";
      }elseif(baseTriangulo != lado1 && baseTriangulo != lado2 && lado2 != lado1){
          return"Escaleno";
      }else{
          return"Isósceles";
      }
  }
  
  staticfloat CalcularAreaTriangulo(float baseTriangulo, float alturaTriangulo){
      return (baseTriangulo*alturaTriangulo)/2;
  }

Codigo en onlinegdb

Resultados
Resultados posibles

3
2235Puntos

Apenas estoy aprendiendo. Escrito en Python:

base = float(input('Escribe la base del triangulo: '))
altura = float(input("Escribe la altura del triangulo: "))
lado1 = float(input("Escribe un lado del triangulo: "))
lado2 = float(input("Escribe el otro lado del triangulo: "))
area = (base*altura)/2
print('El area del triangulo es: ' + str(area))

defdeterminarTriangulo():if lado1==base==lado2 : 
        print("Es un triángulo Equilatero.")
    elif lado1==lado2 or lado1==base or base==lado2 :
        print("Es un triángulo Isosceles.")
    elif lado1!=lado2 and lado1!=lado2 and base!=lado2 :
        print("Es un triángulo Escaleno.")

determinarTriangulo()
2
3999Puntos

Python

defmain():

    base = int(input("¿Cual es la base de tu triangulo? "))
    altura = int(input("¿cual es la altura de tu triangulo? "))
    area_triangulo = (base * altura) / 2if base == altura:
        print("Tu triangulo es equilátero")
    else:
        print("Tu triangulo es isosceles")
    print("Su area es  " + str(triangle_area)) 

if __name__ == '__main__':
    main()```
2
7078Puntos

El area de un triangulo en c++

#include<iostream>usingnamespacestd;

intmain(){
    int Altura = 0, Base = 0, Area;

    cout << "Calcula el area de un triangulo" << endl;
    cout << "Ingrese la altura: ";
    cin >> Altura;
    cout << "Ingrese la base: ";
    cin >> Base;

    Area = (Base * Altura) / 2;

    cout << "El area del triangulo es: " << Area << endl;

    if()
    return0;
}
2
17607Puntos

Compañeros aca les comparto mi reto del dia 2. Debo confesarles que lo del Bonus estuvo rudo, porque lo pense que se debia determinar a traves de la altura y la base, asi que tuve que leer teorias y crear una logica, debo decirles que no se que tan acertada es mi teoria, pero si llegue al resultado en base a una logica que aca les comparto.

2
17607Puntos
2 meses

Tome en consideración las siguientes teorías para determinar mi resultado
1.- Equilátero: todos sus lados son iguales
2.- Isósceles: Sus hipotenusas son iguales (Tiene 2 lados iguales)
3.- Todos sus lados son distintos.

Primero para determinar el equilátero calculo la hipotenusa:
(altura ^ 2) + (base % 2) ^ 2 = hipotenusa, de acá determino que si la hipotenusa es igual a la base, entonces es equilátero.

En caso contrario verifico si es isósceles de la siguiente manera, hago la suposición que la hipotenusa es igual a ambos lados (eso es lo que entendí de la teoría de los triángulos isósceles) y calculo el área a través de la formula de Heron que permite calcularla a través de sus lados, esto lo hago para tener un dato que me permita comparar, a través de esto llego a la conclusión que si el área calculada con la formula de Heron es igual al área calculada (b * h) / 2 entonces es isósceles.

y por ultimo sino cumple ni la primera ni la segunda condición determino que es escaleno.

Espero su feedback, si mis consideración están correctas o equivocadas, de igual forma les comparto el código.

2
17607Puntos
2 meses
<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8" /><metaname="viewport"content="width=device-width, initial-scale=1.0" /><title>Reto 2: Área de un Triángulo</title></head><body><labelfor="b">Ingrese Base</label><inputid="b"type="number"placeholder="Ingrese la base"name="b"value="0"
		/><labelfor="h">Ingrese Altura</label><inputid="h"type="number"placeholder="Ingrese la altura"name="h"value="0"
		/><buttontype="button"onclick="handleArea();">Calcular Area</button><h1id="area"></h1><h2id="tipo"></h2><script>
			alert("Bienvenido al Reto 2: Área de un Triángulo");
			functionhandleArea() {
				//debugger;let b = Number(document.getElementById("b").value);
				let h = Number(document.getElementById("h").value);
				let print1 = document.getElementById("area");
				let print2 = document.getElementById("tipo");
				console.log(b);
				console.log(h);

				let area = Number((b * h) / 2).toFixed(2);
				console.log("area", area);
				let hipotenusa = Number(
					Math.sqrt(Math.pow(h, 2) + Math.pow(b / 2, 2))
				).toFixed(2);
				console.log("hipotenusa", hipotenusa);
				print1.innerHTML = `El area es ${area}`;

				/*La teoria indica que un triangulo equilatero tiene todos sus lados iguales, 
				por ende al calcular hipotenusa que seria uno de sus lados y compararlo con 
				la base que otros de sus lados concluimos que es equilatero*/if (Math.floor(b) === Math.floor(hipotenusa))
					print2.innerHTML = "El triangulo es equilátero ";
				else {
					/*En caso contrario verificamos si es isosceles, 
					la teoria indica que tiene 2 lados iguales, 
					por ende concluimos que sus dos lados (hipotenusas serian igual).
					Teniendo esto en cuenta calculo el area segun la formula de heron,
					la que permite calcular el area usando sus lados.
					Luego de calcular el area la comparo con la original, 
					si son identicas entonces es isosceles, sino es escaleno, que segun 
					la teoria, todos sus lados son distintos.
					Nota: no puedo asegurar que mi logica es correcta totalmente, 
					pero mediante esta logica logre conseguir los resultados.
					*/let p = 2 * hipotenusa + b;
					console.log("perimetro", p);
					let s = Number(p / 2).toFixed(2);
					console.log(s);
					let area2 = Number(
						Math.sqrt(s * Math.pow(s - hipotenusa, 2) * (s - b))
					).toFixed(2);
					console.log("area 2", area2);
					let result = area > area2 ? area - area2 : area2 - area;
					if (result <= 0.1) {
						console.log("entro aqui");
						print2.innerHTML = "El triangulo es isósceles";
					} else {
						console.log("entro aca");
						print2.innerHTML = "El triangulo es escaleno";
					}
				}
			}
		</script></body></html>
2
2518Puntos
alert("Para definir el area de tu triangulo y tipo de triangulo, \n ingresa las medidas de los lados de tu triangulo \n ")
let a = parseInt(prompt("lado a"))
let b = parseInt(prompt("lado b"))
let c = parseInt(prompt("lado b"))

let s = (a + b + c) / 2let area = Math.sqrt( s * (s - a) * (s - b) * (s - c))

console.log(s)
console.log(area)

    if ( a == b && b == c && a == c){
        console.log("los tres lados son iguales, tu triangulo es un equilatero")
    }elseif (a !== b && b !== c &&  a !== c ){
        console.log("los tres lados son diferentes, tu triangulo es un escaleno")
    } else   {
        console.log("2 lados son iguales y 1 diferente, tu triangulo es un equilatero")
    }```
2
2047Puntos

lo hice en JS

varbase = parseInt(prompt("¿Cual es su base?"));
var altura = parseInt(prompt("¿Cual es su altura?"));
var tipo;

  if(base == altura)
  {
    tipo = "equilatero";
  }
  elseif(base < altura)
  {
    tipo = "isoceles";
  }
  else
  {
      tipo = "escaleno";
  }

var area = (base * altura) / 2;
document.write("Tu triangulo es un " + tipo + " de area " + area);
2
560Puntos

HTML

<!DOCTYPE html><html><head><metacharset = "utf-8" /><title>Platzi Coding #2</title></head><body><h1>Área de un triángulo y su tipo</h1><p><imgsrc = "TriánguloysusMedidas.png" /></p><p>¿Cuál es la base del Triángulo?</p><inputtype= "number" value = "0" id = "textoBase" /><br /><p>¿Cuál es la altura del Triángulo?</p><inputtype= "number" value = "0" id = "textoAltura" /><br /><p>¿Cuánto mide el lado derecho del Triángulo?</p><inputtype= "number" value = "0" id = "textoLadoDer" /><br /><p>¿Cuánto mide el lado izquierdo del triángulo?</p><inputtype= "number" value = "0" id = "textoLadoIzq" /><br /><br /><inputtype= "button" value = "Obtener áreaytipo" id = "botoncito" /><pid = "resultado"></p><scriptsrc = "Challenge2.js"></script></body></html>

JS

botoncito.addEventListener("click", functionareaDeTriangulo(){

	var b = parseInt(textoBase.value);
	var h = parseInt(textoAltura.value);
	var ladoDer = parseInt(textoLadoDer.value);
	var ladoIzq = parseInt(textoLadoIzq.value);

	var area = parseFloat((b * h) / 2);

	resultado.innerHTML += "El área del triángulo es de: " + area + "<br />";

	tipoDeTriangulo(b, ladoDer, ladoIzq);
});

functiontipoDeTriangulo(b, ladoDer, ladoIzq){

	if(b === 0 && ladoDer === 0 && ladoIzq === 0){
		resultado.innerHTML += "" + "<hr />";
	}elseif(b === ladoDer && b === ladoIzq && ladoDer === ladoIzq){
		resultado.innerHTML += "<br />El triángulo es Equilátero" + "<br />" + "<hr />";
	}elseif(b === ladoDer || b === ladoIzq || ladoDer === ladoIzq){
		resultado.innerHTML += "<br />El triángulo es Isóceles" + "<br />" + "<hr />";
	}elseif(b != ladoDer && b != ladoIzq && ladoDer != ladoIzq){ 
		resultado.innerHTML += "<br />El triángulo es Escaleno" + "<br />" + "<hr />";
	}
}
Interfaz.png
2
4607Puntos

C++
Solo con lados

#include<iostream>#include<math.h>usingnamespacestd;

intmain(){
	float lado1, lado2, lado3, A, SP ;
	
	cout <<"Clasificacion y area de un triangulo segun sus lados" << endl << endl;
	
	cout << "Dame la medida del primer lado  ";
	cin >> lado1;
	cout << "Dame la medida del segundo lado  ";
	cin >> lado2;
	cout << "Dame la medida del tercer lado  ";
	cin >> lado3;
	
	cout << endl;
	
	
	SP=(lado1+lado2+lado3) / 2;
	A = sqrt(SP*(SP-lado1)*(SP-lado2)*(SP-lado3));
	
	
	if (lado1==lado2 && lado2==lado3)
    {
        cout<<"El trianguilo es equilatero"<<endl;
    }
    elseif (lado1==lado2 || lado2==lado3 || lado1==lado3)
    {
        cout<<"El triangulo es isoceles "<<endl;
    }
    else 
    {
        cout<< "El triangulo es escaleno " <<endl;
	}
	
	cout << endl;
	cout << "Ademas, su area es " << A ;
	
	return0;
}
2
10650Puntos
8 meses

Muy buen codigo utilizando otra tecnica que chido

1
16247Puntos
let b = 15let h = 15let area = (b * h) / 2console.log(`Dada la base: ${b} y la altura: ${h} de un triangulo su area es: ${area}`)

// si es es escaleno A = (b*h)/2let ladoA = 3let ladoB = 3let ladoC = 3console.log(`Dados los lados ${ladoA}, ${ladoB} y ${ladoC}`)
functiontypeOfTriangle (a, b, c) {
    if(a == b){
        if(c == b) {
            console.log('Es equilatero')
        }else {
            console.log('Es isoceles')
        }
    }elseif (c == a || c == b) {
        console.log('Es isoceles')
    }else {
        console.log('Es un triangulo escaleno')
    }
}
typeOfTriangle(ladoC, ladoB, ladoC)
1
9521Puntos

Mi código en python

2020-07-08 13_57_47-Window.png)

1
12527Puntos
function  triangleArea(b, a){
   return b*a /2 

}

constresult = triangleArea(2, 4)

console.log(result)
1
16004Puntos

Buen dia apenas iniciando el reto, realizado con JavaScript:

let button = document.querySelector("button");
let area_result = document.getElementById("area_result");
let tipo_triangulo = document.getElementById("tipo_triangulo")

const area_triangulo = (base, altura) => (base*altura)/2;

const calcular_triangulo = (lado_derecho,lado_izquierdo,base) => {
    if(lado_derecho==lado_izquierdo && lado_izquierdo==base)
        return"Triangulo equilatero"if(lado_derecho==lado_izquierdo || lado_derecho== base || lado_izquierdo==base)
        return"Triangulo Isosceles"return"Triangulo Escaleno"
};

const calcular = (e) => {
    e.preventDefault();
    letbase = document.getElementById("base").value;
    let altura = document.getElementById("altura").value;
    let lado_izquierdo = document.getElementById("lado_izquierdo").value;
    let lado_derecho = document.getElementById("lado_derecho").value;    

    const calcular_area = area_triangulo(base,altura);
    const calcular_tipo_triangulo = calcular_triangulo(lado_derecho,lado_izquierdo,base);
    area_result.innerHTML = `El area del triangulo es: ${calcular_area}`;
    tipo_triangulo.innerHTML = `El triangulo es: ${calcular_tipo_triangulo}`
}

button.addEventListener('click', calcular)
1
2088Puntos

Mi aporte al reto de los triángulos, escrito en python (recien aprendiendo)
triangulos.png

1
4801Puntos

El área de un triángulo en C

#include <stdio.h>

/**

  • main: imprime el área de un triángulo
  • Return: (0)

*/

int main(void)
{

int b = 0, h = 0, area;

printf("Introduzca la base: ");
scanf("%d", &b);

printf("Introduzca la altura: ");
scanf("%d", &h);

area = (b * h) / 2;
printf("El área del triangulo es: %d m2\n", area);

return(0);

}

1
39913Puntos
letbase = prompt('¿Cual es la base de tu triangulo?')
  let altura = prompt('¿Cual es la altura de tu triangulo?')
  let area = base * altura / 2
  alert(`El área de tu triangulo es de ${area}`)
1
4372Puntos

Python

defArea(h,b):
    print(f'The area of a triangle is ½ (b × h) : {(b*h)/2}')

if __name__ == "__main__":
    h = int(input("Height of the triangle : "))
    b = int(input("Base of the triangle : "))
    area = Area(h,b)```
1
1313Puntos
<?php
    function getTriangleArea($base, $height) {
        return ($base * $height) * 0.5;
    }

    // prueba is
    $b = 4;
    $h = 6;

    echo "El area del triángulo es: ". getTriangleArea($b, $h);
?>```
1
17784Puntos

Hice mi programa con el supuesto que son triangulos rectángulos, por que sino la base y altura no son suficientes para determinar el tipo de triangulo, se necesitaría un angulo o un lado.

import math

defcalcular_area_triangulo(base, altura):
    area = (base * altura) / 2return round(area, 1)

defobtener_tipo_triangulo(base, altura, area):if (area == obtener_area_equilatero(base)):
        return"Equilatero"elif (base == altura):
        return"Isosceles"else:
        return'Escaleno'defobtener_area_equilatero(base):
    area = ((base ** 2) * math.sqrt(3)) / 4return round(area, 1)

base = float(input('Base: '))
altura = float(input('Altura: '))
area = calcular_area_triangulo(base, altura)
tipo = obtener_tipo_triangulo(base, altura, area)
print(f'El area es = {area}')
print(f'El tipo es = {tipo}')

1
5135Puntos

Solo supe como saber con base y altura si era equilátero. No pude saber cómo diferenciar entre escaleno e isósceles (sé que el isósceles tiene dos lados iguales y el escaleno los tres lados son distintos); Sin embargo, según yo no basta con saber solo la base y la altura para saberlo, mínimo necesitaríamos saber algún dato adicional.

1
9764Puntos

Javascript

var getArea = (args) => {
    let A = (args.B * args.H) * .5;
    let Hip  = Math.sqrt( (args.B ** 2) + (args.H ** 2) );
    let K = '';

    if (args.B == args.H  && args.B == Hip && args.H == Hip) {
        K = 'Equilátero';
    }elseif (args.B != args.H && args.B != Hip && args.H != Hip) {
        K = 'Escaleno'
    }else{
        K = 'Isósceles'
    }

    return `El área es ${A}, el tipo de triángulo es ${K} y su hipotenusa es ${Hip}`;
}

getArea({B:12, H:25});

1
4031Puntos

aqui esta mi version, en c++.

usingnamespacestd;

intmain(){

    cout << "Hola, me podrias decir la base de tu triangulo por favor?" << endl;
    int base = 0;
    cin >> base ;
    cout << "ahora la altura por favor" << endl;
    int altura = 0;
    cin >> altura;
    cout << "ahora dime otro de los lados de tu triangulo"<< endl;
    int ladoB = 0;
    cin >> ladoB;
    cout << "ahora el ultimo lado" << endl;
    int ladoC = 0;
    cin >> ladoC;
    int area = (base*altura)/2;
    cout << "el area de tu triangulo es de "<< area << endl;
    if (base == ladoB == ladoC)
    {
    cout<< "tu triangulo es equilatero"<<endl;
    }
    if (base == ladoB != ladoC)
    {
    cout <<"tu triangulo es isoceles"<< endl;
    }
    if (base == ladoC != ladoB)
    {
    cout <<"tu triangulo es isoceles"<< endl;
    }
    if (ladoB == ladoC != base)
    {
    cout <<"tu triangulo es isoceles"<< endl;
    }
    else
    {
    cout << "tu triangulo es escaleno"<< endl;
    }
    return0;
}

1
425Puntos
function triangulo(){

letaltura = parseFloat(prompt("Ingrese la altura del triangulo: "));
    letbase = parseFloat(prompt("Ingrese la base del triangulo: "));
    letarea = (base * altura)/2;

    alert("El Area del tringulo es: " + area);

    letlado1 = prompt("Ingrese el primer lado del triangulo: ");
    letlado2 = prompt("Ingrese el segundo lado del triangulo: ");
    letlado3 = prompt("Ingrese el tercer lado del triangulo: ");

    if(lado1 == lado2 && lado2 == lado3 ){
        alert("El triangulo es equilatero")
    }
    elseif(lado1 == lado2 || lado2 == lado3 || lado3 == lado1 ){
        alert("El triangulo es isosceles");
    }
    else{
        alert("El triangulo es escaleno");
    }
}

triangulo();

Aquí va el reto en Javascript

1
266Puntos

C

/* Day #2 | Program: Area of a Triangle */#include<stdio.h>#include<conio.h>intmain(){
	float t_area, height, base;
	
	printf("Program: Area of a Triangle\n");
	
	printf("\nIntroduce the base of the triangle (m): ");
	scanf("%f", &base);
	
	printf("\nIntroduce the height of the triangle (m): ");
	scanf("%f", &height);
	
	t_area=(height*base)/2;
	printf("\nThe area of the triangle is: %.2f meters", t_area);

	getch();
	return0;
}
1
9298Puntos

Solo puede calcular el área, para sacar el tipo de triangulo a partir de la base, la altura y el área no se me ocurre, es necesario un angulo o, a su caso, un cateto mas:

alert('Vamos a calcular el aerea de un triangulo')

let base = parseInt(prompt('Base del triangulo'))
let altura = parseInt(prompt('Altura del triangulo'))

let resultado = (base * altura) / 2

alert(`El area del triangulo es ${resultado}`)
1
4834Puntos

JS

const lado1 = 3;
const lado2 = 3;
const lado3 = 4;

area = (a, b, c) => {
    //Semiperimetroconst s = (a+b+c)/2;
    //Formula de HerónreturnMath.sqrt(s*(s-a)*(s-b)*(s-c)).toFixed(2);
}

tipoTriangulo = (lado1, lado2, lado3) => {
    if(lado1 === lado2 && lado2 === lado3){
        return"Es un triángulo Equilatero"
    }elseif(lado1 != lado2 && lado2 !== lado3){
        return"Es un triángulo Escaleno"
    }else{
        return"Es un triángulo Isoceles"
    }
}

console.log(area(lado1, lado2, lado3));
console.log(tipoTriangulo(lado1, lado2, lado3))
1
439Puntos

C++

<code>
#include<iostream>#include<conio.h>#include<math.h>usingnamespacestd;

intmain(){
	float base, altura, area;

	cout<<"===== Calcular Area de un Triangulo ====="<<endl;
	cout<<"ingrese la base: ";
	cin>>base;
	cout<<"ingrese la altura: ";
	cin>>altura;
	
	area = (base*altura)/2;
	
	cout<<"El area del triangulo es: "<<area<<endl;
	
	if(base==altura){
		cout<<"el triangulo es isoceles"<<endl;
	}
	elseif(base== sqrt(pow(base/2,2)+pow(altura,2))){
		cout<<"el triangulo es equilatero"<<endl;
	}
	else{
		cout<<"el triangulo es escaleno"<<endl;
	}
}
1
13595Puntos

Codigo en una funcion de JS.

functiontriangleArea(sideA, sideB, base) {
  let area = 0;

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

    console.log("Triangulo Isósceles.");
    return`Area: ${area}`;
  } elseif (sideA !== sideB && sideB !== base) {
    let s = (sideA + sideB + base) / 2;
    area = Math.sqrt(s * ((s - sideA) * (s - sideB) * (s - base)));

    console.log("Triangulo Escaleno.");
    return`Area: ${area}`;
  } else {
    area = (Math.sqrt(3) / 4) * (sideA * sideA);

    console.log("Triangulo Equilatero.");
    return`Area: ${area}`;
  }
}
1
2714Puntos

class Triangulo:

def __init__(self, base, altura):
    self.base = base
    self.altura = altura

def area(self):
    return self.base * self.altura / 2

if name == ‘main’:
triangulo = (Triangulo(base=3, altura=4))
print("El area del Triangulo es: " + str(triangulo.area()))

1
2714Puntos
classTriangulo:def__init__(self, base, altura):
        self.base = base
        self.altura = altura

    defarea(self):return self.base * self.altura / 2if __name__ == '__main__': 
    triangulo = (Triangulo(base=3, altura=4))
    print("El area del Triangulo es: " + str(triangulo.area()))

1
3213Puntos

let b = prompt("Dime la base= ");
let h = prompt(“Dime la altura=”);
let A = (b*h)/2;
console.log(La respuesta es: ${A});

1
13234Puntos
defrun(base, altura):
    area = (base * altura)/2if base == altura:
        print('El triangulo es Equilatero')
    elif base < altura:
        print('El triángulo es isóceles')
    else:
        print('El triángulo es escaleno')
    print(area)



if __name__ == '__main__':
    run(8, 6)```
1
12398Puntos

Hecho en JavaScript.

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Area</title></head><body><h2>Cálculo del área de un triangulo</h2><p>
        Ingrese la base (lado B):
        <inputtype="number"id="base"><br>
        Ingrese la altura:
        <inputtype="number"name="altura"id="altura"><br>
        Ingrese el lado A del triángulo:
        <inputtype="number"id="lado_a"><br>
        Ingrese el lado C del triángulo:
        <inputtype="number"id="lado_c"><br><inputtype="button"value="Calcular"id="area"></p><pid="resultado"></p><pid="tipoTriangulo"></p><script>var base = document.getElementById('base')
        var altura = document.getElementById('altura')
        var lado_c = document.getElementById('lado_c')
        var lado_a = document.getElementById('lado_a')

        var area = document.getElementById('area')
        area.addEventListener('click', calcularArea)

        var resultado = document.getElementById('resultado')
        var tipoTriangulo = document.getElementById('tipoTriangulo')

        functioncalcularArea() {
            var lado_b = parseInt(base.value)
            var h = parseInt(altura.value)
            var areaTriangulo = (lado_b * h) / 2var a = parseInt(lado_a.value)
            var c = parseInt(lado_c.value)

            resultado.innerHTML = `El área del triangulo es: ${areaTriangulo} mt2.  <br>`if (lado_b != a && lado_b != c) {
                tipoTriangulo.innerHTML = `Triángulo escaleno.`
            } elseif(lado_b == a && lado_b == c){
                tipoTriangulo.innerHTML = `Triángulo equilatero.`
            } else{
                tipoTriangulo.innerHTML = `Triángulo isóseles.`
            }

        }

    </script></body></html>```
1
2949Puntos

El area de un triangulo en mi humilde C++

#include<iostream>usingnamespacestd;

intmain(){
    float base, altura, area;

    cout << "Base de triangulo: ";
    cin >> base; 

    cout << "Altura del triangulo: ";
    cin >> altura;

    area = (base*altura)/2;
    cout << "El area es: " << area << "m^2" << endl;

    return0;
}
1
15157Puntos
const triangleArea = (base, height) => {
  const area = (base * height) / 2;

  if(base === height){
    console.log("Es un triangulo equilátero")
  } elseif (base > height) {
    console.log("Es un triangulo escaleno")
  } elseif ( base < height) {
    console.log("Es un triangulo isósceles")
  }

  return console.log(area)
}

triangleArea(5, 4)```
1
26494Puntos

Este es el resultado. 😄

Gracias a los que aportaron cómo deducir obtener el tipo de triángulo por comparaciones de base y altura.

defarea_triangulo(b, h):"""Calcula el área de un triángulo

    Parámetros:
    b, h float > 0

    Retorna:
    area = (b * h) / 2 float > 0"""

    area = (b * h) / 2return area


deftriangle_type(b, h):"""Dependiendo de los valores de base y altura decide
    si un triángulo es escaleno, isósceles o equilatero.

    Parámetros:
    b, h float > 0

    Retorna:
    triangle_t string"""

    triangle_t = 'equilatero'if b < h:
        triangle_t = 'isósceles'elif b > h:
        triangle_t = 'escaleno'return triangle_t


if __name__ == "__main__":
    base = float(input('Ingresa la base del triángulo: '))
    altura = float(input('Ingresa la altura del triángulo: '))

    triangle = triangle_type(base, altura)
    result = area_triangulo(base, altura)

    print(f'\n\tEl triángulo es {triangle}.')
    print(f'\tEl área del triángulo es: {result}')
1
6327Puntos

El área de un triángulo en Java

public class AreaTriangulo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);System.out.println("Ingresa la base");int base = scanner.nextInt();System.out.println("Ingresa la altura");int altura = scanner.nextInt();System.out.println("Ingresa los 3 lados del tríangulo");int lado1 = scanner.nextInt();int lado2 = scanner.nextInt();int lado3 = scanner.nextInt();//Calcular el areadouble area = base * altura / 2;
        String tipoTriangulo = "";if (lado1 == lado2 && lado1 == lado3) {
            tipoTriangulo = "Equilatero";
        } elseif(lado1 == lado2 || lado1 == lado3 || lado2 == lado3) {
            tipoTriangulo = "Isósceles";
        } else {
            tipoTriangulo = "Escaleno";
        }
        System.out.println("El tríangulo es:" + tipoTriangulo + "\nÁrea: " + area);
    }
}
1
9932Puntos

Python

#Día dos
#Área de un triángulo

base = int(input(f'¿Cuál es la base? '))
altura = int(input(f'¿Cuál es la altura? '))

area = (base * altura)/2if base == altura:print (f'El triángulo es equilátero y el área es {area}') 
elif base < altura:print (f'El triángulo es isóseles y el área es {area}')
elif base > altura:print (f'El triángulo es escaleno y el área es {area}')```
1
9998Puntos

a ver que tal (: Captura de pantalla -2020-07-08 04-50-15.png

1
11264Puntos

Reto día 2 en JS.

var triangulo1 = {
  base: 10,
  altura: 5,
  ladoa: 10,
  ladoc: 10
}

var triangulo2 = {
  base: 10,
  altura: 5,
  ladoa: 15,
  ladoc: 15
}

var triangulo3 = {
  base: 10,
  altura: 5,
  ladoa: 5,
  ladoc: 8
}

var objeto = [triangulo1, triangulo2, triangulo3]

const areaTriangulo = (objeto) => {
  var area = objeto.base * objeto.altura / 2return area
}

console.log(areaTriangulo(triangulo1))

functiontipoDeTriangulo(objeto) {
  var b = objeto.base
  var a = objeto.ladoa
  var c = objeto.ladoc
  if (b === a && a === c) {
    console.log('Es un triangulo equilatero')
  } elseif (a === c && b != a) {
    console.log("Es un triangulo isósceles")
  } else {
    console.log("Es un triangulo escaleno")
  }
}

tipoDeTriangulo(triangulo1)
tipoDeTriangulo(triangulo2)
tipoDeTriangulo(triangulo3)
1
2552Puntos
defarea_del_triangulo(base, altura):
	area = (base*altura)/2if base == altura:
		print("Su triangulo es equilatero y tiene un área de: " + str(area))
	else:
		print("Su triangulo es isóceles y tiene un área de: " + str(area))
	return area

if __name__ == '__main__':
	base = int(input(" Ingrese la base de su triangulo: "))
	altura= int(input(" Ingrese la altura de su triangulo: "))
	area_del_triangulo(base, altura)


1
6748Puntos

JavaScript

const heigth = prompt('Ingresa la altura');
const base = prompt('Ingrese la base');

functiontypeTriangle({ heigth }, { base }) {
   const area = (base * heigth) / 2;
   if (heigth === base) {
      alert(`Tienes un triangulo Equilatero con un area de: ${area}`);
   } elseif (heigth > base) {
      alert(`Tienes un triangulo Isoceles con un area de ${area}`);
   } else {
      alert(`Tienes un triangulo Escaleno con un area de ${area}`);
   }
}
typeTriangle( { heigth }, { base })
1

KIS con Javascript

// AREA DEL TRIANGULO

function area(base, height) {
    a = (base*height)/2
    console.log(`El area del triangulo es: ${a}`)
}


// DETERMINAR TIPO DE TRIANGULO (equilatero, isoceles, escaleno)


function triangle(a, b, c) {
    if (a == b && b == c) {
        console.log('Es EQUILATERO')
    } elseif (a != b && (a != c && b != c))  {
        console.log('Es ESCALENO')
    } else {
        console.log('Es ISOCELES')
    }
}


area()triangle()
1
3379Puntos

JavaScript

varbase = prompt('Ingrese la base del triangulo');
var altura = prompt('Ingrese la altura del triangulo');

obtenerArea(base, altura);

function getArea(base, altura) {
  var area = (base * altura) / 2;

  alert('el área del triangulo es: ' + area);
}
1
7689Puntos

No entendí muy bien el bonus, ya que no se puede determinar que tipo de triángulo es partiendo solo de la base y altura, por ende hice dos partes, uno que calcula el área, y otra que calcula tipo de triángulo por los lados.

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Triangulo</title></head><body><divstyle="
      display: flex;
      flex-flow: column;
      align-items: center;  
      justify-content: space-around; 
      flex-grow: 1;
  "><headerstyle="display: flex; flex-flow: column; align-items: center;"><h1>Área de un triángulo</h1><h3style="color: red;">¡¡¡Usar medidas en cm!!!</h3></header><div><p>El resultado es: <spanid='area'>0</span> cm^2</p></div><imgstyle="margin-top: 30px;"width="30%"src='https://www.vippng.com/png/full/136-1363327_triangulo-png.png'alt='Borde_Triángulo'><inputstyle="margin-top: 20px; text-align: center;"id='altura'><spanstyle="margin-left: 5px;">Altura</span></inpupt><inputid='base'style="text-align: center;"><spanstyle="margin-left: 5px;">Base</span></input><buttonstyle="margin: 20px 0;"id='ver'onclick="handleSubmitArea()">Resultado</button></div><hr><divstyle="
      display: flex;
      flex-flow: column;
      flex-grow: 1;
      align-items: center;  
      justify-content: space-around; 
  "><h1>Determina que tipo de triangulo es por medio de sus lados en cm</h1><p>El resultado es: <spanid='tipo'></span></p><imgstyle="margin-top: 30px;"width="20%"src='https://es-static.z-dn.net/files/d5d/3c75a97024bd9d95c9ab7adbdf3a77b6.jpg'alt='Borde_Triángulo'><inputstyle="margin-top: 20px; text-align: center;"id='a'><spanstyle="margin-left: 5px;">Lado a</span></inpupt><inputid='b'style="text-align: center;"><spanstyle="margin-left: 5px;">Lado b</span></input><inputid='c'style="text-align: center;"><spanstyle="margin-left: 5px;">Lado c</span></input><buttonstyle="margin: 20px 0;"id='ver'onclick="handleSubmitType()">Resultado</button></div><script>const handleSubmitArea = () => {
      const altura = document.getElementById('altura').value
      const base = document.getElementById('base').value
      const resultado = document.getElementById('area')

      // Áreaconst area = (altura*base)/2
      resultado.innerHTML = ''
      resultado.innerHTML = area
    }

    const handleSubmitType = () => {
      const a = document.getElementById('a').value
      const b = document.getElementById('b').value
      const c = document.getElementById('c').value
      const type = document.getElementById('tipo')
      
      if ( a === b && a === c){
        type.innerHTML = 'Equilátero'
      }
      if (( a === b || b === c || a === c ) && ( a !== b || b !== c || a !== c )){
        type.innerHTML = 'Isóceles'
      }
      if ( a !== b && a !== c && b !== c ){
        type.innerHTML = 'Escaleno'
      }
    }
    </script></body></html>
1
4330Puntos

JS.

const lado1 = parseInt(prompt('Dame el valor del primer lado'));
const lado2 = parseInt(prompt('Dame el valor del segundo lado'));
const lado3 = parseInt(prompt('Dame el valor del tercer lado'));
let area = 0;
let perimetro;

functioncalcularPerimetro(l1, l2, l3) {
  let perimetro = 0;
  return perimetro = l1 + l2 + l3
}

functioncalcularArea(p, l1, l2, l3) {
  let sp = (p / 2)
  let totalL1 = (sp - l1)
  if(totalL1 === 0){
    totalL1 = 1;
  }

  let totalL2 = (sp - l2)
  if(totalL2 === 0){
    totalL2 = 1;
  }

  let totalL3 = (sp - l3)
  if(totalL3 === 0){
    totalL3 = 1;
  }

  let total = sp * (totalL1 * totalL2 * totalL3)
  return area = Math.sqrt(total)
}

if(lado1 === lado2 && lado1 === lado3){
  console.log('El triángulo es equilátero')
}elseif(lado1 != lado2 && lado1 != lado3){
  console.log('El triángulo es escaleno')
}else{
  console.log('El triángulo es isósceles')
}

perimetro = calcularPerimetro(lado1, lado2, lado3)
console.log(`Su área es ${calcularArea(perimetro, lado1, lado2, lado3)}`)
1

Hacer este programa en Python fue muy entretenido, llevo muy poco aprendiendo a programar y es genial hacer estos retos para usar lo que he aprendido y reconocer lo que no sé cómo hacer.

print("Bienvenido!\nContinua para conocer el área de un triángulo y su clasificación segun sus lados.\n ")

b = float(input("Ingrese la medida de la base del triángulo: "))
h = float(input("Ingrese la medida de la altura del triángulo: "))
a = float(input("Ingrese la medida de un lado del triángulo: "))
c = float(input("Ingrese la medida del otro lado del triángulo: "))

print("\n")

defareaTriangulo():
    area = (b * h) / 2
    print(f"El área del triángulo es {area} " )

areaTriangulo()

deftipoTriangulo():if a==b==c : 
        print("Y es un triángulo equilatero.")
    elif a==c or a==b or b==c :
        print("Y es un triángulo isosceles.")
    elif a!=b and a!=c and b!=c :
        print("Y es un triángulo escaleno.")

tipoTriangulo()```
1
7 meses

Cuando es equilátero también te va a imprimir que es isósceles, saludos.

1
283Puntos

He visto varios códigos buenos en JavaScript y Python, así que decidí usar un lenguaje poco convencional, F#:

open System

let areaTriangulo _base altura = _base * altura / 2.0[<EntryPoint>]let main argv =

    let _base =
        printfn "Base: "
        Console.ReadLine() |> float

    let altura =
        printfn "Altura: "
        Console.ReadLine() |> float
    
    printfn "El área del triángulo es: %f" (areaTriangulo _base altura)
    
    0

https://repl.it/join/cyfwncnq-miguelzabala

1
9642Puntos

#PlatziCodingChallenge

classTriangulo():def__init__(self):
        self.area = 0defarea_triangulo_lados(self, hipotenusa, opuesto, adyacente):
        self.lados = True
        self.perimetro = hipotenusa + opuesto + adyacente
        self.semi = self.perimetro / 2
        self.area = math.sqrt(self.semi * (self.semi-hipotenusa)* (self.semi-opuesto)* (self.semi-adyacente))
        if hipotenusa==opuesto and hipotenusa == adyacente:
            print("Es triángulo Equilátero")
        elif opuesto == adyacente or opuesto == hipotenusa or hipotenusa == adyacente:
            print("Es triángulo Isósceles")
        else:
            print("Es triángulo Escaleno")
        return self.area

    
    defarea_triangulo(self, base, altura):
        self.area = (base * altura) / 2return self.area

        
    


if __name__ == "__main__":
    menu = 0while menu != 3 :
        print("Seleccione la opción que desea ejecutar: ")
        print("1. Calcular el área del triángulo conociendo los lados.")
        print("2. Calcular el área del triángulo conociendo la base y la altura.")
        print("3. Salir")
        opcion = int(input())
        if opcion == 1:
            triangulo = Triangulo()
            area = triangulo.area_triangulo_lados(int(input('Ingrese la hipotenusa ')), int(input('Ingrese el cateto opuesto ')),int(input('Ingrese el cateto adyacente ')))
            
            print(f'El área del triángulo es: {area}')
            
            breakelif opcion == 2:
            triangulo = Triangulo()
            area = triangulo.area_triangulo(int(input("Ingrese la base: ")), int(input("Ingrese la altura: ")))
            print(f'El área del triángulo es: {area}')
            breakelif opcion == 3:
            breakelse:
            pass
1
1857Puntos

Esta es la solución al reto por medio de Python.

lado_1 = float(input('Cuanto mide el primer lado: '))
lado_2 = float(input('Cuanto mide el segundo lado: '))
lado_3 = float(input('Cuanto mide el tercer lado: '))

base = float(input('Cuanto mide la base: '))
altura = float(input('Cuanto mide la altura: '))

# determinaremos el tipo de triangulo y el area.if lado_1 == lado_2 and lado_2 == lado_3:
    area = (3**0.5 / 4) * (lado_1**2)
    print(f'Tienes un triangulo equilatero con un area de: {area}.')
elif lado_1 == lado_2 or lado_2 == lado_3 or lado_1==lado_3:
    area = (base * altura) / 2print(f'Tienes un triangulo isoseles con un area de: {area}.')
elif lado_1 != lado_2 and lado_2 != lado_3 and lado_1 != lado_3:
    area = (base * altura) / 2print(f'Tienes un triangulo escaleno con un area de: {area}.')
else:
    print(f'Revisaremos el error.')```
1

Ayer vi este apartado, no sé de cuándo es, pero comenzé a cabecearme enseguida y recién lo terminé.
No luce muy bien, pero funciona. Ya llegará el día en que aprenda a seleccionar los tamaños de los comentarios. Saludos
.

<!DOCTYPE html><html><head><metacharset="utf-8"><title> Area del Triángulo </title><style>body
    {
      background-color: green;
      color: white;
      font-family: Frontier;
      }
    </style></head><body><h1>Calculo del Area de un triángulo</h1><h2> Area = (base * altura) / 2</h2><scripttype="text/javascript">var base = prompt("Ingresar medida de la base: ");
    var altura = prompt("Ingresar medida de la altura: ");
    var A_triang = (base * altura) / 2;
    if (base < altura)
    {
    document.write("El tipo de triángulo es Isósceles ");
    }
    elseif (base > altura)
    {
    document.write("El tipo de triángulo es Escaleno ");
    }
    elseif (base == altura)
    {
    document.write("El tipo de triángulo es Equilátero ");
    }
    document.write(" y el Area del triángulo es " + A_triang);
    </script></body></html>
1
8 meses

Mientras le explicaba este código a mi hija, acabo de darme cuenta de que no tenía claro lo de cómo identificar el tipo de triángulo de acuerdo a sus características y cometí el error en esa parte. Me voy a poner a estudiar para entender bien lo de los triángulos y no solo eso, si no que antes de hacer un programa, me dedicaré a entender bien todo de lo que se trata, es lo que debí haber hecho. Me castigo 😦
Saludos

1
5423Puntos

En Python:

def triangle(base, height, side1, side2):
	r = (base * height)/2if side 1 == side 2and side 1 == base:
		return(f'Equilaterum triangle with an area of {r}

	elif side1 > side 2and (side1 == base):
		return(f'Scalene triangle with an area of {r}'

	elif:
		return(f'Isoceles triangle with an area of {r}'
1

Buen reto, el programa indica el tipo de triangulo según los lados ingresados por el usuario y el área de cada triangulo, como ayuda se utilizó pitagoras y Herón
En Python:

#Lados del triangulo
import math
a=int(input(f'Ingrese tu primer lado del triangulo: '))
b=int(input(f'Ingrese otro lado de tu triangulo: '))
c=int(input(f'Ingrese un tercer lado para tu triangulo: '))

if a==b==c:
    print('Tu triangulo es equilatero')
    base=a/2
    altura=a*math.sin(math.pi/3)
    area=(base*altura)/2print(f'Tu area es {area}')
elif a==b or b==c or a==c:
    print('Tu triangulo es isoceles')
    if a==b:
        base=c/2
        altura=(a**2-(c/2)**2)**0.5
        area=(base*altura)/2print(f'Tu triangulo tiene una area de {area}')
    elif b==c:
        base=a/2
        altura=(b**2-(a/2)**2)**0.5
        area=(base*altura)/2print(f'Tu triangulo tiene una area de {area}')
    else:
        base=b/2
        altura=(a**2-(b/2)**2)**0.5
        area=(base*altura)/2print(f'Tu triangulo tiene una area de {area}')
else:
    print('Tu triangulo es escaleno')
#Por Heron
    s=(a+b+c)/2
    area=(s*(s-a)*(s-b)*(s-c))**0.5print(f'Tu triangulo tiene un area de: {area}')```
1
12601Puntos
platz1.jpg
defasknumber(message):
    number=int(input(f'{message}'))
    while number <= 0:
        print('Ingrese números mayores a cero')
        number=int(input(f'{message}'))
    return number

defvalidetriangle(sides):if sides[0]+sides[1]>sides[2] and sides[2]+sides[0]>sides[1] and sides[1]+sides[2]>sides[0]:
        returnTrueelse:
        returnFalsedeftypetriangle(sides):
    area=0if sides[0]==sides[1] and sides[0]==sides[2]:
        print('Triángulo Equilatero')
        area=findheighteq(sides[0])*sides[0]/2elif sides[0]==sides[1] or sides[0]==sides[2] or sides[1]==sides[2]:
        if sides[0]==sides[1]:
            base=sides[2]
            height=findheightis(base,sides[0])
        elif sides[0]==sides[2]:
            base=sides[1]
            height=findheightis(base,sides[0])
        else:
            base=sides[0]
            height=findheightis(base,sides[1])
        print('Triángulo Isoseles')
        area=height*base/2else:
        print('Triángulo Escaleno')
        semiperimeter=0for side in sides:
            semiperimeter+=side
        semiperimeter=semiperimeter/2
        area=semiperimeter
        for side in sides:
            area*=(semiperimeter-side)
        area=area**(1/2)
    print(f'El área del Triángulo es: {area}')

deffindheighteq(side):return (side/2)*(3**(1/2))

deffindheightis(base,side):return (side**2-(base/2)**2)**(1/2)

print('Ingresar los lados del Tringulo\n')
sidesnumber=3
sides=[1,1,1]
for index in range(sidesnumber):
    sides[index]=asknumber(f'Ingresar el {index+1}° lado: ')

ifnot validetriangle(sides):
    print('Triangulo no valido')
    exit()

typetriangle(sides)
1
6226Puntos
functioncalcularArea(){
    var base = parseInt(prompt("Cuanto mide la base?"));
    var altura = parseInt(prompt("cuanto mide la altura?"));
    var resultado = (base * altura)/2;
    
    console.log(resultado);
}

functiontriangulo(){
    var lado1 = prompt("Cuanto mide el lado 1?");
    var lado2 = prompt("cuanto mide el lado 2?");
    var lado3 = prompt("cuanto mide el lado 3?");
    
    if(lado1 == lado2){
        if(lado1 == lado3){
            console.log("El triangulo es equilatero");
        }
        else{
            console.log("El triangulo es isoceles");
        }
    }
    if(lado1 != lado2){
        if(lado1 != lado3){
            console.log("Triagulo escaleno");
        }
        else{
            console.log("Triangulo isoceles");
        }
    }
}

triangulo();
calcularArea();
1
4951Puntos

Mi codigo en JavaScript

var base = parseInt(prompt("¿Cual es la base?"));
var altura = parseInt(prompt("¿Cual es la altura?"));
var resultado = base * altura / 2;
console.log("El area del tringulo es: " + resultado);

Estuve buscando la manera de determinar el tipo de tringulo y no logre encontrar la respuesta, si alguien sabe como y que me pueda explicar se lo agradeceria, claro esta que en base a los parametros que estan pidiendo en la descripcion. No quiero que me pasen el codigo solo quiero saber como se determina para yo poder realizarlo y practicar mas.

2
9298Puntos
8 meses

Para saber el tipo de triangulo debes tener ya sea los tres lados del triangulo o dos y un angulo si quieres hacer un programa que resuelva el tipo de triangulo en general, ya sea comparando los lados o aplicando formulas como seno y coseno. Que yo sepa, no es posible solo con la altura, base y el área.

1
4951Puntos
8 meses

era mi duda si se podia saber el tipo de triangulo en base a esos parametros que pedian en la descripcion, porque habia visto las formulas que podia utilizar para obtener el resultado y me pedia como tu dices ya se los lados o angulos.

1
7151Puntos

JAVA

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        // Your code here!int b;int h;

        String unidadDeMedida;
        String response;System.out.println("Por favor introduce la base del triangulo");
        Scanner sc = new Scanner(System.in);
        b = Integer.valueOf(sc.nextLine());System.out.println("\nPor favor introduce la altura del triangulo");
        Scanner sch = new Scanner(System.in);
        h = Integer.valueOf(sc.nextLine());System.out.println("\nPor favor introduce la Unidad de medida a usar (m, cm, Km, etc.)");
        Scanner scudm = new Scanner(System.in);
        unidadDeMedida = String.valueOf(sc.nextLine());
        


        var res = b * h / 2;
        var un = b + unidadDeMedida;
        var unh = h + unidadDeMedida;System.out.println("\nEl area de tu triangulo de " + un + " de base y " + unh + " de altura es de: " + res + unidadDeMedida);
    }
}
1
12287Puntos

Un poco tarde pero aquí mi resultado del reto.

1
7927Puntos

JavaScript:
No encontré como determinar si era isósceles, equilátero o escaleno con solo la base y la altura, así que usé la formula de Herón para hallar el área usando las longitudes de los tres lados.

var lado1 = parseInt(prompt("Longitud del primer lado"));
var lado2 = parseInt(prompt("Longitud del segundo lado"));
var lado3 = parseInt(prompt("Longitud del tercer lado"));

// Formnula de Herónvar perimetro = lado1 + lado2 + lado3;
var semiperimetro = perimetro / 2;
var area = Math.sqrt(semiperimetro * (semiperimetro - lado1) * (semiperimetro - lado2) * (semiperimetro - lado3));

console.log(`El area del triangulo es: ${area}`);

// Clasificación del trianguloif(lado1 == lado2 == lado3){
    console.log('El triangulo es equilátero');
} elseif(lado1 == lado2 || lado1 == lado3 || lado2 == lado3){
    console.log('El triangulo es isóceles');
} else{
    console.log('El triangulo es escaleno');
}
1
4009Puntos

Hola
Soy muy nuevo en esto, estoy tratando de hacer lo más básico primero que es una fórmula para calcular el área, todavía no he llegado a la parte de clasificarlo por tipo de triangulo, usé html para la interfaz y javascript para la lógica, pero a la hora de ejecutar el evento “click” para que me active la función me da NaN… ¿Alguien puede observar cuál es el error de código?
Muchas gracias

<!DOCTYPE html><htmllang="es"><head><metacharset="UTF-8"><metaname="viewport"content="width=device-width, initial-scale=1.0"><title>Document</title></head><body><h1>Comprueba/calcula el área de un triánugulo</h1><section><p><inputtype="number"id="base">Ingresa la base (b)</p><p><inputtype="number"id="altura">Ingresa la altura (h)</p><p><inputtype="submit"value="CALCULAR"id="enviar"></p></section><scriptsrc="pruebaarea.js"></script></body></html>
var b = parseInt(document.getElementById("base"));
var h = parseInt(document.getElementById("altura"));
var boton = document.getElementById("enviar");
boton.addEventListener("click", area);


functionarea (b,h) 
{
    area = (b*h)/2;
    document.write(area);
}


1
15736Puntos

El reto es de ayer, pero igual vengo a hacerlo. Tardé más de una hora (creo, se me fue el tiempo), pero puedo presumir que funciona con todo y bonus. Aquístá:

var triangulo1 = {
  name: 'Triángulo 1',
  base: 10,
  lado1: 10,
  lado2: 10,
  altura: 8.66
}

var triangulo2 = {
  name: 'Triángulo 2',
  base: 20,
  lado1: 25,
  lado2: 25,
}

var triangulo3 = {
  name: 'Triángulo 3',
  base: 20,
  lado1: 25,
  lado2: 30,
}



functiondeterminarArea(figura) {
  area = (figura.base*figura.altura)/2;
  console.log(`El área del ${figura.name} es de ${area}`)
}

determinarArea(triangulo1)

functiondeterminarTriangulo(figura) {
  if (figura.base === figura.lado1 &
    figura.base === figura.lado2 & figura.lado1 === figura.lado2) {
      console.log(`El ${figura.name} es un triángulo equilátero`)
  } elseif (figura.base !== figura.lado1 &
    figura.base !== figura.lado2 & figura.lado1 === figura.lado2) {
      console.log(`El ${figura.name} es un triángulo isóceles`)
  } elseif (figura.base !== figura.lado1 &
    figura.base !== figura.lado2 & figura.lado1 !== figura.lado2) {
      console.log(`El ${figura.name} es un triángulo escaleno`)
  }
}

determinarTriangulo(triangulo1)
determinarTriangulo(triangulo2)
determinarTriangulo(triangulo3)

El área del Triángulo 1 es de 43.3
El Triángulo 1 es un triángulo equilátero
El Triángulo 2 es un triángulo isóceles
El Triángulo 3 es un triángulo escaleno

Toda retroalimentación es bienvenida 😄

1
12410Puntos

Calculadora Chola del área de un tríangulo.

print("Esta es la calculadora chola del área de un triángulo.")
base , altura = input("Cáite con la base, prro: ") , input("Ora la altura, prro: ")
b, h = float(base), float(altura)
area = b * h / 2
txt = "Ahí ta: Tu triángulo tiene {} de área :V"print(txt.format(area))

Hace esto:

//Cáite con la base, prro: 73//Ora la altura, prro: 89//Ahí ta: Tu triángulo tiene 3248.5 de área :V
1
3427Puntos

Área de un Triangulo:

menu = '''
==============================================
=  DETERMINAR EL AREA Y TIPO DE UN TRIANGULO =
==============================================
'''deftipoTriangulo(l1, l2, b):if l1 == l2 and l2 == b:
        return'Es un triangulo equilatero'elif l1 != l2 and l1 != b and l2 != b:
        return'Es un triangulo escaleno'else:
        return'Es un triangulo isósceles'defareaTriagulo(b, h):
    area = (b * h) / 2return area

defrun():
    print(menu)

    whileTrue:
        l1 = int(input('\nIngrese lado 1 del triangulo: '))
        l2 = int(input('Ingrese lado 2 del triangulo: '))
        b = int(input('Ingrese Base del triangulo: '))
        h = int(input('Ingrese altura del triangulo: '))

        area = areaTriagulo(b, h)
        tipo = tipoTriangulo(l1, l2, b)

        print(f'\nEl area del Triagulo es: {area}')
        print(tipo)

        continuar = str(input('Desea continuar...? 1/continuar, 0/salir: '))

        if continuar == '1':
            continueelse:
            breakif __name__ == '__main__':
    run()
1
15039Puntos

Resuelto con JavaScript. Una pregunta como puedo ver los otros retos que vi que van en el 5 pero no encuentro el 3 y 4

 form.addEventListener('submit', (e) => {

       e.preventDefault();

      const height = parseInt(document.getElementById('height').value);
      const left = parseInt(document.getElementById('left').value);
      const right = parseInt(document.getElementById('right').value);
      const base = parseInt(document.getElementById('base').value);
      const results = document.getElementById('results');
      const results2 = document.getElementById('results2');

      const area = (base, height) => {

        const area = base * height / 2;

        return area;
      }

      //.toFixed(n) Define cuantos número decimales mostrar
      results.textContent = `El área del triangulo es: ${area(base, height).toFixed(2)}`;
      console.log(area(base, height));

      if ( left === right && right === base) {
        results2.textContent = 'Es un triangulo Equilatero';
      } elseif (left === right && right != base) {
        results2.textContent = 'Es un triangulo Isólseles';
      } elseif (left != right && right != base) {
        results2.textContent = 'Es un triangulo Escaleno';
      }
      form.reset();

    });

1
3466Puntos

C++

/*
El reto del día de hoy es escribir un programa que tome la base y la altura como parámetros y calcule el área del triángulo. Bonus: El programa debe determinar si el triángulo es isósceles, equilátero o escaleno.
*/#include<iostream>usingnamespacestd;
intmain(){
    int base, altura, area, option, ladoIzq, ladoDer;
    cout << "Introduce la base del triángulo: ";
    cin >> base;
    cout << "Introduce la altura del triángulo: ";
    cin >> altura;
    area = (base * altura) / 2;
    cout << "El area de tu triángulo es: " << area << endl
         << endl;
    cout << "Deseas saber que tipo de triángulo es: \n1: Sí\nOtra tecla: No\n";
    cin >> option;
    if (option == 1)
    {
        cout << "Introduce el lado Izquierdo: ";
        cin >> ladoIzq;
        cout << "Introduce el lado Derecho: ";
        cin >> ladoDer;
        if (ladoDer == ladoIzq && ladoIzq == base)
        {
            cout << "Triángulo equilátero";
        }
        elseif (ladoDer == ladoIzq || base == ladoIzq || ladoDer == base)
        {
            cout << "Triángulo isósceles";
        }
        else
        {
            cout << "Triángulo escaleno";
        }
    }
    return0;
}
1
6358Puntos

base = int(input(" Base del triangulo"))
altura = int(input(" Altura del triangulo"))

area = (base * altura) / 2

print(‘El area del triangulo es: {}’.format(area))

1
9984Puntos
<?php

function area_triangulo(int $base, int $altura) {
    return ($base*$altura)/2;
}

function tipo_triangulo(int $ladoa, int $ladob, int $ladoc) {
    $result = "";
    if($ladoa == $ladob  && $ladob == $ladoc) {
        $result = "Triangulo equilatero";
    }elseif (($ladoa == $ladob) || ($ladoa == $ladoc) || ($ladob == $ladoc)) {
        $result = "Triangulo isosceles";
    } else {
        $result = "Triangulo escaleno";
    }

    return $result;
}
echo "Area es: ".area_triangulo(4,2)."\n";
echo tipo_triangulo(4,1,5)."\n";

?>
1
12281Puntos
const l1 = 7const l2 = 7const base = 4const height = 5functioncalc(base, height) {
  return (base * height) / 2
}


functiontriagle(l1, l2, l3) {
  if (l1 === l2 && l1 === l3) {
    console.log('Equilatero')
  } elseif (l1 === l2 && l1 != l3) {
    console.log('Isosceles')
  } else {
    console.log('Escaleno')
  }
}


triagle(l1, l2, base)
console.log(calc(base, height))```
1

Llegué tarde a este reto pero aquí vamooss

const calcularArea = (base, altura, callback) => { 
    let area = (base * altura) / 2console.log(`El area del triangulo es ${area}`)
    return callback(4, 4, 4)
}

const definirLado = (lado1, lado2, lado3) => {
    if (lado1 != lado2 && lado2 != lado3) {
        console.log('Escaleno')
    } elseif (lado1 === lado2 && lado2 === lado3) {
        console.log('Equilatero')
    } else {
        console.log('Isoceles')
    }
}

calcularArea(4, 4, definirLado)```

con js
1
10055Puntos
<code>
letbase = prompt("ingrese la base del triangulo")
letaltura = prompt("ingrese la altura del triangulo")
let area;


area= (base*altura)/2
alert("El area del triangulo es "+ area)

1
5435Puntos

Mi aportacion en JS y usando stdin & stdout

let preguntas = ['¿Altura del triangulo? ', '¿Base del triangulo? '];

let respuestas = [];

functionpregunta(i) {
  process.stdout.write(preguntas[i]);
}

process.stdin.on('data', function (data) {
  respuestas.push(data.toString().trim());

  if (respuestas.length < preguntas.length) {
    pregunta(respuestas.length);
  } else {
    areaTriangulo(respuestas[0], respuestas[1]);
    tipoTriangulo(respuestas[0], respuestas[1]);
    process.exit();
  }
});

functiontipoTriangulo(base, altura) {
  if (altura === base) {
    console.log(`\tEs un triangulo Equilatero`);
  } elseif (altura > base) {
    console.log(`\tEs un triangulo Isoceles`);
  } else {
    console.log(`\tEs un triangulo Escaleno`);
  }
}

functionareaTriangulo(base, altura) {
  const area = (respuestas[0] * respuestas[1]) / 2;
  console.log(
    `\nEl área del triangulo con altura ${respuestas[0]} y base ${respuestas[1]} es ${area}`
  );
}

pregunta(0);
1
10269Puntos

Solo logré hacer si el triángulo es Equilátero o Isósceles:

functionArea(b, h) {
    let A = (b * h) / 2console.log(A)
    let tiposTriangulos = (b, h) => {
        let Promedio = (h * 100) / b
        if (floor(Promedio) == 86) {
            console.log('El Triángulo es Equilatero')
        } else {
            console.log('El triángulo es Iscóseles')
        }
    }
    tiposTriangulos(b, h)
}
1
5819Puntos

Compañeros les presento mi código en python.

deflados():
    print()
    lado1 = float(input('Ingrese la medida del primer lado del triangulo: '))
    lado2 = float(input('Ingrese la medida del segundo lado del triangulo: '))
    lado3 = float(input('Ingrese la medida del tercer lado del triangulo: '))

    print()
    if lado1 == lado2 == lado3:
        print('El triangulo es equilatero.')
    elif lado1 == lado2 or lado1 == lado3 or lado2 == lado3:
        print('El triangulo es isosceles.')
    else:
        print('El triangulo es escaleno.')

defrun():

    print('Vamos a calcular el area de un triangulo.')
    print()
    base = float(input('Ingrese la base del triangulo: '))
    altura = float(input('Ingrese la altura del triangulo: '))
    area = (base * altura)/2
    print(f'El area del triangulo es {area}')

    lados()


    

if __name__ == '__main__':
    run()
1
14928Puntos

Yo he creado una clase en typescript, que se encarga de hacer esta tarea, con los datos que nos aportan no se puede saber si es escálenlo o no =(

classTriangle{

    private height: number;
    privatebase: number;

    constructor(base: number, height: number){
        this.base = base;
        this.height = height;
    }

    getArea(): number {
        return (this.base * this.height) / 2;
    }

    getType(): string{
        let hypotenuse = this.calculatehypotenuse();
        if(hypotenuse == this.base){
            console.log("Es un triangulo Equilatero");
            return"Equlatero";

        }else{
            console.log("Es un triangulo Isoceles");
            return"Isoceles";
        }

    }

    privatecalculatehypotenuse(): number {
        return ((this.base/2)*this.height) /2;
    }
}

export default Triangle
1
9585Puntos

Va sin el bonus por el momento:

<!DOCTYPE html><htmllang="en"><head><metacharset="UTF-8" /><metaname="viewport"content="width=device-width, initial-scale=1.0" /><title>Coding Challenge</title></head><body></body><script>var b = prompt("Cual es la base del triangulo?");
    var h = prompt("Cual es la altura del triangulo?");
    var area = (b * h) / 2;

    alert(`El área del triangulo es de ${area}`);
  </script></html>
1
16088Puntos

Aquí pongo el código, pero pueden ver mi repositorio acá.
.
Hice un front básico para recibir los datos e imprimirlos que pueden ver por acá

class Triangle {
    constructor(){
        this.side1 = prompt("Intruduce la longitud del lado 1");
        this.side2 = prompt("Intruduce la longitud del lado 2");
        this.side3 = prompt("Intruduce la longitud del lado 3");
        this.type;
        this.area;
    }
    getArea() {
        let s1 = Number(this.side1);
        let s2 = Number(this.side2);
        let s3 = Number(this.side3);

        if (s1 == s2 && s2 == s3) {
            const a = s1;
            letresult = ((Math.round(Math.sqrt(3)*1000)/1000) / 4) * a**2;
            this.area = result;
            this.type = 'equilatero';
        } 
        elseif (s1==s2 || s2==s3 || s1 == s3) {
            let a;
            let b;
            if (s1 == s2){
                a = s1;
                b = s3;
            }
            elseif (s1 == s3){
                a = s1;
                b = s2;
            } else {
                a = s2;
                b = s1;
            }
            letresult = (b * (Math.round(Math.sqrt(a**2 - ((b**2)/4))*1000)/1000))/2;
            this.area = result;
            this.type = 'isósceles';

        } else {
            const a = s1;
            const b = s2;
            const c = s3;
            let s = (a + b + c) / 2;
            letresult = Math.round(Math.sqrt(s*(s-a)*(s-b)*(s-c))*1000)/1000;
            this.area = result;
            this.type = 'escaleno';
        }
    }
    print(){
        this.getArea();
        console.log(`Tu triángulo es ${this.type} y su área es ${this.area}u`);
    }
}

const myTriangle = new Triangle();
myTriangle.print();

export default Triangle;

1

Adjunto mi aporte, el usuario nos da los valores de los lados del triangulo. Saludos 😄

<!DOCTYPE html><html><head><metacharset="utf-8"><title>PlatzCodingChallenge Reto 2</title></head><body><h1>Reto 1 Area de un Triangulo</h1><p>#PlatzCodingChallenge</p><br /><p>Cual es la base del Triangulo?</p><inputtype="text"id="base"><br /><p>Cual es la alturra del Triangulo?</p><inputtype="text"id="altura"><br /><p>Cual es el valor del primer lado</p><inputtype="text"id="lado1"><br /><p>Cual es el valor del segundo lado</p><inputtype="text"id="lado2"><br /><inputtype="button"id="boton"value="Click aqui para hacer magia"><br /><scriptsrc="reto1_triangulo.js"></script></body></html>
var b = document.getElementById("base");
var h = document.getElementById("altura");
var ladoA = document.getElementById("lado1");
var ladoB = document.getElementById("lado2");
var botoncito = document.getElementById("boton");

botoncito.addEventListener ("click" , calcularArea);

functioncalcularArea ()
{
var area_triangulo = parseFloat(b.value) * parseFloat (h.value) / 2;
console.log(area_triangulo);
document.write ("El area del triangulo es " + area_triangulo);
if (parseInt(ladoA.value) == parseFloat(ladoB.value) && parseFloat(ladoB.value) == parseFloat(b.value) )
 {
  document.write ("\n El triangulo es Equilatero");
  }
elseif (parseFloat(ladoA.value) == parseFloat(ladoB.value))
 {
  document.write ("\n El triangulo es Isoceles");
}
else {
  document.write ( "\nEl triangulo es Escaleno");
}
}
1
28285Puntos
//Dart doubletriangle_area(double height, doublebase){
  return height*base/2;
}

voidmain(){
  print("The area of the triangle is ${triangle_area(10, 4)}");
}```
1
49000Puntos

Hice lo que pude:

defarea(base, altura):

    print(f'El área es igual a {base * altura / 2}')


deftipo_triangulo(base, altura):if altura == (3**(1/2) * base**2) / 4:
        print(f'Es un triángulo equilátero')
    else:
        print(f'Es un triángulo isósceles o escaleno')


if __name__ == "__main__":
    base = int(input("Ingresa la magnitud de la base: "))
    altura = int(input("Ingresa la magnitud de la altura: "))
    area(base,altura)
    tipo_triangulo(base, altura)
1
17489Puntos

Mi código en Javacript:

let base = parseInt(prompt('¿Cuál es la base del triangulo?; '));
document.write(base);

let altura = parseInt(prompt('¿Cuál es la altura del triangulo?; '));
document.write(altura);

area = (base*altura)/2;

console.log(area);
1
17489Puntos
5 meses

Mi código en python:

base = int(input('¿Cuál es la base del triangulo?; '))
altura = int(input('¿Cuál es la altura del triangulo?; '))

area = (base*altura)/2;print('El area es: ' + str(area));
1
8870Puntos

Aprovechando que estoy en el curso de introducción a Java SE

import javax.swing.*;

public class Main {
    public static void main(String[] args) {
        System.out.println("Calcula el área de un triangulo");int base = Integer.parseInt(JOptionPane.showInputDialog("Dame el valor de la base del triangulo"));int altura = Integer.parseInt(JOptionPane.showInputDialog("Dame el valor de la altura del triangulo"));
        Triangulo T = new Triangulo();int area = T.calcularArea(base, altura);System.out.println("El area del triangulo es: " + area);int ladoA = Integer.parseInt(JOptionPane.showInputDialog("Dame la medida del primer lado del triangulo"));int ladoB = Integer.parseInt(JOptionPane.showInputDialog("Dame la medida del segundo lado del triangulo"));int ladoC = Integer.parseInt(JOptionPane.showInputDialog("Dame la medida del tercer lado del triangulo"));
        String clasificacion = T.clasificacion(ladoA, ladoB, ladoC);System.out.println("Tu triangulo es un " + clasificacion);System.out.println("Vuelva pronto");
    }
}
publicclassTriangulo {
    publicintcalcularArea(intbase, int altura){
        int area=(base*altura)/2;
        return area;
    }
    public String clasificacion(int ladoA,int ladoB, int ladoC){
        if(ladoA==ladoB && ladoA==ladoC){
            return"Equilatero";
        }elseif((ladoA==ladoB && ladoC!=ladoA)||(ladoA==ladoC && ladoB!=ladoA)||(ladoC==ladoB && ladoC!=ladoA)){
            return"Isóceles";
        }elseif(ladoA!=ladoB && ladoA!=ladoC && ladoB!=ladoC){
            return"Esacaleno";
        }
        return"Error";

    }
}