Practica sobre tipos enumerados, typedef y struct

1. Dada la siguiente especificacin:

TIPO REGISTRO ASIGNACIN =
REAL TRANSPORTE;
REAL COMIDA;
REAL VACACIONES;
FREGISTRO
TIPO REGISTRO DEDUCCIN =
REAL SEGURO;
REAL AH; //Ahorro Habitacional
FREGISTRO
REGISTRO EMPLEADO =
ENTERO CODIGO;
ENTERO ACTIVO;
CARACTER SEXO;
REAL SUELDO_HORA;
ENTERO HORAS_TRAB;
ASIGNACIN AS;
DEDUCCIN DE;
FREGISTRO
Realice un programa que permita:
a) Declarar una variable de tipo EMPLEADO.
b) Inicializar cada campo del registro., con datos de un empleado
c) Calcular el sueldo de ese empleado, dado que ST = (SH * HT) + A D, siendo
las variables las siguientes: ST = Sueldo Total, SH = Sueldo por Hora, HT =
Horas Trabajadas, A = Asignaciones, D = Deducciones
SOLUCION:
#include <stdio.h>
main() {
typedef struct {
float transporte, comida, vacaciones;
} asignacion;
typedef struct {
float seguro, AH;
} deduccion;
typedef struct {
int codigo, activo;
char sexo;
float sueldo_hora;
int horas_trab, asignacionAS, deduccionDE;
} empleado;
empleado e;
float sueldo_total;

e.codigo=110;
e.activo=1;
e.sexo='M';
e.sueldo_hora=25000.0;
e.horas_trab=30;
e.asignacionAS=100000;
e.deduccionDE=50000;
sueldo_total=(e.sueldo_hora*e.horas_trab)+e.asignacionASe.deduccionDE;
printf("Sueldo total del empleado %d es %f\n",e.codigo,
sueldo_total);
}

2. Consideremos que por cada alumno de una universidad debemos almacenar la

siguiente informacin:
- matricula del alumno (entero)
- Nombre del alumno (cadena de caracteres)
- Carrera del alumno (cadena de caracteres)
- Promedio del alumno (real)
- Direccin del alumno (cadena de caracteres)
Escriba un programa en C donde defina una estructura de datos tipo Registro para
almacenar este tipo de informacin por alumno. Use un arreglo unidimensional para
almacenar datos e N alumnos. Escriba una funcin Leer_alumnos, que le permita leer
los datos de N alumnos dados, N pasa como argumento a la funcin, as como el arreglo
unidimensional de alumnos.
SOLUCION:
#include <stdio.h>
#define MAX
50
#define MAXN 80
/* se declara prototipo de la funcion */

void Leer_alumnos ( int num )

/* se define el Registro a Usar para los datos por alumno*/
typedef struct {
int matricula;
char nombre[MAX];
char carrera[MAX];
float promedio;
char direccion[MAX];
} alumno;
/* NOTA: se define el arreglo unidimensional alumnos, como variable
GLOBAL */
alumno alumnos[MAXN];
void main() {
int n;
/* leer para cuantos alumnos vamos a leer datos */
printf( Introduzca numero de alumnos\n);
scanf(%d,&n);

/* llama a la funcion para leer los datos de cada alumno, desde 1 hasta n */
Leer_alumnos( n );

} /* fin del main */

/* se define la funcion que permite llenar de datos nuestro arreglo alumnos */
void Leer_alumnos ( int num )
{
int i;
for ( i=0; i < num; i++ )
{
printf(Introduzca la matricula del alumno %d\n);
scanf(%d, &alumnos[i].matricula );
printf(Ingrese el nombre del alumno %f\n);
gets( alumno[i].nombre );
printf(Ingrese la carrera del alumno %f\n);
gets( alumno[i].carrera );
printf(Introduzca el promedio del alumno %f\n);
scanf(%f, &alumnos[i].promedio );
printf(Ingrese la direccion del alumno %f\n);
gets( alumno[i].direccion );
}
} /* fin de la funcion */

