LabEx
EntrarÚnete

Resolver un Triángulo Rectángulo en C

CBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderás a resolver un triángulo rectángulo utilizando cálculos trigonométricos en el lenguaje de programación C. El laboratorio cubre los pasos esenciales necesarios para determinar los lados y ángulos desconocidos de un triángulo rectángulo, dados un conjunto de valores conocidos. Empezarás aprendiendo a leer y definir los lados y ángulos conocidos del triángulo, luego utilizarás las razones trigonométricas para calcular los valores desconocidos y, finalmente, imprimir la información faltante. Este laboratorio te proporcionará una sólida comprensión de la aplicación de los principios trigonométricos en un contexto de programación práctica.

Lectura de Lados/Ángulos Conocidos

En este paso, aprenderemos a leer y definir los lados y ángulos conocidos de un triángulo rectángulo en programación C. Comprender cómo introducir y almacenar la información del triángulo es crucial para realizar cálculos trigonométricos.

Primero, creemos un nuevo archivo C para definir la estructura de nuestro triángulo y el método de entrada:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>

// Definir una estructura para representar un triángulo rectángulo
struct RightTriangle {
    double side_a;     // Lado adyacente
    double side_b;     // Lado opuesto
    double side_c;     // Hipotenusa
    double angle_A;    // Ángulo opuesto al lado a
    double angle_B;    // Ángulo opuesto al lado b
    double angle_C;    // Ángulo recto (90 grados)
};

int main() {
    struct RightTriangle triangle;

    // Introducir valores de lados o ángulos conocidos (introducir 0 si es desconocido):
    printf("Introduzca los valores de los lados/ángulos conocidos (introduzca 0 si es desconocido):\n");

    printf("Longitud del lado a: ");
    scanf("%lf", &triangle.side_a);

    printf("Longitud del lado b: ");
    scanf("%lf", &triangle.side_b);

    printf("Longitud del lado c (hipotenusa): ");
    scanf("%lf", &triangle.side_c);

    printf("Ángulo A (en grados): ");
    scanf("%lf", &triangle.angle_A);

    printf("Ángulo B (en grados): ");
    scanf("%lf", &triangle.angle_B);

    return 0;
}

Compilamos y ejecutamos el programa para probar nuestro método de entrada:

gcc ~/project/triangle_solver.c -o ~/project/triangle_solver -lm
~/project/triangle_solver

Ejemplo de salida:

Introduzca los valores de los lados/ángulos conocidos (introduzca 0 si es desconocido):
Longitud del lado a: 3
Longitud del lado b: 4
Longitud del lado c (hipotenusa): 5
Ángulo A (en grados): 36.87
Ángulo B (en grados): 53.13

Entendiendo el Código

  1. Definimos una estructura RightTriangle para almacenar todas las posibles medidas del triángulo.
  2. La estructura incluye tres lados (a, b, c) y tres ángulos (A, B, C).
  3. Usamos scanf() para permitir que los usuarios introduzcan valores conocidos.
  4. Los usuarios pueden introducir 0 para valores desconocidos, que usaremos en pasos posteriores para calcular la información faltante.

Consideraciones de Entrada

  • Las longitudes de los lados pueden ser cualquier número real positivo.
  • Los ángulos están en grados.
  • En un triángulo rectángulo, un ángulo es siempre de 90 grados.
  • Necesitas al menos dos valores conocidos para resolver completamente el triángulo.

Uso de Razones Trigonométricas para Encontrar Incógnitas

En este paso, ampliaremos nuestro programa de resolución de triángulos para calcular lados y ángulos desconocidos utilizando razones trigonométricas. Actualizaremos el código anterior para incluir funciones para resolver triángulos rectángulos.

Modifiquemos nuestro archivo triangle_solver.c para agregar funciones de cálculo:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>

#define PI 3.14159265358979323846

struct RightTriangle {
    double side_a;     // Lado adyacente
    double side_b;     // Lado opuesto
    double side_c;     // Hipotenusa
    double angle_A;    // Ángulo opuesto al lado a
    double angle_B;    // Ángulo opuesto al lado b
    double angle_C;    // Ángulo recto (90 grados)
};

// Función para convertir grados a radianes
double to_radians(double degrees) {
    return degrees * (PI / 180.0);
}

