Curso: Fundamentos de Programacion Estructuras

_______________________________________________________________
Estructuras (struct)
Una estructura (struct) es un tipo de dato definido por el usuario. Las estructuras son
similares a los registros utilizados en otros lenguajes de programación.
Una estructura es un tipo de dato estructurado que consta de un conjunto de elementos
que pueden ser del mismo tipo o de tipos diferentes
Los componentes de una estructura se denominan campos. Cada campo tiene un nombre
llamado identificador de campo que es algún identificador elegido por el programador
cuando se declara la estructura.

Definición de una estructura

La sintaxis para definir una estructura es la siguiente:

Struct nombreEstructura{
TipodeDato1 campo1;
TipoDeDato2 campo2:
TipoDeDato3 campo3;

TipoDeDaton campon;
};

Lo que se esta definiendo es un Nuevo tipo de Dato llamado nombreEstruc tura que tiene un
conjunto de campos.

Ejemplos:
- Declarar una estructura llamada Producto con los siguientes campos : codigo, nombre,
precio, stock.

struct Producto{
char codigo[10];
char nombre[60];
float precio;
int stock;
};

-Declarar la Estructura Empleado con los siguientes campos : Apellidos, nombres, sueldo.

struct Empleado{
char apellidos[30];
char nombres[30];
float sueldo;
};

- Declarar la Estructura Punto con campos x e y.

struct Punto{
float x;
float y;
};

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 1
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
Variables Tipo Estructura
Al declarar la estructura se ha creado un nuevo tipo de dato, pero no se ha declarado
variables de ese tipo.
Para declarar variables se puede hacer de la siguiente manera:

Producto prod1,prod2, prod3;

Se ha declarado 3 variables tipo producto.

También se puede declarar la estructura y automáticamente declarar variables.

struct Producto{
String codigo;
String nombre;
float precio;
int stock;
} prod1, prod2, prod3;

Acceso a los campos de una Estructura

El acceso a los miembros de una estructura se realiza mediante el operador punto (.)

Por ejemplo si declaramos la variable X de tipo producto

Producto X;

Para acceder a sus campos se hace de la siguiente manera

strcpy(X.codigo, ”pr001”);
strcpy(X.nombre, ”ace”);
X.precio = 1.5;
X.stock = 200;

Operaciones sobre Estructuras

Una operación que se puede realizar entre estructuras es la asignación (copia del contenido
de una estructura en otra estructura del mismo tipo). Si A y D son variables tipo
estructura del mismo tipo, la Sentencia
A=D;
Copia todo los valores asociados de la variable D a la variable A.
Ejemplo:
Punto P1, P2;
P1.x=10;
P1.y=20;

La sentencia de asignación
P2=P1
Equivale a :
P2.x = P1.x;
P2.y=P1.y;

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 2
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
No se puede comparar completamente una variable tipo estructura con otra.
Por ejemplo si se tiene dos variables A y B de tipo estructura

Punto A, B;

No se puede hacer esto: if(A==B)

Si se quiere comparar se tiene que hacer campo por campo

If(A.x==B.x && A.y==B.y)

Estructuras Anidadas
Es posible declarar una estructura con campos que sean otras estructuras. Una estructura
con uno o mas campos que son tipo estructura se llaman registro jerárquico o anidado.

Ejemplo:
struct NombreEmp{
char apellidos[30];
char nombre[30];
};

struct CalleNumero{
char calle[40];
int numero;
};

Struct Empleado{
NombreEmp nombre;
CalleNumero dir;
};

Acceso a los registros Anidados

Para referenciar un campo en estructuras anidadas se debe indicar el camino a seguir en
orden jerárquico desde el nombre de la estructura raíz hasta el campo específico.
Ejemplo:

Empleado E;

strcpy(E.nombre.apellidos,“Juan”);
strcpy(E.nombre.apellidos, “Peréz”);
strcpy(E.dir.calle, “Zela”);
E.dir.numero= 254

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 3
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________