3. Siguiendo con el mismo ejercicio 2, permita que la direccion contenga otros campos
de datos mas elaborados, tales como :
- Calle (entero)
- Localidad (cadena de caracteres)
- CodigoPostal (cadena de caracteres)
- Ciudad (cadena de caracteres)
Definas esta nueva estructura, y realice los cambios necesarios en el programa anterior
para permitir introducir estos datos en el campo direccin de cada alumno.
SOLUCION:
Se trata de construir una nuevo registro y cambiar el anterior usando el concepto de
registros anidados, se debe cambiar el proceso de lectura para leer datos para estos
campos.
4. Usando el concepto de funcin recursiva, reescriba el programa del ejercico No 6
de la Practica4-sem5, 6.
La serie de Fibonacci se define de la siguiente manera an
= an-1 + an-2. Con a0=0 y a1=1. Elabore un programa que determine el trmino ax de
la serie.
SOLUCIN:
#include <stdio.h>
/* se declara prototipo de la funcion recursiva */
double Fibonacci( int number );
main()
{
int x; // Entrada

// PRE: x entero positivo

double ax; // Salida
// POST: ax es el elemento x de la serie de Fibonacci
int i;
printf(Introduzca un entero positivo:);
scanf(%d,&x);
ax = Fibonacci( x );
printf(El elemento %d de la serie es %d ,x,ax);
} /* fin del main */
/* se define la funcin recursiva */
double Fibonacci( int number )
{
if ( number == 0 || number == 1)
return number;
else return Fibonacci( number -1 ) + Fibonacci( number -2 );
} /* fin de la function */
5. Un consultorio medico realiza el diagnstico de las posibles enfermedades que sufren
sus pacientes confrontando la informacin de los sntomas que presenta el paciente con
informacin de los sntomas que caracterizan las enfermedades por ellos registradas,
As, a un paciente se le diagnostica una enfermedad si sus sntomas coinciden
exactamente con los registrados para esa enfermedad.
Considerando que dicho consultorio tiene caracterizadas a M enfermedades con a lo
sumo N sntomas cada una. Suponga que se tiene las siguientes definiciones de tipos y
declaraciones de variables:
#define
#define
#define
#define
#define
#define

TotalEnfermedades 100
TotalSintomas 50
LongNombre 20
LongEnfermedad 30
LongSintomas 20
NumeroPacientes 200

typedef struct {
char nombre[LongNombre];
char sexo;
char enfermedad[LongEnfermedad];
int cantidadSintomas;
char sintomas[TotalSintomas][LongSintomas];
} PACIENTE;
typedef struct {
char enfermedad[LongEnfermedad];
int cantidadSintomas;
char sintomas[TotalSintomas][LongSintomas];
} ENFERMEDAD;
PACIENTE pacientes[NumeroPacientes];
ENFERMEDAD SintomasEnfermedad[TotalEnfermedades];

Suponiendo que dichas variables ha sido inicializada. Escriba un trozo de cdigo en