// Función para convertir radianes a grados
double to_degrees(double radians) {
    return radians * (180.0 / PI);
}

// Calcular lados desconocidos usando razones trigonométricas
void solve_triangle(struct RightTriangle *triangle) {
    // Si la hipotenusa y un lado son conocidos, calcula el tercer lado
    if (triangle->side_c > 0 && triangle->side_a > 0 && triangle->side_b == 0) {
        triangle->side_b = sqrt(triangle->side_c * triangle->side_c - triangle->side_a * triangle->side_a);
    }

    // Si dos lados son conocidos, calcula los ángulos
    if (triangle->side_a > 0 && triangle->side_c > 0) {
        triangle->angle_A = to_degrees(asin(triangle->side_a / triangle->side_c));
        triangle->angle_B = 90.0 - triangle->angle_A;
    }

    // Si dos lados son conocidos, calcula la hipotenusa
    if (triangle->side_a > 0 && triangle->side_b > 0 && triangle->side_c == 0) {
        triangle->side_c = sqrt(triangle->side_a * triangle->side_a + triangle->side_b * triangle->side_b);
    }
}

// Imprimir información del triángulo
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nInformación del triángulo:\n");
    printf("Lado a: %.2f\n", triangle->side_a);
    printf("Lado b: %.2f\n", triangle->side_b);
    printf("Lado c (Hipotenusa): %.2f\n", triangle->side_c);
    printf("Ángulo A: %.2f grados\n", triangle->angle_A);
    printf("Ángulo B: %.2f grados\n", triangle->angle_B);
    printf("Ángulo C: 90.00 grados\n");
}

int main() {
    struct RightTriangle triangle = {0}; // Inicializar todos los valores a 0

    // Introducir valores de lados o ángulos conocidos (introducir 0 si es desconocido):
    printf("Introduzca los valores de los lados/ángulos conocidos (introduzca 0 si es desconocido):\n");

    // ... (resto del código de entrada)

    // Resolver valores desconocidos
    solve_triangle(&triangle);

    // Imprimir resultados
    print_triangle_info(&triangle);

    return 0;
}

Ahora, compilemos y ejecutemos el programa actualizado:

gcc ~/project/triangle_solver.c -o ~/project/triangle_solver -lm
~/project/triangle_solver

Ejemplo de entrada y salida:

// ... (entrada)

Información del triángulo:
Lado a: 3.00
Lado b: 4.00
Lado c (Hipotenusa): 5.00
Ángulo A: 36.87 grados
Ángulo B: 53.13 grados
Ángulo C: 90.00 grados

Entendiendo los Cálculos Trigonométricos

  1. solve_triangle() utiliza razones trigonométricas para calcular valores desconocidos:
    • Teorema de Pitágoras para cálculos de lados.
    • asin() para cálculos de ángulos.
  2. to_radians() y to_degrees() ayudan a convertir entre grados y radianes.
  3. El programa puede resolver el triángulo con varias combinaciones de entrada.

Relaciones Trigonométricas Clave

  • Seno: opuesto / hipotenusa
  • Coseno: adyacente / hipotenusa
  • Tangente: opuesto / adyacente
  • Teorema de Pitágoras: a² + b² = c²

Imprimir los Valores Faltantes

En este paso final, mejoraremos nuestro programa de resolución de triángulos para proporcionar una salida más detallada y manejar diferentes escenarios de entrada. Modificaremos el código para imprimir los valores faltantes y agregar comprobaciones de errores.

Actualiza el archivo triangle_solver.c con las siguientes mejoras:

// ~/project/triangle_solver.c
#include <stdio.h>
#include <math.h>
#include <stdlib.h>

#define PI 3.14159265358979323846
#define EPSILON 0.0001 // Valor pequeño para comparaciones de punto flotante

struct RightTriangle {
    double side_a;
    double side_b;
    double side_c;
    double angle_A;
    double angle_B;
    double angle_C;
};

// Las funciones anteriores (to_radians, to_degrees, solve_triangle) permanecen igual

