En una pasada entrega vimos cómo calcular el biotipo de una persona en Java. Ahora lo haremos usando el lenguaje de programación C.
Pero, ¿Qué es el biotipo de una persona?
Es la forma característica de un animal o planta. Es el aspecto general de un sujeto de acuerdo a sus características somáticas o morfológicas y se basa en los datos que refleja su estructura corporal, en todo lo que se ve y se puede medir de su cuerpo.
Se refiere a las características corporales, como la estructura ósea, la musculatura y la predisposición al metabolismo, que influyen en la salud, el rendimiento físico y la respuesta a la dieta o ejercicio.
Establece que hay una relación entre las características físicas y la personalidad. Esto ya lo habiamos mencionado en la entrega pasada.
Para el programa en C:
- Crearemos un archivo de encabezado: biotipo.h
- Un archivo donde tendremos las funciones necesarias para los cálculos: biotipo.c
- Un programa main: main.c
Existen varios biotipos, pero el general comprende estos tres:
- Ectomorfo: Cuerpo delgado, extremidades largas, dificultad para ganar peso o masa muscular, metabolismo rápido. En otras palabras, sería Longitipo
- Mesomorfo: Cuerpo atlético, facilidad para ganar músculo, estructura ósea equilibrada, metabolismo eficiente. En otras palabras, sería Normotipo.
- Endomorfo: Cuerpo con mayor tendencia a acumular grasa, estructura más ancha, metabolismo más lento. En otras palabras, sería Braquitipo.
El programa comprenderá dos "hashmap", hechos con estructuras. Uno para los pesos y el otro para las estaturas.
biotipos.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Estructura para simular el HashMap (clave-valor)
typedef struct {
char *clave;
double valor;
} ParClaveValor;
// Listas de pares clave-valor para peso y estatura
ParClaveValor mapaPeso[] = {
{"85.54", 3.0}, {"83.79", 2.75}, {"82.04", 2.5}, {"80.29", 2.25},
{"78.54", 2.0}, {"76.79", 1.75}, {"75.04", 1.5}, {"73.29", 1.25},
{"71.54", 1.0}, {"69.79", 0.75}, {"68.04", 0.50}, {"66.29", 0.25},
{"64.54", 0.0}, {"62.79", -0.25}, {"61.04", -0.50}, {"59.29", -0.75},
{"57.54", -1.0}, {"55.79", -1.25}, {"54.04", -1.50}, {"52.29", -1.75},
{"50.54", -2.0}, {"45.79", -2.25}, {"47.04", -2.5}, {"45.29", -2.75},
{"43.54", -3.0}
};
ParClaveValor mapaEstatura[] = {
{"1.87", 3.0}, {"1.86", 2.75}, {"1.85", 2.50}, {"1.83", 2.23},
{"1.82", 2.0}, {"1.81", 1.75}, {"1.79", 1.50}, {"1.78", 2.25},
{"1.77", 1.0}, {"1.75", 0.75}, {"1.74", 0.50}, {"1.73", 0.25},
{"1.71", 0.0}, {"1.7", -0.25}, {"1.69", -0.50}, {"1.67", -0.75},
{"1.66", -1.0}, {"1.65", -1.25}, {"1.63", -1.50}, {"1.62", -1.75},
{"1.61", -2.0}, {"1.59", -2.25}, {"1.58", -2.50}, {"1.57", -2.75},
{"1.55", -3.0}
};
// Tamaños de los mapas
const int TAMANO_PESO = sizeof(mapaPeso) / sizeof(mapaPeso[0]);
const int TAMANO_ESTATURA = sizeof(mapaEstatura) / sizeof(mapaEstatura[0]);
// Función para buscar el valor asociado a una clave en el mapa
double buscarValor(ParClaveValor mapa[], int tamano, const char *clave) {
for (int i = 0; i < tamano; i++) {
if (strcmp(mapa[i].clave, clave) == 0) {
return mapa[i].valor;
}
}
return -999.0; // Valor por defecto si no se encuentra la clave
}
// Función para obtener el peso (equivalente a getPeso en Java)
double obtenerPeso(const char *peso) {
return buscarValor(mapaPeso, TAMANO_PESO, peso);
}
// Función para obtener la estatura (equivalente a getTalla en Java)
double obtenerEstatura(const char *estatura) {
return buscarValor(mapaEstatura, TAMANO_ESTATURA, estatura);
}
int main() {
char peso[10], estatura[10];
double valorPeso, valorEstatura, desviacion;
// Solicitar entrada al usuario
printf("Tu peso es de (ejemplo: 56.00): ");
fgets(peso, sizeof(peso), stdin);
peso[strcspn(peso, "\n")] = 0; // Eliminar el salto de línea
printf("Tu estatura es de (ejemplo: 1.55): ");
fgets(estatura, sizeof(estatura), stdin);
estatura[strcspn(estatura, "\n")] = 0; // Eliminar el salto de línea
// Obtener los valores asociados a peso y estatura
valorPeso = obtenerPeso(peso);
valorEstatura = obtenerEstatura(estatura);
printf("valor peso: %.1f\n", valorPeso);
printf("valor estatura: %.1f\n", valorEstatura);
// Verificar si se encontraron los valores
if (valorPeso == -999.0 || valorEstatura == -999.0) {
printf("Error: Peso o estatura no válidos. Asegúrate de ingresar valores dentro del rango permitido.\n");
return 1;
}
// Calcular la desviación
desviacion = valorPeso - valorEstatura;
// Determinar el biotipo y mostrar el resultado
if (desviacion < 0) {
printf("Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil. \n");
} else if (desviacion > 0) {
printf("Tu biotipo es: braquitipo. Sobrepeso. Acumula grasas. Puede ganar musculatura si realiza ejercicio.\n");
} else {
printf("Tu biotipo es: normotipo. Fuerte. Atlético. Musculoso\n");
}
return 0;
}
Compilación y ejecución:
$ gcc -o biotipos.exe biotipos.c
$ ./biotipos.exe
Salida:
Tu peso es de (ejemplo: 56.00): 43.54
Tu estatura es de (ejemplo: 1.55): 1.61
valor peso: -3.0
valor estatura: -2.0
Tu biotipo es: longitipo. Largo. Delgado. De apariencia frágil.
El programa requiere ciertos ajustes para permitir otras entradas de estatura y peso.
Enlaces:
https://codemonkeyjunior.blogspot.com/2013/03/determinar-el-biotipo-de-una-persona-en.html
