Ejercicio 11. Triángulos

Realiza un programa que clasifique un triángulo tras recibir el tamaño de sus lados. Se debe clasificar como triángulo rectángulo, isósceles, equilátero o escaleno.

Para la realización de este ejercicio en Java, debemos tener claros los conceptos geométricos que nos ayudarán a clasificar el triángulo introducido por el usuario.

En primer lugar, debemos pedir que se introduzcan los tres lados del triángulo ladoA, ladoB, ladoC

Para analizar los triángulos y clasificarlos en la opciones indicadas en el enunciado, debemos saber lo siguiente:

Teorema de Pitágoras: hipotenusa al cuadrado = cateto1 al cuadrado + cateto2 al cuadrado.

Comprobación 1:
Si un triángulo cumple el Teorema de Pitágoras, es un triángulo rectángulo.
El resultado de esta comprobación lo guardaremos en una variable de tipo boolean que llamaremos rectangulo.

Comprobaciones 2:
Aún siendo triángulo rectángulo, también pertenecerá a alguna de las otras opciones, con lo que, independientemente del resultado en el primer if se harán las mismas comprobaciones.

  • Si sólo dos lados del triángulo son iguales, es isósceles.
  • Si los tres lados son iguales, es un triángulo equilátero.
  • Si no se cumple ninguna de las condiciones anteriores, es escaleno.

Para calcular el Teorema de Pitágoras, tenemos que tener en cuenta, que la hipotenusa se trata del lado más largo, con lo que en primer lugar, tendríamos que calcular cual sería la hipotenusa de nuestro triángulo.

Una vez que sabemos cual es el lado más largo de los introducidos por el usuario (hipotenusa), calculamos Pitágoras, si se cumple, la variable boolean rectangulo, tendrá el valor “true”.

Una vez realizadas las comprobaciones mediante if anidados como vemos entre las líneas 41 y 53 de nuestro código, continuamos con la siguiente parte del ejercicio.

Triángulo isósceles

Para calcular si el triángulo tiene sólo dos lados iguales, las condiciones deberían ser:

(A == B y A != C) ó (A == C y A != B) ó (B == C y B != A)

Triángulo equilátero

(A == B y A == C)

package estructurasAlternativas;

/**
11 Ejercicios Estructuras Alternativas en Java

Programa:
Programa que lea 3 datos de entrada A, B y C. Estos corresponden a las dimensiones de los lados de un triángulo. El programa debe determinar que tipo de triangulo es, teniendo en cuenta los siguiente:
    - Si se cumple Pitágoras entonces es triángulo rectángulo
    - Si sólo dos lados del triángulo son iguales entonces es isósceles.
    - Si los 3 lados son iguales entonces es equilátero.
    - Si no se cumple ninguna de las condiciones anteriores, es escaleno.

@author: manolohidalgo_
@date: 09-11-19
*/

import java.util.Scanner;

// Inicio del programa y declaración de variables:
public class Ejercicio11Triangulos {
  public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    int ladoA;
    int ladoB;
    int ladoC;
    boolean rectangulo = false;

// Solicitud de datos al usuario
    System.out.println("Este programa muestra la clasificación de un triángulo:");
    System.out.print("Introduce el valor del lado A: ");
    ladoA = scanner.nextInt();
    System.out.print("Introduce el valor del lado B: ");
    ladoB = scanner.nextInt();
    System.out.print("Introduce el valor del lado C: ");
    ladoC = scanner.nextInt();
    
// Realizamos Cálculos y mostramos en pantalla
    // Para calcular el Teorema de Pitágoras debemos hallar en primer lugar la hipotenusa.
    // Una vez sabemos cual es el lado más largo, comprobamos Pitágoras, si se cumple
    // el valor de rectángulo pasa a true.
    if (ladoA > ladoB && ladoA > ladoC) {
      if ((Math.pow(ladoA,2)) == (Math.pow(ladoB,2)) + (Math.pow(ladoC,2))) {
        rectangulo = true;
      } 
    } else if (ladoB > ladoA && ladoB > ladoC) {
      if ((Math.pow(ladoB,2)) == (Math.pow(ladoA,2)) + (Math.pow(ladoC,2))) {
        rectangulo = true;
      } 
    } else if (ladoC > ladoA && ladoC > ladoB) {
      if ((Math.pow(ladoC,2)) == (Math.pow(ladoA,2)) + (Math.pow(ladoB,2))) {
        rectangulo = true;
      } 
    }
    
    // Una vez sabemos si es rectángulo, continuamos con el resto de comprobaciones.
    // Dos lados iguales
    if ((ladoA == ladoB && ladoA != ladoC) || (ladoA == ladoC && ladoA != ladoB)
        || (ladoB == ladoC && ladoB != ladoA)) {
      if (rectangulo) {
        System.out.println("Es un triángulo rectángulo e isósceles.");
      } else {
        System.out.println("Es un triángulo isósceles.");
      }
    // Tres lados iguales
    }else if (ladoA == ladoB && ladoB == ladoC) {
      if (rectangulo) {
        System.out.println("Es un triángulo rectángulo y equilátero.");
      } else {
        System.out.println("Es un triángulo equilátero.");
      }
    }else {
      if (rectangulo) {
        System.out.println("Es un triángulo rectángulo y escaleno.");
      } else {
        System.out.println("Es un triángulo escaleno.");
      }
    } 
    }
  }

Puedes acceder a este ejercicio en GitHub en este enlace

Si tienes alguna duda al respecto, alguna sugerencia o algo que no te haya quedado claro, no tienes más que escribirme en los comentarios, estoy aquí para ayudarte y aprender, ¡Nos leemos!