// Función de impresión mejorada con detección de valores faltantes
void print_triangle_info(struct RightTriangle *triangle) {
    printf("\nResultados del Cálculo del Triángulo:\n");
    printf("------------------------------\n");

    // Imprimir lados
    printf("Lados:\n");
    if (triangle->side_a > 0) {
        printf("  Lado a: %.2f\n", triangle->side_a);
    } else {
        printf("  Lado a: FALTANTE (No se pudo calcular)\n");
    }

    if (triangle->side_b > 0) {
        printf("  Lado b: %.2f\n", triangle->side_b);
    } else {
        printf("  Lado b: FALTANTE (No se pudo calcular)\n");
    }

    if (triangle->side_c > 0) {
        printf("  Lado c (Hipotenusa): %.2f\n", triangle->side_c);
    } else {
        printf("  Lado c (Hipotenusa): FALTANTE (No se pudo calcular)\n");
    }

    // Imprimir ángulos
    printf("Ángulos:\n");
    if (triangle->angle_A > 0) {
        printf("  Ángulo A: %.2f grados\n", triangle->angle_A);
    } else {
        printf("  Ángulo A: FALTANTE (No se pudo calcular)\n");
    }

    if (triangle->angle_B > 0) {
        printf("  Ángulo B: %.2f grados\n", triangle->angle_B);
    } else {
        printf("  Ángulo B: FALTANTE (No se pudo calcular)\n");
    }

    // El ángulo C siempre es de 90 grados en un triángulo rectángulo
    printf("  Ángulo C: 90.00 grados (Ángulo Recto)\n");
}

// Función de validación de entrada
int validate_input(struct RightTriangle *triangle) {
    int valores_conocidos = 0;

    // Contar valores conocidos
    if (triangle->side_a > 0) valores_conocidos++;
    if (triangle->side_b > 0) valores_conocidos++;
    if (triangle->side_c > 0) valores_conocidos++;
    if (triangle->angle_A > 0) valores_conocidos++;
    if (triangle->angle_B > 0) valores_conocidos++;

    // Se necesitan al menos dos valores conocidos para resolver el triángulo
    if (valores_conocidos < 2) {
        printf("Error: Información insuficiente para resolver el triángulo.\n");
        printf("Necesitas proporcionar al menos dos valores conocidos.\n");
        return 0;
    }

    return 1;
}

// ... (resto del código)

Compila y ejecuta el programa:

// ... (compilación y ejecución)

Ejemplo de entrada y salida:

// ... (entrada)

Resultados del Cálculo del Triángulo:
------------------------------
Lados:
  Lado a: 3.00
  Lado b: 4.00
  Lado c (Hipotenusa): 5.00
Ángulos:
  Ángulo A: 36.87 grados
  Ángulo B: 53.13 grados
  Ángulo C: 90.00 grados (Ángulo Recto)

Mejoras Clave

  1. Función print_triangle_info() mejorada para mostrar valores faltantes.
  2. Se agregó validate_input() para verificar la información suficiente del triángulo.
  3. Manejo de errores y retroalimentación al usuario mejorados.
  4. Formato consistente para la salida.

Resultados del Aprendizaje

  • Comprender cómo manejar valores faltantes de triángulos.
  • Aprender a validar cálculos geométricos.
  • Practicar técnicas avanzadas de programación en C.

Resumen

En este laboratorio, aprendimos a leer y definir los lados y ángulos conocidos de un triángulo rectángulo en programación C. Creamos una estructura RightTriangle para almacenar todas las posibles medidas del triángulo, incluyendo los tres lados (a, b, c) y los tres ángulos (A, B, C). Luego, utilizamos scanf() para permitir a los usuarios introducir valores conocidos, con la opción de ingresar 0 para valores desconocidos. Este paso es crucial para realizar cálculos trigonométricos y encontrar los valores faltantes en la siguiente parte del laboratorio.

Después de definir el método de entrada, el siguiente paso es utilizar las razones trigonométricas para calcular los lados o ángulos desconocidos basándose en la información conocida. El paso final es imprimir los valores faltantes, proporcionando al usuario una solución completa al problema del triángulo rectángulo.

Relacionado C Cursos
Programación en C para Principiantes

Programación en C para Principiantes

c
Construir Flappy Bird con C

Construir Flappy Bird con C

c
Creación de una calculadora simple utilizando C

Creación de una calculadora simple utilizando C

c