Ejercicios Resueltos
1) Programa para ingresar las coordenadas de 2 puntos del plano cartesiano. Reportar la
distancia que hay entre ellos y la ecuación de la recta que pasa por ellos.
#include<iostream>
#include<math.h>
using namespace std;
struct Punto{
float x;
float y;
};

void ingresoPunto(Punto &P,char mensaje[]);

float distancia(Punto P1, Punto P2);

int main()
{
Punto P1, P2;
ingresoPunto(P1,"Primer Punto");
ingresoPunto(P2,"Segundo Punto");
cout<<"La distancia entre los puntos es : "<<distancia(P1,P2)<<endl;
system("pause");
return 0;
}

void ingresoPunto(Punto &P,char mensaje[])

{
cout<<mensaje<<endl;
cout<<"Valor de x : ";
cin>>P.x;
cout<<"Valor de y : ";
cin>>P.y;
}

float distancia(Punto P1, Punto P2)

{
return sqrt(pow(P1.x-P2.x,2)+pow(P1.y-P2.y,2));
}

2) Hacer un programa para ingresar 2 complejos y reporte la suma, resta, multiplicación y

división de ellos.

#include<iostream>
#include<math.h>
using namespace std;
struct Complejo{
float real;
float imag;
};

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 4
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________

void ingresoComplejo(Complejo &C, char mensaje[]);

Complejo suma(Complejo C1, Complejo C2);
Complejo resta(Complejo C1, Complejo C2);
Complejo multiplicacion(Complejo C1, Complejo C2);
Complejo division(Complejo C1, Complejo C2);
void reporteComplejo(Complejo C,char mensaje[]);
int main()
{
Complejo C1, C2,CS,CR,CM,CD;
ingresoComplejo(C1,"Primer Complejo");
ingresoComplejo(C2,"Segundo Complejo");
CS=suma(C1,C2);
CR=resta(C1,C2);
CM=multiplicacion(C1,C2);
CD=division(C1,C2);
reporteComplejo(CS,"Complejo Suma");
reporteComplejo(CR,"Complejo Resta");
reporteComplejo(CM,"Complejo Multiplicacion");
reporteComplejo(CD,"Complejo Divisi¢n");
system("pause");
return 0;
}

void ingresoComplejo(Complejo &C, char mensaje[])

{
cout<<mensaje<<endl;
cout<<"Parte real : ";
cin>>C.real;
cout<<"Parte imaginaria : ";
cin>>C.imag;
}
Complejo suma(Complejo C1, Complejo C2)
{
Complejo S;
S.real=C1.real+C2.real;
S.imag=C1.imag+C2.imag;
return S;
}

Complejo resta(Complejo C1, Complejo C2)

{
Complejo R;
R.real=C1.real-C2.real;
R.imag=C1.imag-C2.imag;
return R;
}

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 5
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
Complejo multiplicacion(Complejo C1, Complejo C2)
{
Complejo M;
M.real=C1.real*C2.real-C1.imag*C2.i mag;
M.imag=C1.imag*C2.real+C1.real+C2.i mag;
return M;
}

Complejo division(Complejo C1, Complejo C2)

{
Complejo D;
float den;
den=pow(C2.real,2)+pow(C2.imag,2);
D.real=(C1.real*C2.real+C1.imag*C2.i mag)/den;
D.imag=(C1.imag*C2.real-C1.real+C2.i mag)/den;
return D;
}
void reporteComplejo(Complejo C,char mensaje[])
{
cout<<mensaje<<endl;
cout<<C.real;
if(C.imag>0) cout<<"+";
cout<<C.imag<<"i"<<endl;
}

3) Hacer un programa para ingresar los nombres y las notas de los alumnos de Lenguaje de
Programación y se reporte:
a) Una Lista en orden Alfabético
b) Una Lista en orden de Merito.

#include<iostream>
#include<string.h>

using namespace std;

