Tag Archives: triángulos

Calcular ángulos de un triángulo en C++

En el post anterior vimos cómo saber si un triángulo es rectángulo, acutángulo u obtusángulo en C++, y les anticipé que haría una nueva versión del mismo programa pero que nos calculara además los ángulos del triángulo.

El programa es este.

#include
#include
using namespace std;

#define PI 3.14159265 // nuNcA cAmbieZz we!!
int main()
{
    float a, b, c, A, B, C;
    cout <> a;
    cout <> b;
    cout <> c;
    A = acos((b*b+c*c-a*a)/(2*b*c))*180/PI;
    B = acos((a*a+c*c-b*b)/(2*a*c))*180/PI;
    C = acos((a*a+b*b-c*c)/(2*a*b))*180/PI;
    if(A == 90 || B == 90 || C == 90)
        cout << "El triangulo es rectangulo. ";
    if(A < 90 && B < 90 && C < 90)
        cout < 90 || B > 90 || C > 90)
        cout << "El triangulo es obtusangulo. ";
    cout << "nY sus angulos son: A:" << A << " , B:" << B << " y C:" << C;

    cin.get();cin.get();
}

Para calcular los ángulos utilizamos la ley de cosenos, de hecho en el anterior también lo utilizamos pero no completamente (la ley de cosenos es una ‘ampliación’ del teorema de pitágoras). La ley de cosenos la vemos comúnmente como:
a2 = b2 + c2 -2(b*c)*cos(A)
Si la despejamos en cos(A), nos queda:
cos(A) = (b2 + c2 - a2) / 2(b*c)
Si despejamos A (o sea el ángulo), obtenemos:
A = arccos(b2 + c2 - a2 / 2(b*c))
Que es lo que utilizamos calcular los ángulos, lamentablemente la función que nos da C++ en su librería math.h, acos() nos devuelve el resultado en radianes. Para convertirlo a grados solo tenemos que multiplicar el resultado por 180/PI. Ahora que ya tenemos los tres ángulos de nuestro triángulo, es facilísimo saber cuando es cada tipo de triángulo.

La función acos() está en la librería math.h y sirve para encontrar el arco coseno. En esta librería hay muchas funciones muy útiles: math.h

Otro detalle sencillo pero que no habíamos visto es el asunto de PI. Al principio del programa nos encontramos con:
#define PI 3.14159265
Esto significa que estamos declarando una constante con el nombre PI y con un valor de 3.14159265. Una constante, como su nombre lo indica, nunca cambia a lo largo del programa.

Bueno, pues fue un programa bastante entretenido, me gustó hacerlo 🙂

Advertisements

Saber si un triángulo es rectángulo, acutángulo u obtusángulo en C++

Emanuel por medio de un comentario me pidió ayuda para hacer un programa en c++ que nos dijera si un triángulo es rectángulo, acutángulo u obtusángulo pidiendo solamente los lados. El programa me pareció interesante de hacer y pues lo hice 🙂

El programa resulta bastante sencillo, pero para deducir cómo hacerlo está un poco complicado. Veamos la siguiente imágen:

Triángulos

El triángulo 1 es un clásico triángulo rectángulo. Si aumentáramos el lado c de 5 a 6 obviamente el ángulo aumentaría y por lo tanto sería un triángulo obtusángulo (2). Si por el contrario, disminuyéramos el lado de c 5 a 4, el ángulo disminuiría y por lo tanto sería un triángulo acutángulo (3).

Sabiendo esto veamos cómo se comporta Pitágoras en cada caso (o sea no él, su teorema):

Si despejamos su famoso teorema obtenemos que a2 + b2 – c2 = 0.

Veamos como se comporta este teorema en nuestro triángulo 1:
32 + 42 - 52 = 0
¡Listo!, ya sabemos que el triángulo es rectángulo, porque el teorema de Pitágoras sólo sirve para triángulos rectángulos.

Ahora con el triángulo 2 (obtusángulo):
32 + 42 - 62 = -11
¡Un número negativo! Con los triángulos obtusángulos el teorema de Pitágoras da números negativos.

Y por último el triángulo 3 (acutángulo):
32 + 42 - 42 = 9
¡Un número positivo! Con los triángulos acutángulos el teorema de Pitágoras da números positivos.

Ahora que ya sabemos cómo identificar cada triángulo nos surge otro problema: El usuario sólo va a introducir tres lados cualquiera, ¿cómo saber cual es a, cual es b y cual es c? Pues no hay forma de saberlo, hay que hacer cada paso tres veces tomando el teorema como a2 + b2 – c2, luego a2 + c2 – b2 y al final b2 + c2 – a2.

Ahora si, veamos el programa:

#include
using namespace std;

int main()
{
    int a, b, c, A, B, C;
    cout <> a;
    cout <> b;
    cout <> c;
    A = (b*b+c*c-a*a);
    B = (a*a+c*c-b*b);
    C = (a*a+b*b-c*c);
    if(A == 0 || B == 0 || C == 0)
        cout < 0 && B > 0 && C > 0)
        cout << "El triangulo es acutangulo. ";
    if(A < 0 || B < 0 || C < 0)
        cout << "El triangulo es obtusangulo. ";

}