lenguaje C para determinar:
a) La enfermedad ms frecuente.
b) Cantidad de pacientes con cada una de las enfermedades.
RESPUESTA: El programa completo sera
#include <stdio.h>
#include "string.h"
#define TotalEnfermedades 100
#define TotalSintomas 50
#define LongNombre 20
#define LongEnfermedad 30
#define LongSintomas 20
#define NumeroPacientes 200
main(){
typedef struct {
char nombre[LongNombre];
char sexo;
char enfermedad[LongEnfermedad];
int cantidadSintomas;
char sintomas[TotalSintomas][LongSintomas];
} PACIENTE;
typedef struct {
char enfermedad[LongEnfermedad];
int cantidadSintomas;
char sintomas[TotalSintomas][LongSintomas];
} ENFERMEDAD;
PACIENTE pacientes[NumeroPacientes];
ENFERMEDAD SintomasEnfermedad[TotalEnfermedades];
int contadorEnfermedad[TotalEnfermedades];
int i,j,k,l,sint,pacientesActuales,enfermedadesActuales;
/* Algunas enfermedades ..*/
strcpy(SintomasEnfermedad[0].enfermedad,"x-osis");
SintomasEnfermedad[0].cantidadSintomas=3;
strcpy(SintomasEnfermedad[0].sintomas[0],"discusion");
strcpy(SintomasEnfermedad[0].sintomas[1],"vehemencia");
strcpy(SintomasEnfermedad[0].sintomas[2],"acalorado");
strcpy(SintomasEnfermedad[1].enfermedad,"x-titis");
SintomasEnfermedad[1].cantidadSintomas=4;
strcpy(SintomasEnfermedad[1].sintomas[0],"felicidad");
strcpy(SintomasEnfermedad[1].sintomas[1],"fortaleza");
strcpy(SintomasEnfermedad[1].sintomas[2],"tranquilidad");
strcpy(SintomasEnfermedad[1].sintomas[3],"sosiego");
strcpy(SintomasEnfermedad[2].enfermedad,"x-ardia");
SintomasEnfermedad[2].cantidadSintomas=2;
strcpy(SintomasEnfermedad[2].sintomas[0],"agilidad");
strcpy(SintomasEnfermedad[2].sintomas[1],"rapidez");
/* Pacientes ...*/
strcpy(pacientes[0].nombre,"Wilmer");
pacientes[0].sexo='M';

pacientes[0].cantidadSintomas=4;
strcpy(pacientes[0].enfermedad,"");
strcpy(pacientes[0].sintomas[0],"tranquilidad");
strcpy(pacientes[0].sintomas[1],"sosiego");
strcpy(pacientes[0].sintomas[2],"felicidad");
strcpy(pacientes[0].sintomas[3],"fortaleza");
strcpy(pacientes[1].nombre,"otro");
pacientes[1].sexo='M';
pacientes[1].cantidadSintomas=3;
strcpy(pacientes[1].enfermedad,"");
strcpy(pacientes[1].sintomas[0],"cansancio");
strcpy(pacientes[1].sintomas[1],"ansiedad");
strcpy(pacientes[1].sintomas[2],"mareo");
/* Hacer el diagnostico ... */
pacientesActuales=2;
enfermedadesActuales=3;
sint=0;
for (i=0;i<pacientesActuales;i++)
for (j=0;j<enfermedadesActuales;j++) {
for (k=0;k<pacientes[i].cantidadSintomas;k++)
for (l=0;l<SintomasEnfermedad[j].cantidadSintomas;l++)
if (!
strcmp(pacientes[i].sintomas[k],SintomasEnfermedad[j].sintomas[l]))
sint++;
if (sint==SintomasEnfermedad[j].cantidadSintomas)
strcpy(pacientes[i].enfermedad,SintomasEnfermedad[j].enfermedad);
}
/* Contar los pacientes con determinada enfermedad */
for (i=0;i<enfermedadesActuales;i++) {
contadorEnfermedad[i]=0;
for (j=0;j<pacientesActuales;j++)
if (!
strcmp(SintomasEnfermedad[i].enfermedad,pacientes[j].enfermedad))
contadorEnfermedad[i]++;
}
/* Buscar cual es la enfermedad mas frecuente */
int maxEnfermedad=0;
int enf=2;
for (i=0;i<enfermedadesActuales;i++)
if (contadorEnfermedad[i]>maxEnfermedad) {
maxEnfermedad=contadorEnfermedad[i];
enf=i;
}
printf("La enfermedad mas frecuente es
%s\n",SintomasEnfermedad[enf].enfermedad);
/* Cuenta los enfermos por enfermedad */
for (i=0;i<enfermedadesActuales;i++)
printf("%s = %d
veces\n",SintomasEnfermedad[i].enfermedad,contadorEnfermedad[i]);
}