struct Alumno{
char nombre[40];
float nota;
};

void numAlumnos(int &n);

void ingreso(Alumno A[], int n);
void reporte(Alumno A[], int n);
void ordenAlfabetico(Alumno A[], int n);
void ordenMerito(Alumno A[], int n);

int main()
{
Alumno A[100];

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 6
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
int n;
numAlumnos(n);
ingreso(A,n);
ordenAlfabetico(A,n);
cout<<"Lista en orden alfabetico"<<endl;
reporte(A,n);
ordenMerito(A,n);
cout<<"Lista en orden de Merito"<<endl;
reporte(A,n);
system("pause");
return 0;
}

void numAlumnos(int &n)

{
do{
cout<<"Numero de alumnos : ";
cin>>n;
}while(n<=0);
}
void ingreso(Alumno A[], int n)
{
int i;
for(i=0;i<n;i++)
{
cout<<"Datos del alumno"<<i+1<<endl;
cout<<"Nombre : ";
cin.get();
cin.getline(A[i].nombre,40);
do{
cout<<"Nota : ";
cin>>A[i].nota;
}while(A[i].nota<0 || A[i].nota>20);
}
}

void reporte(Alumno A[], int n)

{
int i;
for(i=0;i<n;i++)
cout<<A[i].nombre<<"\t "<<A[i].nota<<endl;
}

void ordenAlfabetico(Alumno A[], int n)

{
int i,j;
Alumno temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 7
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
if(strcmp(A[i].nombre,A[j].nombre)>0)
{
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}

void ordenMerito(Alumno A[], int n)

{
int i,j;
Alumno temp;
for(i=0;i<n-1;i++)
for(j=i+1;j<n;j++)
if(A[i].nota<A[j].nota)
{
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}

4) Dada una colección de puntos (xi,yi), i=1, 2, ....,n, existe una recta L : y = Mx + B para la
cual es mínima la suma de los cuadrados de las distancias de los puntos a la recta.
Así, L constituye la recta mas próxima a los puntos dados, y puede ser utilizada para
estimar valores aproximados (x,y)
Escríbase un programa que permita hallar la recta de regresión asociada a una colección
de datos.
Los coeficientes M y B son dados por las formulas:

N * SXY - SX * SY
M = ───────────────────
N * SXX - SX * SX

SXX * SY - SXY * SX
B = ────────────────────
N * SXX - SX * SX
en donde :
SX = X1 + X2 + ... + Xn
SY = Y1 + Y2 + ... + Yn
SXX = X1^2 + X2^2+ ... + Yn^2
SXY = X1*Y1 + X2*Y2 + ... + Xn*Yn

#include<iostream>
#include<math.h>
using namespace std;

#define MAX 100

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 8
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________

struct Punto{
float x;
float y;
};
void numeroDePuntos(int &n);
void ingresoPuntos(Punto P[], int n);
void calculoEcuacion(Punto P[], int n, float &M, float &B);
void reporteEcuacionRecta(float M, float B);

int main()
{
Punto P[MAX];
float M,B;
int n;
numeroDePuntos(n);
ingresoPuntos(P,n);
calculoEcuacion(P,n,M,B);
reporteEcuacionRecta(M,B);
system("pause");
return 0;
}

void numeroDePuntos(int &n)

{
do{
cout<<"Numero de puntos : ";
cin>>n;
}while(n<=0 || n>MAX);
}
void ingresoPuntos(Punto P[], int n)
{
int i;
for(i=0;i<n;i++)
{
cout<<"Punto "<<i+1<<endl;
cout<<"Valor de x : ";
cin>>P[i].x;
cout<<"Valor de y : ";
cin>>P[i].y;
}
}

void calculoEcuacion(Punto P[], int n, float &M, float &B)

{
int i;
float sx=0,sy=0,sxx=0,sxy=0,den;
for(i=0;i<n;i++)
{

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 9
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
sx=sx+P[i].x;
sy=sy+P[i].y;
sxy=sxy+P[i].x*P[i].y;
sxx=sxx+P[i].x*P[i].x;
}
den = n*sxx - sx*sx;
M = (n*sxy-sx*sy)/den;
B = (sxx*sy - sxy*sx)/den;
}

void reporteEcuacionRecta(float M, float B)

{
cout<<"Y = "<<M<<" X ";
if(B>0) cout<<"+ ";
cout<<B<<endl;
}

5) Hacer un programa para manipular los datos de Productos. En el se podrá ingresar sus
datos, consultar, modificarlos, eliminarlos y reportar, esto debe estar dentro de un menu.