La única parte no explicada es la de las condiciones. Si en cualquiera de los tres formas de tomar el teorema nos resulta 0 es rectángulo, por lo tanto se usa ||. Para ser acutángulo, las tres formas del teorema deben ser mayores a 0, se usa &&. Con una sola forma del teorema que resulte menor a 0 es obtusángulo, se usa ||. Para mayor información de esos operadores leer esto: Operadores lógicos es C++.

¿Cómo ven el programita? Está sencillo ¿no? Tal vez después haga una modificación para que además te calcule los ángulos del triángulo.

Triángulo de Pascal en C++

¿Han escuchado eso de que en el triángulo de pascal cada número es la suma de los dos que están sobre él? ¡PUES LES HAN MENTIDO!, eso no es más que una coincidencia y la forma mas fácil de escribirlo en el pizarrón. En realidad el triángulo de pascal es una matriz donde cada elemento es el coeficiente binomial o combinación de sus coordenadas. Las pruebas.

El caso es que para obtener el triángulo de pascal en c++ hay muchas formas, pero la que está a continuación yo la considero especial porque está basada en su propia definición.

#include
using namespace std;

int factorial(int n)
{
    if(n<2)
        return 1;
    else
        return n * factorial(n-1);
}

int combinacion(int n, int r)
{
    if(r==1)
        return n;
    else
    {
        if(n==r)
            return 1;
        else
            return factorial(n) / (factorial(r) * factorial(n - r));
    }
}

int main()
{
    for(int i=0; i<=6; i++)
    {
        for(int ii=0; ii<=i; ii++)
            cout << combinacion(i, ii) << "  ";
        cout << endl;
    }
    return 0;
}

Vamos analizándolo:

1. La primera función es para obtener el factorial de forma recursiva.

2. La segunda es para obtener el coeficiente binomial o combinación de dos números, es en esencia esta fórmula:
C(n,r) = n! / r!(n-r)!
Mas información sobre coeficientes binomiales.

3. En el main hay dos ciclos que se encargan de armar una matriz para obtener el coeficiente binomial de cada uno de ellos.

  • La primera pareja de numeros es (0,0) y su combinación es 1. Nuestro primer numero del triangulo de pascal.
  • La siguiente es (1,0) y luego (1,1) cuyas combinaciones son 1 y 1. Segunda línea.
  • Luego tenemos (2,0) (2,1) y (2,2) cuyas combinaciones son 1, 2 y 1. Tercera linea
  • Y así seguimos obteniendo nuestras líneas.

Y pues así es, el que me diga que no tiene forma de triángulo está ciego, porque si es triángulo, lo que pasa es que no es isósceles.

Programa: ¿Qué tipo de triángulo es?

Ok, hasta hoy ya hemos visto las herramientas necesarias para hacer nuestro primer programa un poco más en serio. Este programa nos pide la medida de los tres lados de un triángulo y nos devuelve el tipo de triangulo que es (equilátero, isósceles o escaleno).

Para esto vamos a usar condiciones en C++ para comparar los lados de nuestro triángulo.

Un tríangulo equilátero tiene sus tres lados iguales, por tanto, la condición quedaría así:

“si el lado 1 es igual al lado 2 y el lado 2 es igual al lado 3, entonces es equilátero”

Un tríangulo isósceles tiene solo dos lados iguales, por tanto, la condición quedaría así:

“si el lado 1 es igual al lado 2 y el lado 2 es diferente al lado 3, o
el lado 2 es igual al lado 3 y el lado 3 es diferente al lado 1, o
el lado 3 es igual al lado 1 y el lado 1 es diferente al lado 2 entonces es isósceles”

Un tríangulo escaleno tiene sus tres lados diferentes, por tanto, la condición quedaría así:

“si el lado 1 es diferente al lado 2 y el lado 2 es diferente al lado 3 y el lado 3 es diferente al lado 1, entonces es escaleno”

Pero vamos a lo bueno. El programa completo en C++, sería así:

#include<stdio.h>
#include<conio.h>
int main()
{
  //Declaracion de variables
  int lado1=0,lado2=0,lado3=0;

  //Pedir los datos
  printf("TIPOS DE TRIANGULOS");
  printf("nIntroduce el lado 1: ");scanf("%i",&lado1);
  printf("nIntroduce el lado 2: ");scanf("%i",&lado2);
  printf("nIntroduce el lado 3: ");scanf("%i",&lado3);

  //Hacer comparaciones
  if(lado1==lado2 && lado2==lado3)
  { printf("ntEs equilatero"); }
  if(lado1==lado2 && lado2!=lado3 || lado2==lado3 && lado3!=lado1 || lado3==lado1 && lado1!=lado2)
  { printf("ntEs isosceles"); }
  if(lado1!=lado2 && lado2!=lado3 && lado3!=lado1)
  { printf("ntEs escaleno"); }

  //Pausa
  getch();
}

Aprovecho para explicarles un detalle más. n (alt+92 n) dentro de un printf(); indica un salto de línea, y t (alt+92 t) indica una sangría o tabulado o algo de espacio.