#include<iostream>
#include<string.h>
#include<ctype.h>
using namespace std;

#define MAX 20

struct Producto{
char codigo[10];
char nombre[30];
float precio;
int stock;
};

char continuar(char mensaje[]);

int buscarCodigo(Producto X[], int n,char codigo[10]);
void mostrarProducto(Producto P);
void modificarProducto(Producto &P);
void ingreso(Producto X[], int &n);
void consulta(Producto X[], int n);
void modificacion(Producto X[], int n);
void eliminacion(Producto X[], int &n);
void reporte(Producto X[], int n);

int main()
{
int op,n=0;
Producto X[MAX];
do{

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 10
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
system("cls");
cout<<"Mantenimiento de Productos "<<endl;
cout<<"[1] Ingreso"<<endl;
cout<<"[2] Consulta"<<endl;
cout<<"[3] Modificacion"<<endl;
cout<<"[4] Eliminacion"<<endl;
cout<<"[5] Reporte"<<endl;
cout<<"[6] Salir "<<endl;
do{
cout<<"Ingrese opcion (1-6) : ";
cin>>op;
}while(op<1 || op>6);
switch(op)
{
case 1 : ingreso(X,n);break;
case 2 : consulta(X,n);break;
case 3 : modificacion(X,n);break;
case 4 : eliminacion(X,n);break;
case 5 : reporte(X,n);break;
}
}while(op!=6);
}

char continuar(char mensaje[])

{
char tecla;
do{
cout<<mensaje;
cin>>tecla;
tecla=toupper(tecla);
}while(tecla!='S' && tecla!='N');
return tecla;
}

int buscarCodigo(Producto X[], int n,char codigo[10])

{
int i;
for(i=0;i<n;i++)
if(stricmp(X[i].codigo,codigo)==0)
return i;
return -1;
}
void mostrarProducto(Producto P)
{
cout<<"Datos del Producto"<<endl;
cout<<"codigo : "<<P.codigo<<endl;
cout<<"nombre : "<<P.nombre<<endl;
cout<<"precio : "<<P.precio<<endl;
cout<<"stock : "<<P.stock<<endl;

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 11
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
}

void modificarProducto(Producto &P)

{
int op;
do{
cout<<"Que deseas Modificar "<<endl;
cout<<"[1] Codigo [2] nombre [3] precio [4] stock [5] salir"<<endl;
cout<<"Ingrese opcion (1-5)";
cin>>op;
switch(op)
{
case 1 : cout<<"Nuevo codigo :";
cin>>P.codigo;
break;
case 2 : cout<<"Nuevo nombre :";
cin.get();
cin.getline(P.nombre,30);
break;
case 3 :
do{
cout<<"Nuevo precio :";
cin>>P.precio;
}while(P.precio<=0);
break;
case 4 :
do{
cout<<"Nuevo stock : ";
cin>>P.stock;
}while(P.stock<=0);
break;
}
}while(op!=5);
}

void ingreso(Producto X[], int &n)

{
char resp;
int p;
do{
system("cls");
cout<<"Ingreso de datos"<<endl<<endl;

cout<<"Datos del Producto "<<endl;

cout<<"Codigo : ";
cin>>X[n].codigo;

p=buscarCodigo(X,n,X[n].codigo);
if(p==-1)

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 12
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
{
cout<<"Nombre : ";
cin.get();
cin.getline(X[n].nombre,30);
do{
cout<<"Precio : ";
cin>>X[n].precio;
}while(X[n].precio<=0);
do{
cout<<"Stock : ";
cin>>X[n].stock;
}while(X[n].stock<=0);
n++;
}
else
cout<<"-- El codigo ya existe !!"<<endl;
resp=continuar("Deseas ingresar otro Producto (s/n) :");
}while(resp=='S');
}

void consulta(Producto X[], int n)

{
int i,p;
char codigo[10],resp;
do{
system("cls");
cout<<"Consulta de Datos"<<endl<<endl;
cout<<"Codigo a buscar : ";
cin>>codigo;
p=buscarCodigo(X,n,codigo);
if(p!=-1)
mostrarProducto(X[p]);
else
cout<<"el codigo del producto no existe"<<endl;
resp=continuar("Deseas consultar otro producto(s/n) ");
}while(resp=='S');
}

void modificacion(Producto X[], int n)

{
int i,p;

char codigo[10],resp;
do{
system("cls");
cout<<"Modificacion de Datos"<<endl<<endl;
cout<<"Codigo a buscar : ";
cin>>codigo;
p=buscarCodigo(X,n,codigo);

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 13
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
if(p!=-1)
{
mostrarProducto(X[p]);
modificarProducto(X[p]);
}
else
cout<<"el codigo del producto no existe"<<endl;
resp=continuar("Deseas modificar otro producto(s/n) ");
}while(resp=='S');
}

void eliminacion(Producto X[], int &n)

{
int i,p;
char codigo[10],resp,preg;
do{
system("cls");
cout<<"Eliminacion de un Producto"<<endl<<endl;
cout<<"Codigo a buscar : ";
cin>>codigo;
p=buscarCodigo(X,n,codigo);
if(p!=-1)
{
mostrarProducto(X[p]);
preg=continuar("Estas seguro de eliminarlo (S/N) :");
if(preg=='S')
{
for(i=p;i<n-1;i++)
X[i]=X[i+1];
n=n-1;
}
}
else
cout<<"el codigo del producto no existe"<<endl;
resp=continuar("Deseas eliminar otro producto(s/n) ");
}while(resp=='S');
}

void reporte(Producto X[], int n)

{
int i;
system("cls");
cout<<"Listado de Productos "<<endl;
cout<<"codigo\t\tnombre\t\tprecio \t\tstock"<<endl;
for(i=0;i<n;i++)
cout<<X[i].codigo<<"\t\t"<<X[i].nombre<<" \t\t"<<X[i].precio<<"\t\t"<<X[i].stock<<endl;
system("pause");
}

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 14
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________

Ejercicios Propuestos
1) Ingresar el nombre, nota del Examen1, nota del Examen2 y nota de Trabajos de n
alumnos si los pesos de los exámenes son 0.25 y del trabajo 0.5 encontrar el promedio
ponderado de cada alumno y reportarlos en orden de Merito, además reportar el Promedio
general.

2) Ingresar los datos de n clientes de un banco (código, nombre, saldo). Haga un menú
donde se pueda crear una Cuenta, consultar Saldo, depositar una cantidad, retirar una
cantidad y Mostrar todas las cuentas ingresadas.

3) Los términos de un polinomio los podemos colocar como una estructura (coeficiente y
exponente). Ingresar el grado y los términos de un polinomio y Escriba una funcion que
encuentre el valor numérico del polinomio.

4) Hacer un programa para ingresar los datos de n trabajadores (código, nombre, valor por
hora, horas trabajadas). Hacer las siguientes operaciones:
- Mostrar los Trabajadores ordenados por nombre,
- Mostrar los Trabajadores ordenados por sueldo
- Ingresar un codigo de un trabajador y mostrar todos sus datos.

5) Se tiene una serie de fracciones (numerador y denominador).Calcule la suma de todas

estas fracciones y muestre el resultado. La respuesta debe estar simplificada.

6) Ingresar n cadenas, y reportarlas ordenadas ascendentemente según la longitud de la

cadena.

7) De n alumnos se tiene los siguientes datos: código, nombre apellidos, fecha de ingreso.
Se pide ordenar por fecha de ingreso.

8) En una tienda de la Ciudad de Trujillo se almacena información relativa a las ventas

efectuadas por sus empleados en los 12 meses del año. La información que se tiene de los
empleados es la siguiente:
Código (entero), nombre (cadena), ventas (arreglo unidimensional de 12 elementos), salario
(real).
Hacer un programa para que haga lo siguiente:
1) Listar el código y nombre del Empleado que tuvo las mayores ventas durante el año.
2) Incremente un 10 % el salario de todos los empleados que durante el año obtuvieron
ventas superiores a 100000
3) Listar el código y nombre de los empleados que en el mes de diciembre tuvieron
ventas inferiores a 5000.

9) En una universidad almacenan información relativa a sus profesores en un arreglo

unidimensional. Cada elemento del arreglo es un registro que contiene la siguiente
información respecto a cada profesor:
* Numero de empleado
* Nombre de profesor
* Departamento al que pertenece
* Grado Académico

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 15
Curso: Fundamentos de Programacion Estructuras
_______________________________________________________________
* Nacionalidad
* Salario
Hacer un programa que haga lo siguiente:
a) El numero, nombre y nacionalidad del profesor que mas ganó el año anterior.
b) El monto total pagado en el año a los profesores del departamento X.
c) El monto total pagado a los profesores extranjeros (nacionalidad distinta a Peru)
d) El nombre del profesor del departamento Y que más ganó en el año anterior.
10) Una inmobiliaria tiene información disponible sobre departamentos de renta. De cada
departamento se conoce:
CLAVE: Variable entera que identifica al inmueble
EXTENSION: Variable tipo real que representa la superficie del departamento en metros
cuadrados.
UBICACIÓN: Variable tipo cadena de caracteres que indica si la ubicación del inmueble es
excelente, buena, regular o mala
PRECIO: variable tipo real que representa el precio del inmueble.
DISPONIBLE: Variable entera que indica si el inmueble esta disponible para la renta o no.
(1: disponible 0: no disponible)
Hacer un programa que haga lo siguiente:
a) Listar los datos de todos los departamentos disponibles que tengan un precio mayor
o igual a un cierto valor P.
b) Listar los datos de los departamentos disponibles que tengan una superficie mayor
o igual a un cierto valor dado E y una ubicación exc elente.
c) Listar el monto de la renta de todos los departamentos alquilados.

11) Un departamento de personal de una escuela tiene registros del nombre, sexo y edad de
cada uno de los profesores adscritos al mismo.

Escriba un programa que calcule e imprima lo siguiente:

a) Edad promedio del grupo de profesores
b) Nombre del profesor más joven del grupo.
c) Nombre del profesor de mas edad
d) Numero de profesores con edad mayor al promedio
e) Numero de profesores con edad menor al promedio.

12) En una escuela privada se almacena la información de sus pacientes:

Nombre y apellido(cadena de caracteres), edad (entero), sexo (carácter),
condición(entero), Domicilio (estructura con los siguientes campos: calle (cadena),
numero(entero), urbanización (cadena), ciudad(cadena)), Tel éfono (cadena)
La condición se refiere al estado de salud con que ingresa el paciente. Los valores de
condición van de 1 a 5, y 5 representa el máximo grado de gravedad.
Hacer un programa que genere lo siguiente:
a) El porcentaje tanto de hombres como de mujeres registradas en el hospital
b) El numero de pacientes de cada una de las categorías de condición.
c) El nombre y teléfono de todos los pacientes que tuvieron una condición de ingreso
de máxima gravedad(5)

-----------------------------------------------------------------------------------------------------
Docente: Marcelino Torres Villanueva 16