Ejercicios con punteros, estructuras y archivos.

COMPUTACION II
INFORMATICA II
Ingeniería Electrónica y Bioingeniería
Guía de Práctica Nº 3
Problemas resueltos y propuestos
con punteros, estructuras y archivos
Departamento de Electrónica y Automática
Facultad de Ingeniería
Universidad Nacional de San Juan
1
PROBLEMAS RESUELTOS CON PUNTEROS
PROBLEMA 1:
Ejemplo que muestra la declaración de variables punteros y su asignación:
#include <stdio.h>
int main( ) {
int ivar,*iptr;
iptr=&ivar;
/* la dirección de ivar es asignada a iptr */
ivar=122;
printf("Dirección de ivar
: %p\n",&ivar);
printf("Contenido de ivar
: %d\n",ivar);
printf("Contenido de iptr
: %p\n",iptr);
printf("Valor apuntado por iptr: %d\n",*iptr);
}
PROBLEMA 2:
Paso de punteros a una función, la cual tiene como objetivo intercambiar el contenido de dos
variables enteras.
#include <stdio.h>
/* Declaracion funcion intercambio */
void intercambio(int *px, int *py);
int
main ( ) {
int x = 3, y = 2;
printf(“Antes de la función\t: x=%d\ty=%d\n\n, x, y);
intercambio(&x, &y);
printf(“Despues de ejecutarse la función: x=%d\ty=%d\n, x, y);
}
void intercambio(int *px, int *py) {
int temp;
temp = *px;
*px = *py;
*py = temp;
}
PROBLEMAS RESUELTOS CON PUNTEROS y ARREGLOS
DINAMICOS
PROBLEMA 1:
Ejemplo Arreglo dinámico con punteros.
#include <stdio.h>
#include <stdlib.h>
void mostrar( int *p,int n);
/* Declaración de la función */
int main( ) {
int *p,n,i;
2
printf ("ingrese cant de datos del arreglo \n");
scanf ("%d",&n);
p = (int*) malloc(n* sizeof(int));
if(p==NULL) {
puts( "No hay memoria \n");
exit(1); /*Fuerza la salida. Arg =1 indica error.*/
}
for( i = 0; i<n ; ++i) {
printf("ingrese el dato %d de arreglo\n", i+1);
scanf("%d", p+i);
/* puede ser: scanf(“%d”,&p[i]); */
}
mostrar( p, n);
/* Invocación a la función */
free(p);
system("pause");
}
/* Definición de la función */
void mostrar( int *p,int n) {
int i;
puts( "Los datos del arreglo son: \n\n");
for( i = 0; i<n ; ++i)
printf("%d \n",*(p + i));
/*Tambien podría ser de la forma: printf("%d \n“, p[i]));*/
}
PROBLEMA 2:
Intersección de dos conjuntos de números enteros. Cada conjunto numérico deberá ser
representado por un arreglo dinámico. Donde la cantidad de elementos de cada arreglo
deberá ser pedido mediante teclado. El conjunto intersección deberá ser representado por
otro arreglo dinámico. La lectura de los arreglos y la muestra del arreglo intersección
deberán realizarse mediante funciones.
#include <stdio.h>
#include <stdlib.h>
void lee( int * a, int cant );
int inter( int *a, int *b, int * c, int m, int n );
void muestra( int cant, int *c );
int
main( ) {
int *a, *b, *c;
int m, n, cant, menor;
printf("Ingrese la cantidad de elementos del conjunto a:");
scanf("%d", &m);
getchar();
printf("Ingrese la cantidad de elementos del conjunto b:");
scanf("%d", &n);
getchar();
a = (int *)malloc(m * sizeof (int));
3
b = (int *)malloc(m * sizeof (int));
menor= (m < n)? m : n;
/* selecciona la menor cantidad */
c = (int *)malloc (menor * sizeof (int));
printf("\n\nIngrese elementos del vector a\n");
lee(a,m);
printf("\n\nIngrese elementos del vector b \n");
lee(b, n);
cant = inter(a, b, c, m, n);
if(cant) muestra(cant, c);
else printf("INTERSECCION VACIA ");
system("pause");
}
void lee(int * a,int cant) {
int i;
for( i=0; i < cant ; ++i) {
printf( "Ingrese el elemento %d\n", i+1);
scanf("%d", &a[i]); /* podria usarse a+i */
}
}
int inter(int * a, int * b, int *c,int m , int n) {
int i, j, k = 0;
for( i = 0; i < m; ++i ) {
for( j = 0; j < n ; ++j )
if(*(a+i) == *(b+j))
/* ¢ (a[i] == b[j]) */
*(c+k++) = *(a+i);
/* ¢ c[k++] = a[i] */
}
return( k );
}
void muestra(int cant, int c[ ]) {
int i;
printf("\nLa intersecccion tiene %d elementos.", cant);
for(i = 0 ; i < cant ; ++ i)
printf("\nc[%d] = \t %d", i+1, c[i]);
}
PROBLEMA 3:
Dado un polinomio de cualquier grado:
P(X)=a0+a1 x+a2 x^2+a3 x^3+....+an x^n
Donde los coeficientes a_i y el valor de la variable x son datos reales. Se pide:
a) Leer por teclado cada coeficiente del polinomio en un arreglo dinámico. Mostrar el arreglo
de coeficientes en el main. El grado del polinomio deberá ser leído por teclado.
b) Determinar si el polinomio posee raíces enteras para el rango de -100<= x <= 100,
mostrar por pantalla.
# include <stdio.h>
# include <stdlib.h>
float *lee( int *);
void raices( float *, int);
int main( ) {
float *pol;
int i,n;
4
pol= lee(&n);
/*invoca la función en que se declara un
arreglo dinámico donde se guardan los */
/* coeficientes del polinomio. */
/*Muestra valor del grado elegido*/
printf("\n El grado del polinomio es:%d\n", n);
/*Muestra el polinomio ordenado creciente
y completo de la forma:
a0+a1 x+a2 x^2+a3 x^3+....+an x^n */
printf("\n El polinomio ordenado creciente y completo queda
:\n");
printf(" %1.2f\t", pol[0]);
/* termino indepediente */
for(i=1;i<=n;i++) {
printf("+ %1.2f x^%d \t", pol[i],i);
}
printf("\n");
/*Se invoca la función para determinar si tiene raices
enteras*/
raices( pol, n);
printf("\n");
system("PAUSE");
}
DEFINICION DE FUNCIONES:
• La lectura de todo el arreglo se hace en la función, en donde ahí mismo se hace la
asignación dinámica de memoria y se guarda el valor de la variable cantidad de
elementos o coeficientes en la dirección de memoria que se recibió desde el main.
• Para hacer asignación dinámica de memoria es necesario devolver la dirección del
puntero del arreglo.
float *lee( int *A ) {
int i = 0, N;
float *p, C;
/* Se debe ingresar si o si un grado menor o igual a 10 */
do{
printf("Ingrese grado del polinomo:\n");
scanf("%d",&N);
}while(N<0 && N>10);
/*Se asigna memoria*/
p = (float* ) malloc((N+1) * sizeof (float));
if( p == NULL ) {
printf( "Espacio de memoria insuficiente\n" );
exit(1);
}
/* Fin del proceso */
printf("Ingrese termino independiente: \n");
scanf("%f", &C);
/* Se lee sobre una variable auxiliar */
fflush(stdin);
*(p+i)=C; /* Se guarda valor de coeficiente en el arreglo */
for( i=1;i<=N;i++ ) {
5
printf("Ingrese coeficiente %d: \n",i);
scanf("%f", &C);
fflush(stdin);
*(p+i) = C;
}
*A=N; /* Se asigna el valor del grado del polinomio en la
direccion apuntada por A en el main */
return p; /* Se devuelve el valor del puntero que apunta al
arreglo dinámico de coeficientes */
}
void raices( float *p, int N ) {
int x, i;
float potencia, y;
for(x=-100;x<=100;x++) { /* se recorre el valor de x desde -100
hasta 100 */
/* Se calcula x usando un método recursivo de calculo, luego
se verifica si es raíz del polinomio */
y=p[0];
/* se inicia la variable y con termino indep. */
potencia=1;
/* se inicia la potencia de x con el valor uno
(elem. Neutro de la multiplicación) */
for (i=1;i<=N;i++) {
/*se calcula el valor del polinomio en forma recursiva*/
Potencia *= x;
y += (potencia * p[i]);
}
if(y==0)
printf("El valor de x=%d es raíz del polinomio:\n", x);
}
}
PROBLEMA 4:
Programa ejemplo de arreglo bidimensional con un arreglo de punteros. El arreglo
bidimensional se representa como un arreglo de punteros, donde cada puntero contiene la
dirección de comienzo de la correspondiente fila del arreglo bidimensional.
#include
#include
#define
<stdio.h>
<stdlib.h>
MFIL 30
int main( ) {
int fila, nfilas, ncols, col;
/* definición del arreglo de punteros */
int *a[MFIL];
/*Para pedir memoria => la cantidad de filas y columnas
printf("Cuantas filas?\n");
scanf("%d",&nfilas);
printf("\nCuántas columnas?\n")
scanf("%d", &ncols);
6
*/
/*reserva espacio de memoria para cada fila de la matriz */
for(fila =0; fila < nfilas; ++fila)
a[fila] = (int *)malloc(ncols * sizeof(int));
/* Lee el arreglo bidimensional */
for (fila = 0; fila < nfilas; ++fila) {
printf ("\nIntroducir datos para la fila %2d\n", fila + 1);
for (col = 0; col < ncols; ++col) {
printf (" x[%d][%d]= ",fila + 1, col + 1);
scanf ("%d", (a[fila]+col));
}
}
/* Muestra el arreglo bidimensional leído */
printf("La matriz ingresada tiene los elementos:\n\n");
for(fila=0; fila < nfilas; ++fila) {
for(col = 0; col < ncols; ++col) {
printf("a[%d][%d]=%4d",fila+1,col+1,*(a[fila]+col));
printf("\n");
}
system("pause");
}
PROBLEMA 5:
String con arreglo de punteros. Se utiliza un arreglo de punteros para almacenar la dirección
de cada uno de los string. Se lee por teclado un string y se pide memoria de acuerdo a su
longitud.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSTR 100 /* Maxima cantidad de strings */
int main( ) {
/* arreglo de punteros cada uno apunta a un string */
char *plinea[MAXSTR];
/* puntero auxiliar, arreglo estático */
char linea[81];
/* indice, longitud string, cantidad de lineas*/
int i, lng, nlinea = 0;
system( "cls" );
/*Ejecuta orden del sistema operativo*/
printf("Ingrese las Cadenas de caracteres\n");
printf("Para finalizar con enter \n\n");
gets(linea);
lng=strlen(linea);
/* se podría haber puesto dentro del while
(lng =strlen(gets(linea)))>0 ;
*/
/* mientras no sea el string nulo y la cantidad
de string no supere el maximo*/
while(( lng > 0 ) && (nlinea < MAXSTR)) {
7
/* Pide memoria para la cadena ingresada y guarda la
direccion esa cadena en el arreglo de Punteros */
plinea[nlinea] = (char*) malloc (lng +1);
if(plinea[nlinea] == NULL) {
puts ( " Espacio de memoria insuficiente" );
exit(1);
}
/* Fin del proceso */
/* Copia la cadena en el espacio de memoria asignado */
strcpy(plinea[nlinea],linea);
nlinea ++ ;
printf("Ingrese Nueva Cadena de caracteres\n");
gets(linea);
lng=strlen(linea);
} /* fin del while */
/* Muestra las cadenas de caracteres */
for(i=0; i< nlinea ; ++i)
printf( " %s\n", plinea[i]);
system("pause");
}
PROBLEMA 6:
Ejemplo simple de puntero a puntero.
#include <stdio.h>
int main ( ) {
int V= 10;
/* Definición variable inicializa con 10 */
int *p1;
/* Definición puntero */
int **p2;
/* Definición de puntero a puntero */
p1 = &V;
p2 = &p1;
**p2 = 20;
/* el valor de V ahora es 20. */
printf ( " el valor de v es :\t v = %d \n",V);
system("pause");
}
PROBLEMA 7:
Cargar un arreglo en una función que pide memoria, la función recibe un puntero a puntero y
retorna la cantidad de datos leídos.
#include <stdio.h>
int lee(int**p2);
void muestra(int*p, int n);
int main ( ) {
int i, n;
int **p2;
/* Define puntero a puntero */
n = lee( p2 ); /* pasa a la función un puntero a puntero p2 */
muestra( *p2, n );
system("pause");
}
8
int lee (int**p2) {
int i,cant;
printf ( " Ingrese la cantidad de elementos \n");
scanf ("%d", &cant);
/* Pide memoria para el puntero apuntado por p2 */
*p2 = (int*) malloc(cant * sizeof(int));
for ( i=0; i < cant ; ++i) {
printf ( " Ingrese el elemento %d \n", i+1);
scanf ("%d", (*p2)+i);
}
return(cant);
}
void muestra (int*p,int n) {
int i;
for (i = 0 ; i < n ; ++ i) {
/* Podria ser también: printf ("\n %d",p[i] ); */
printf ("\n %d",*(p+i) );
}
printf ("\n\n ");
}
PROBLEMAS PROPUESTOS CON PUNTEROS
PROBLEMA 1:
Ingrese en un arreglo dinámico las notas obtenidas en los exámenes que rindió cualquier
alumno. La cantidad de exámenes rendidos deberá ser ingresada por teclado. Se pide:
a) Mediante una función calcular el promedio de notas. Mostrar el promedio en el main.
b) Mediante una función genere un nuevo arreglo dinámico de notas con aquellas notas
superiores al promedio obtenido en el punto anterior. Mostrar las notas en el main.
PROBLEMA 2:
Una empresa que vende herramientas desea procesar la información de sus ventas
realizadas en el mes. Por cada venta realizada, se debe ingresar en tres arreglos paralelos
dinámicos, el código de herramienta de la herramienta (entero desde 101 hasta 1000), la
cantidad vendida (entero) y el precio por unidad (real). Se supone una herramienta por
venta. Pedir al operador que ingrese por teclado la cantidad de ventas.
a) Mediante una función, genere un nuevo arreglo dinámico con aquellas cantidades
vendidas para el código de herramienta que más se repite. Tener en cuenta que una
herramienta se puede vender más de una vez. Mostrar el nuevo arreglo en el main.
b) ¿Cuánto se recaudó en total por la venta de esa herramienta? Hacer en una función,
mostrar en el main.
PROBLEMA 3:
Guardar un párrafo en un único string. El string no debe contener más de 1000 caracteres.
Se pide:
a) El porcentaje de palabras que comienzan con ‘c’ o con ‘e’. Mostrar en el main.
b) Generar un nuevo arreglo dinámico de strings, donde cada string contenga una palabra
que comienzan con ‘c’ o con ‘e’.
NOTA: Se puede desarrollar los ejercicios de arreglos numéricos y string de la guía
anterior utilizando arreglos dinámicos.
9
PROBLEMAS RESUELTOS CON ESTRUCTURAS
PROBLEMA 1:
Un medico desea llevar los datos de sus pacientes para lo cual necesita de un programa en
C capaz de realizar la siguiente tarea:
Para cada Paciente se cuenta con la siguiente información:
Nombre (alfanumérico, 20)
Ultimo Diagnostico (alfanumérico, 20)
Edad (entero)
Localidad (alfanumérico, 10)
Dirección (alfanumérico, 25)
El programa debe permitir la carga de todos los datos relativos a cada uno de los pacientes
cuya cantidad se especifica al comenzar el programa (leer esta cantidad) Hacer la reserva
dinámica de memoria correspondiente.
Listar los pacientes cuyo Ultimo Diagnostico se especifique. Este listado debe realizarse
ordenado por Localidad y Dirección.
El promedio de Edad de los pacientes que poseen el Diagnostico del punto anterior.
Nota: No se deben usar variables globales, y se deben emplear al menos tres funciones
diferentes para resolver el problema.
#include
#include
#include
#include
<stdio.h>
<malloc.h>
<stdlib.h>
<string.h>
typedef struct {
char nombre [30];
char ult_diag [20];
int edad;
char loc[10];
char direc[25];
} FICHA;
void carga (FICHA *pacientes, int n);
void lista ( FICHA *pacientes, int n);
void ordena ( FICHA *pacientes, int n);
int main ( ) {
int n,cant;
FICHA *pacientes;
printf ("\n Ingrese la cantidad de Pacientes a Procesar \n");
scanf ("%d",&n);
getchar();
pacientes = (FICHA *)malloc(sizeof(FICHA) * n);
carga( pacientes, n );
ordena(pacientes, n );
lista(pacientes, n );
}
void carga( FICHA *pacientes, int n) {
int i;
printf("\n\n carga de datos\n\n");
10
for( i=0; i<n; ++i) {
printf("\nNombre del paciente \n");
gets(pacientes[i].nombre);
printf("\nUltimo diagnostico del paciente \n");
gets(pacientes[i].ult_diag);
printf("\nEdad del paciente \n");
scanf("%d",&pacientes[i].edad);
getchar();
printf("\nLocalidad \n ");
gets((pacientes+i)->loc);
printf("\nDireccion \n ");
gets((pacientes+i)->direc);
}
}
void ordena( FICHA *pacientes, int n) {
int i,j,pos;
FICHA aux;
/* Ordena por localidad */
for(i = 0; i<n-1; ++i) {
pos =i;
for(j=i+1;j<n; ++j) {
if( strcmp( pacientes[j].loc, pacientes[pos].loc) <
0){
pos = j;
aux = pacientes[i];
pacientes[i] = pacientes[pos];
pacientes[pos] = aux;
}
}
}
/* Ordena por direccion los de igual localidad */
for(i = 0; i<n-1; ++i) {
pos =i;
for(j=i+1;j<n; ++j) {
if((strcmp( pacientes[j].loc,pacientes[pos].loc) == 0) &&
(strcmp( pacientes[j].direc,pacientes[pos].direc)< 0)) {
pos = j;
aux = pacientes[i];
pacientes[i] = pacientes[pos];
pacientes[pos] = aux;
}
}
}
void lista ( FICHA *pacientes, int n) {
char diag[20];
int i,cont=0;
float prom=0;
printf("\n Ingrese el diagnostico a buscar \n");
gets(diag);
11
for (i=0;i<n;++i) {
if(strcmp(diag,pacientes[i].ult_diag)==0){
printf("\n %s \t %d \t %s \t %s \n",pacientes[i].nombre,
pacientes[i].edad,pacientes[i].loc,pacientes[i].direc);
++cont;
prom += pacientes[i].edad;
}
}
if(cont) {
prom = prom/cont;
printf("\n El promedio de edad de los pacientes con
diagnostico %s",diag);
printf("es %f",prom);
} else printf(" no hay pacientes con ese diagnostico");
}
PROBLEMA 2:
Se debe desarrollar un programa que realice un balance de cuentas de los clientes de una
empresa en un año, para ello se deben ingresar los datos de cada cliente para ese periodo.
Los datos de cada cliente son: Número de orden, Nombre, cuit, los saldos correspondientes
a cada uno de los trimestres y el saldo total. Se debe contemplar un máximo de 100 clientes.
• Mediante una función se deben ingresar los datos de los clientes, el ingreso finaliza con
nombre de cliente igual a “ultimo”.
• Utilizando otra función se deben construir dos nuevos arreglos, donde se almacenarán
los clientes con saldo positivo en uno y en el otro los negativos, para esto arreglos se
debe realizar Asignación Dinámica de Memoria.
• mediante una función mostrar los valores, esta función debe servir para mostrar los
valores de los tres arreglos.
• Permitir ubicar a un cliente por nombre en el arreglo (Búsqueda Binaria).
• Permitir borrar un determinado cliente ingresando el nombre.
• Listar los datos de los clientes cuyo nombre comience con una determinada letra
• Realizar un MENÚ para poder seleccionar la operación deseada.
• Se propone poder agregar clientes, buscar clientes por número de cuit, encontrar saldos
totales, agregar un miembro para dirección y ordenar por dirección y nombre, y todas las
posibilidades que se le ocurran, etc.
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define max 100
typedef struct {
int num_ord;
char nombre[30];
char cuit [14];
float saldo_tri[5]; /* saldo por trimestre y total */
} CLIENTE;
int leer_cli (CLIENTE *cli ); /* declaracion */
void mostrar(CLIENTE *, int cant );
void deu_acre(CLIENTE *cli,CLIENTE *deu,CLIENTE *acre, int cant);
void orde_alf(CLIENTE *cli, int n );
int busca_bin_nom (CLIENTE *cli, int n,char * nom_abus );
void busca_bin_let (CLIENTE *cli, int n,char let );
12
int borra_cli (CLIENTE *cli, int n,char * nom_abus );
int main( ) {
CLIENTE cli[100], *deu , *acre;
int i, cant,cant_deu=0,pos;
char nom_abus[30],let,selec;
cant = leer_cli (cli);
/* Cuenta los deudores para reservar memoria */
for( i=0;i< cant; ++i)
if( cli[i].saldo_tri[4] < 0)
cant_deu ++; system("cls");
do {
printf("opcion 1 Genera deudores y acreedores\n");
printf("opcion 2 Busca un cliente por nombre\n");
printf("opcion 3 Lista deudores\n");
printf("opcion 4 lista clientes dada la 1ra letra\n");
printf("opcion 5 Borra un cliente dado el nombre\n");
printf("opcion 6 Lista los clientes\n");
printf("opcion S salir\n");
printf("Seleccione una opcion\n");
selec = getchar();
getchar();
switch( selec ){
case '1':
deu = (CLIENTE
*)malloc(cant_deu*sizeof(CLIENTE));
acre= (CLIENTE *)malloc((cantcant_deu)*sizeof(CLIENTE));
deu_acre(cli, deu, acre, cant);
break;
case '2':
printf("\n\nIngrese el nombre a buscar\n");
gets(nom_abus);
orde_alf( cli, cant );
pos = busca_bin_nom(cli, cant, nom_abus );
if(pos > cant)
printf("No se encuentra el cliente.");
else mostrar((cli+pos),1);
printf("\nPresione enter para continuar\n");
getchar();
break;
case '3':
puts("\n**** DEUDORES ***\n");
mostrar( deu, cant_deu );
printf("\nPresione enter para continuar\n");
getchar();
break;
case '4':
printf("\nIngrese el caracter de comienzo:");
let=getchar();
busca_bin_let(cli, cant , let );
printf("\nPresione enter para continuar\n");
13
getchar();
getchar();
break;
case '5':
printf("\n\nIngrese el nombre del cliente a
borrar\n");
getchar();
gets( nom_abus );
if( borra_cli(cli, cant, nom_abus ));
cant --;
printf("\nPresione enter para continuar\n");
getchar();
break;
case '6':
mostrar(cli,cant);
printf("\nPresione enter para continuar\n");
getchar();
break;
}
} while(selec != 'S');
system("PAUSE");
return 0;
}
/* definicion de funciones */
int leer_cli(CLIENTE *cli ) {
int j,i = 0 ;
float temp;
char nombre[30];
puts("Ingrese el Nombre del cliente 1:\t");
gets( nombre );
while(strcmpi(nombre, "ultimo" )) {
cli[i].num_ord = i+1;
strcpy( cli[i].nombre, nombre );
puts("\ningrese el cuit: ");
gets( cli[i].cuit );
cli[i].saldo_tri[4] = 0;
for( j=0; j<4 ; ++j) {
printf("\nIngrese saldo Trm: %d\t", j+1);
scanf("%f", &temp);
cli[i].saldo_tri[j] = temp;
cli[i].saldo_tri[4] += temp; /* calcula saldo total
*/
}
i++;
getchar();
printf("Ingrese el Nombre del cliente %d:\t", i+1);
gets( nombre );
}
return (i);
}
14
void mostrar(CLIENTE *cli, int cant) {
int i=0;
printf ("\n\n\n Orden \t\t\t Nombre \t\t\t SaldoTotal \n\n");
for(i=0 ;i < cant; ++i) {
printf (" %d ", (cli+i)->num_ord);
printf ("\t\t %s \t\t ",(cli+i)->nombre);
printf ("\t\t\t %f \n", (cli+i)->saldo_tri[4]);
}
}
void deu_acre(CLIENTE *cli, CLIENTE *deu, CLIENTE *acre, int cant) {
int i, d=0, a=0;
/* Separa los arreglos */
for( i=0;i< cant; ++i) {
if( cli[i].saldo_tri[4] < 0) {
deu[d] = cli[i];
++d;
} else {
acre[a] = cli[i];
++a;
}
}
}
void orde_alf(CLIENTE *cli, int n ) {
int i,j,pos;
CLIENTE aux;
for(i=0; i<n-1; ++i) {
pos =i;
for( j=i+1 ; j< n; ++j) {
if( strcmp(cli[j].nombre, cli[pos].nombre) < 0) {
pos=j;
aux = cli[i];
cli[i]=cli[pos];
cli[pos]=aux;
}
}
}
} /* Fin funcion ordena por nombre */
int busca_bin_nom(CLIENTE *cli, int n, char *nom_abus ) {
int maxi=n-1, medio=n/2, min=0;
while( (min <=maxi) && (strcmp(cli[medio].nombre, nom_abus))) {
if(strcmp(cli[medio].nombre,nom_abus) > 0) maxi = medio 1;
else min = medio + 1;
medio = (min + maxi)/2;
}
if( strcmp(cli[medio].nombre,nom_abus) != 0) {
medio = n + 1;
}
return(medio);
}
15
void busca_bin_let(CLIENTE *cli, int n,char let ) {
int maxi=n, medio=n/2, min=0;
while( (min <=maxi) && (cli[medio].nombre[0]!=let )) {
if(cli[medio].nombre[0] >let) maxi = medio ;
else min = medio + 1;
medio = (min + maxi)/2;
}
if( cli[medio].nombre[0] == let ) {
/* Busca el primero con esa letra */
while(cli[medio].nombre[0] == let)
medio -- ;
medio++;
/* Muestra todos los clientes que empiezan con esa letra */
while(cli[medio].nombre[0] == let)
mostrar(&cli[medio++],1);
}else printf("No hay clientes con esa letra");
}
/* funcion que elimina un cliente */
int borra_cli(CLIENTE *cli, int n,char * nom_abus ) {
int i,pos;
orde_alf(cli,n);
pos = busca_bin_nom(cli, n, nom_abus);
if(pos < n)
for(i=pos;i<n-1;++i)
cli[i] = cli [i+1];
else {
printf("No se encuentra. Imposible borrar\n");
pos =0;
}
return (pos);
}
16
PROBLEMAS PROPUESTOS CON ESTRUCTURAS
PROBLEMA 1:
Los alumnos de primer año están registrados en una base de datos en la facultad, para lo
cual necesita de un programa en C capaz de realizar la siguiente tarea:
Para cada alumno se cuenta con la siguiente información:
• Nombre (alfanumérico, 20).
• Especialidad (alfanumérico, 6).
• Edad (numérico).
• Numero de registro
• Notas (real,7) ( debe contener las notas de seis materias y el promedio de estas).
El programa deberá permitir realizar lo siguiente:
a) Cargar un arreglo dinámico de n alumnos. Reserva dinámica de memoria.
b) A través de una función calcular el promedio de las seis notas de cada alumno y
almacenarlo en el elemento correspondiente de la base.
c) A través de una función listar los alumnos de la base ordenados por promedio y
separados por especialidad.
d) A través de una función calcular la cantidad de alumnos que aprobaron Informática II (4
elemento del arreglo). Se considera un alumno aprobado cuando su nota es superior a 6
y mostrar esta cantidad en el programa principal.
PROBLEMA 2:
Dada la siguiente estructura de dato:
typedef struct {
char tipo[20];
float pendiente;
float ordenada;
float y [100];
} RECTA;
• Ingresar por teclado las coordenadas de 2 puntos: P1(X1, Y1), P2(X2, Y2).
• Calcular la pendiente y la ordenada al origen de la recta que pasa por dos puntos mediante
una función (llenar la estructura).
• Clasificar la recta según tipo:
PENDIENTE +
PENDIENTE PARALELA X
PARALELA Y
Llenar la estructura.
e) Calcular 100 puntos de la recta en el intervalo [0..999] tomando un paso de 10, y llenar la
estructura.
f) Exteriorizar por la pantalla la estructura obtenida.
g) Repetir (a-e) hasta que P1(X1=100,Y1=100).
PROBLEMA 3:
Una zapatería desea llevar un control de stock de sus zapatos (como máximo 200 tipos
diferentes). Las características de cada tipo de zapato son:
• Precio (numérico)
• Talle (numérico)
• Cantidad de pares en existencia (numérico)
• Talle mínimo (numérico)
• Nombre del fabricante (alfanumérico)
Hacer un programa en lenguaje C que permita:
a) Cargar los datos de los zapatos disponibles en la zapatería, y también:
17
b) Realizar Una búsqueda binaria por nombre del fabricante (se ingresa el nombre y se
muestran los datos Precio, Talle Mínimo de todos los tipos de zapatos que pertenezcan
al fabricante pedido y que tengan pares en existencia, o un mensaje de error sí el
fabricante no existe)
PROBLEMA 4:
Una empresa que vende artículos de segunda mano por Internet desea realizar un programa
en C que le permita llevar algunos datos estadísticos de sus ventas, para eso cuenta con la
siguiente información:
• Nombre del cliente (string de 20 caracteres)
• Nombre de la tarjeta de crédito (string de 15 caracteres)
• Numero de la tarjeta de crédito (string de 14 caracteres)
• Cantidad de productos comprados (entero sin signo)
• Monto total de la compra (real)
• Fecha de compra (aaaammdd)
• Estado del cliente (C conforme, D disconforme, S satisfecho, J cliente con juicio)
Se debe realizar un programa en C que permita:
a) Realizar la carga de una cantidad N de clientes mediante asignación dinámica de
memoria.
b) Calcular el monto total de la venta para una fecha determinada que se debe ingresar por
teclado.
c) Realizar un listado ordenado por Estado del cliente y Nombre de la tarjeta de crédito.
d) Calcular el monto total de la venta para cada Estado del cliente
Nota: Los puntos 1 hasta 4 deben realizarse mediante funciones .No se deben usar
variables globales.
PROBLEMA 5:
En un instituto de investigación se necesita catalogar artículos de revistas y libros para su
utilización en la investigación. Para lo cual se pide ingresar dinámicamente la siguiente
información para X artículos o libros:
• Titulo del articulo o libro
• Autores
• Año de edición
• Nombre de la revista o vacío si es un libro (´\0´).
• Cantidad de paginas.
• Editorial
• Marca: ´A´ articulo, ´L´ libro
Se pide:
a) Mostrar dos listados ordenados alfabéticamente por titulo, uno de los artículos de las
revistas y otro para los libros.
b) Calcular la cantidad y el porcentaje de artículos y lo mismo para los libros.
c) Mostrar un listado de todos los libros cuya editorial se ingrese por teclado y que se hayan
editado desde 1970 hasta la fecha.
PROBLEMA 6:
Una casa de ventas de autopartes desea llevar un registro computarizado de la información
de sus productos. Cada producto esta caracterizado por los siguientes datos:
• Código del producto (hasta 6 caracteres alfanuméricos).
• Nombre del producto (hasta 30 caracteres).
• Precio (real).
• Stock (entero).
• Proveedor (hasta 30 caracteres).
18
Hacer un programa en C que permita:
a) Cargar la totalidad de los productos (con todos sus datos). Suponer que hay un máximo
de 1200 productos diferentes, pero si se ingresa “FIN” como código de producto, la carga
finaliza.
b) Generar un listado (por pantalla) de todos los productos con stock inferior a 60 unidades,
ordenado por proveedor.
c) Encontrar y mostrar todos los productos de un proveedor dado (que el usuario ingresa
por teclado), ordenados por código de producto.
d) Calcular y mostrar el monto invertido actualmente por la empresa en los productos en
stock.
PROBLEMA 7:
La Coca-Cola desea que sus promotores de venta posean un sistema informático para
levantar los pedidos de sus ventas. Por tal motivo necesitan un programa en C para tal
propósito. La información relativa de cada Cliente debe contener:
• Razón Social.(nombre de la empresa)
• Fecha del pedido (string de la forma aaaa/mm/dd).
• Nombre del producto (1 litro, 11/2 litro, 2 litros, etc.)
• Cantidad de botellas.
• Precio unitario por botella.
Por la venta de cada producto se debe ingresar toda esta información. Se pide:
a) Realizar un programa en C que ingrese los datos antes mencionados hasta que se
ingrese una razón social igual a “Coca-Cola” (considerar un máximo de 100 clientes y
utilizar asignación dinámica de memoria).
b) Calcular y mostrar el precio total de la venta que corresponda a los clientes que
compraron producto de 2 litros.
c) Generar un listado ordenado por nombre de producto para cada cliente (un cliente debe
realizar un pedido por cada tipo de producto que desee).
PROBLEMA 8:
Una biblioteca desea registrar los libros que posee para obtener cierta información del
conjunto. La información relevante a considerar por cada libro es:
• Titulo
• Editorial
• Autor(es)
• Numero de paginas
Se pide hacer un programa en C que permita:
a) Leer y almacenar los datos de todos los libros disponibles. La lectura finaliza cuando se
alcanza un total de 100 libros o cuando se ingresa un titulo de libro que sea “NADA”.
b) Mediante una función generar un listado por pantalla de toda la información de aquellos
libros que tengan una cantidad de paginas mayor que 120, ordenados alfabéticamente
por titulo.
c) Mediante una función calcular él numero de paginas promedio de todos los libros
ingresados.
d) A través de una función permitir que el usuario ingrese las tres primeras letras del titulo
de un libro y generar un listado por pantalla de toda la información de aquellos libros cuyo
titulo comience con las tres primeras letras ingresadas por el usuario y cuyo numero de
paginas superen él numero de paginas promedio.
PROBLEMA 9:
Un vendedor de seguros de vida requiere para su trabajo un programa en C que permita leer
la información de cada cliente, a saber:
• Nombre completo (en formato Apellido, Nombre).
19
• Edad.
• Estado de salud actual (“Bueno”, “Regular”, “Malo”).
• Monto anual de la prima.
• Parentesco del beneficiario del seguro (“Esposa”, “Hijos”, “Otros”).
Por cada cliente se debe ingresar toda esta información. Se pide:
a) Realizar un programa en C que ingrese los datos antes mencionados hasta conseguir un
nombre igual a “FIN” (considerar un máximo de 100 clientes y utilizar asignación
dinámica de memoria).
b) Calcular el monto total de la prima a pagar por cada cliente, considerando que la prima
se pagará por una cantidad de años igual a los años que le resta a cada cliente para
cumplir la edad de 60 años (siempre que la edad actual del cliente sea inferior a 60
años). Mostrar el nombre completo y edad.
c) Generar un listado ordenado por nombre del cliente y edad, para todos los clientes cuyo
beneficiario es la “Esposa”. También mostrar la cantidad de tales clientes.
PROBLEMA 10:
Se debe realizar un programa en C a cerca de un censo en una provincia de la Argentina.
Para esta tarea se debe contar con la siguiente información:
a) Nombre del Jefe de Familia.
b) Cantidad de Integrantes del grupo familiar.
c) El promedio de edad del grupo familiar (para calcular este dato se debe requerir al
operador, la edad de cada uno de los integrantes del grupo familiar).
d) Ingreso de dinero en $ del grupo familiar.
Se deben leer los datos hasta que el Nombre del Jefe de Familia sea la frase “Fin Censo” o
cuando la cantidad de Integrantes del grupo familiar sea igual a cero. Se pide:
• Generar un listado por pantalla ordenado por cantidad de integrantes y por nombre
del Jefe de familia, de aquellos grupos familiares cuyo promedio de edad sea mayor a
20 años.
• Se debe requerir al operador un determinado monto correspondiente al ingreso
mínimo en $ del grupo familiar y generar un nuevo arreglo dinámico con aquellas
familias que superan en 10% este valor ingresado. El arreglo debe contener toda la
información relativa a la familia.
• Se debe hacer un listado del arreglo generado en el punto anterior.
No se deben utilizar variables globales y se deben utilizar al menos 3 funciones.
PROBLEMA 11:
Un laboratorio de análisis clínicos lleva el control de calidad del resultado de su trabajo. Para
eso cuenta con planillas que contienen la siguiente información:
• Nombre del Paciente (alfanumérico)
• Fecha del Análisis (alfanumérico; año, mes y día)
• Colesterol HDL (numérico)
• Colesterol LDL (numérico)
• Triglicérido (numérico)
Luego de presentar las planillas a un organismo de control, se recibe un listado de 17 fechas
en las cuales los resultados están fuera de los estándares proporcionados por tal organismo
y se deben eliminar de la base.
Hacer un programa en C que permita:
a) Ingresar los datos de las planillas (Suponga que existe una cantidad N de datos)
b) Mediante un algoritmo de búsqueda binaria permitir encontrar las fechas que han sido
reportadas como dudosas (un total de 17 fechas) y eliminarlas del conjunto de registros
de la base (para esto se deberán ingresar todas las fechas al mismo tiempo).
20
El funcionamiento del programa debe ser automático en el sentido de que el usuario ingresa
la totalidad de los datos y de las fechas. El programa deberá listar por pantalla la información
que se considera correcta sin intervención del operador.
Nota1: Usar al menos 3 funciones, no se permiten variables globales.
PROBLEMA 12:
Defina un tipo de estructurado de datos llamado TRANSISTOR con la siguiente información:
a) Modelo (2N2222,BC548,etc)
b) Precio
c) Ganancia de potencia eléctrica.
d) Tipo de encapsulado (TO-92, TO-46,etc).
El proceso de carga finaliza cuando se llega a un máximo de 100 transistores o cuando se
ingresa un modelo “NNN”. Se pide:
• Hacer el proceso de carga con asignación dinámica de memoria mediante una función.
• Ordenar y mostrar aquellos transistores por su ganancia, y a igual ganancia por su tipo
de encapsulado.
• Buscar aquellos transistores que tengan una ganancia igual a la ingresada por teclado,
mostrando todos los modelos correspondientes a esta ganancia y el porcentaje que
representa del total.
• Encontrar el promedio de ganancias de aquellos transistores cuyo tipo de encapsulado
se encuentran desde TO-32 a TO-54.
PROBLEMA 13:
Los datos relevantes de un grupo de alumnos de la Facultad de Ingeniería son:
• Nombre.
• Registro.
• Código de especialidad.
• Cantidad de exámenes rendidos.
• Notas de los exámenes (un conjunto de hasta 60 notas posibles).
• Promedio de los exámenes (sin incluir los aplazos. Este miembro no debe ser
ingresado, debe ser calculado por el programa!).
Se pide escribir un programa en C que sea capaz de leer estos datos para el conjunto de
alumnos encuestados, hasta que se ingrese un alumno cuyo código de especialidad sea
“FIN” o bien cuando se alcance un máximo de 100 alumnos (utilizar asignación dinámica de
memoria). También es necesario:
• Listar ordenados por código de especialidad y registro, todos los alumnos que no tienen
ningún examen reprobado.
• Se debe ingresar por teclado el código de una especialidad. Con estos valores crear un
nuevo conjunto (usar asignación dinámica de memoria) formado por todos los datos
de todos los alumnos que pertenezcan a la especialidad ingresada.
• Listar todos los datos correspondientes a los alumnos del arreglo creado, cuyo promedio
sea superior a 6 (seis).
Nota: No usar variables globales y utilizar al menos cuatro funciones
PROBLEMA 14:
Suponga que una compañía aérea maneja la siguiente información:
• Nombre pasajero (string).
• DNI (string).
• código pasaje (string).
• código lugar de destino (string).
• Hora de partida en horas (float).
• Fecha de partida.
21
• Precio del pasaje (float).
Considere que la compañía posee una promoción de un pasaje por persona a precios
rebajados.
En base a los datos se debe:
a) Cargar los datos mientras el lugar de destino sea diferente al de partida (considerar que
el lugar de partida debe ser suministrado al momento de comenzara ejecutarse el
programa).
b) Determinar y mostrar el destino más requerido y la cantidad de pasajes que le
corresponden.
c) Hacer un listado ordenado por código de pasaje y por hora de partida de aquellos que se
produzcan entre las 10,00 y las 18,00 horas inclusive.
PROBLEMA 15:
Un almacén desea informatizar la facturación de sus ventas. Para ello, necesita un programa
en C que debe tener en cuenta los siguientes datos para facturar cada producto:
• Numero de factura (numérico).
• Nombre del cliente (alfanumérico)
• Fecha de emisión de factura (alfanumérico con formato aaaammdd)
• Código del producto (hasta 6 caracteres alfanuméricos)
• Descripción del producto (hasta 30 caracteres alfanuméricos)
• Cantidad de productos (numérico)
• Precio unitario del producto (numérico)
El programa debe permitir:
a) Cargar las facturas (máximo 100).
b) Buscar una factura por fecha (búsqueda binaria, suponer fechas no repetidas) .
c) Mostrar por pantalla la factura buscada.
d) Borrar la factura buscada si se desea.
Nota: Las tareas citadas pueden realizarse mas de una vez y en forma repetitiva. Por
ejemplo, Cargar 10 facturas - Buscar 1 y mostrarla- cargar 5 facturas - buscar una y borrarla
etc. Por lo tanto, para esto se deberá realizar un menú.
PROBLEMA 16:
El servicio meteorológico nacional posee varias estaciones meteorológicas en diferentes
puntos de la república. Cada estación envía el central los datos recopilados durante un día
de mediciones. La información entregada se ajusta a una estructura del tipo:
• Número de estación (entero largo sin signo)
• Ubicación ( alfanumérico de 25 caracteres)
• Temperatura ( arreglo de 24 datos flotantes, medición por hora del día)
• Temp_max (flotante)
• Hora (entero)
• Fecha ( string de 9 caracteres, con la fecha actual)
Se pide un programa en C que realice lo siguiente:
a) asumir que el servicio posee N estaciones, realizando la reserva dinámica de memoria
para un mes de mediciones (30 días).
b) Realizar una función que permita la carga de las mediciones para el mes.
c) A través de una función, calcular la temperatura máxima de cada estación para ada día y
almacenarlo en el miembro de la estructura correspondiente, llenando también la hora a
la cual se produjo.
d) Realizar a través de una función, un listado ordenado por fecha y número de estación,
siempre y cuando la temperatura máxima registrada sea superior a los 35 grados.
e) Permitir por teclado el ingreso de una fecha y buscar la estación que registró la
temperatura máxima durante ese día, mostrar todos los elementos de la estructura.
22
PROBLEMA 17:
En un campeonato de tiro se desea llevar la estadística de la competencia. Por lo tanto se
debe ingresar la siguiente información:
• Nombre de tirador (string de 25 caracteres)
• Ciudad de origen del tirador (string de 15 caracteres)
• Edad (entero sin signo)
• Cantidad de tiros realizados por cada participante ( entero sin signo)
• Cantidad de puntos obtenidos por cada tiro (arreglo de enteros máx. 50, puntos posibles:
20, 40,60,80,100)
• Promedio de puntos obtenidos (real a calcular)
Se pide:
a) Hacer una función que permita cargar los participantes en el campeonato. La lectura
finaliza cuando se ingresa una edad inferior a 17 años o cuando el nombre finalice con la
secuencia “rt”. Esta última estructura no debe ser tenida en cuenta.
b) Hacer una función que permita calcular el promedio de tiro de cada participante y que lo
asigne al miembro correspondiente.
c) Generar un listado ordenado de mayor a menor por ciudad y a igual ciudad por promedio.
d) Suponiendo que exista más de un participante por ciudad, esto es un equipo de
participantes, se debe mostrar cual fue la ciudad que obtuvo el mejor promedio por
participante.
e) Generar y mostrar un nuevo arreglo con aquellos participantes de la “provincia de San
Juan” que hallan obtenido más del 50% del puntaje máximo posible.
23
PROBLEMAS RESUELTOS SOBRE OPERACIONES BÁSICAS
CON ARCHIVOS
PROBLEMA 1:
Ingresa datos por teclado para una estructura agenda y los graba en un achivo de texto.
#include <stdio.h>
#include <string.h>
typedef struct {
int num_ord;
char nombre[30];
char telf [14];
} AGENDA;
int carga_abo (AGENDA *age);
/* declaracion
void mostrar(AGENDA *age, int cant );
void grabar (AGENDA *age,int cant);
de funciones */
int main( ) {
AGENDA age[20];
int i, cant;
cant = carga_abo (age);
mostrar (age, cant);
system("pause");
grabar (age,cant);
}
void mostrar (AGENDA *age, int cant) {
int i=0;
printf ("\n\n\n Orden \t\t\t Nombre \t\t\t Numero \n\n");
for(i=0 ;i < cant; ++i) {
printf (" %d ", age[i].num_ord);
printf ("\t\t %20s \t",age[i].nombre);
printf ("%14s \n", age[i].telf);
}
}
int carga_abo( AGENDA *age ) {
int i = 0 ;
char c, nombre[30];
puts("Ingrese el Nombre del cliente 1:
gets( nombre );
");
while(strcmpi (nombre,"ultimo")) {
age[i].num_ord =i+1;
strcpy ( age[i].nombre, nombre);
puts (" ingrese el numero de tele");
gets(age[i].telf);
i++;
printf ("\nIngrese el Nombre del cliente %d:", i+1);
24
scanf("%s", nombre);
fscanf(stdin,"%c");
}
return (i);
}
void
grabar(AGENDA *age,int cant) {
int i;
FILE *arch;
arch = fopen("agenda.txt","wt") ;
if( !arch ) {
printf("No se puede abrir el archivo ");
exit(1);
} else {
for(i=0;i<cant;++i) {
fprintf (arch,"%2d %30s %14s\n",
age[i].num_ord,age[i].nombre, age[i].telf);
}
}
fclose(arch);
}
PROBLEMA 2:
Lee un archivo texto de estructuras agenda y lo muestra, realiza una primer lectura para
determinar la cantidad de estructuras que hay grabadas, con el objeto de realizar la reserva
dinámica de memoria correspondiente.
#include <stdio.h>
#include <string.h>
typedef struct {
int num_ord;
char nombre[30];
char telf [14];
} AGENDA;
void mostrar(AGENDA *age, int cant );
*/
/*declaración de funciones
int main( ) {
AGENDA *age, aux;
int cant=0, i;
FILE *arch;
arch = fopen("agenda.txt","rt") ;
if( !arch ) {
printf("No se puede abrir el archivo ");
exit(1);
}
/* lee el archivo para contar los elementos */
fscanf (arch,"%2d%30s%14s",&aux.num_ord,aux.nombre,aux.telf);
while ( !feof( arch ) ) {
25
cant++;
fscanf (arch, "%2d%30s%14s", &aux.num_ord, aux.nombre,
aux.telf);
}
age = malloc(cant * sizeof(AGENDA));
rewind( arch );
/* pide memoria */
for (i=0;i<cant; ++i) /* lee sobre el Arreglo de estructuras */
fscanf (arch, "%2d%30s%14s\n", &age[i].num_ord,
age[i].nombre, age[i].telf);
fclose(arch);
mostrar(age,cant);
system("pause");
free(age);
}
void mostrar(AGENDA *age, int cant) {
int i=0;
printf("\n\n\n Orden \t\t\t\t Nombre \t\t Numero \n\n");
for(i=0 ;i < cant; ++i) {
printf(" %d ", age[i].num_ord);
printf("\t\t %20s \t\t ",age[i].nombre);
printf("%14s \n", age[i].telf);
}
}
PROBLEMA 3:
Ingresa por teclado datos de la estructura agenda y los graba en un archivo Binario.
#include <stdio.h>
#include <string.h>
typedef struct {
int num_ord;
char nombre[30];
char telf [14];
} AGENDA;
int carga_abo ( AGENDA *age );
/* declaración de función */
void mostrar( AGENDA *age, int cant );
void grabar ( AGENDA *age, int cant );
int main( )
AGENDA
int i,
cant =
{
age[20];
cant;
carga_abo(age);
mostrar(age, cant);
grabar(age,cant);
system("pause");
}
26
void mostrar (AGENDA *age, int cant) {
int i=0;
printf ("\n\n\n Orden \t\t\t\t Nombre \t\t Numero \n\n");
for(i=0 ;i < cant; ++i) {
printf ("%d", age[i].num_ord);
printf ("\t\t%20s\t\t ",age[i].nombre);
printf ("%14s\n", age[i].telf);
}
}
int carga_abo(AGENDA *age ) {
int i = 0 ;
char c, nombre [30];
puts("Ingrese el Nombre del cliente 1:\t");
gets( nombre );
while(strcmpi(nombre, "ultimo")) {
age[i].num_ord = i+1;
strcpy( age[i].nombre, nombre);
puts("\ningrese el numero de telefono: ");
gets( age[i].telf );
i++;
printf("Ingrese el Nombre del cliente %d:\t",
scanf("%s", nombre);
fscanf( stdin, "%c" );
}
return (i);
i+1);
}
void
grabar (AGENDA *age, int cant) {
int i;
FILE *arch;
arch = fopen("agenda.bin","wb");
if( !arch ) {
printf("No se puede abrir el archivo ");
exit(1);
}
for( i=0; i < cant; i++) {
fwrite( age+i, sizeof(AGENDA), 1, arch);
}
fclose(arch);
}
PROBLEMA 4:
Lee archivo con estructura agenda en modo binario con función que lee y devuelve el
puntero al arreglo y la cantidad de datos por dirección, el nombre del archivo debe ser
ingresado por el usuario y se le fija la extensión .bin
#include <stdio.h>
#include <string.h>
typedef struct {
int num_ord;
27
char nombre[30];
char telf [14];
} AGENDA;
int carga_abo (AGENDA *age);
void mostrar(AGENDA *age, int cant );
AGENDA *leer(int *pt_cant);
int main( ) {
AGENDA *age;
int cant, i;
age = leer( &cant );
mostrar(age, cant);
getchar();
free (age);
}
/*Función que recibe puntero a la variable cant y retorna puntero al
arreglo de estructuras, dado que se pide memoria en la función.*/
AGENDA *leer( int *pt_cant ) {
AGENDA *age, aux;
int i, k;
FILE *arch;
char nomb_arch[20];
printf("\nIngrese el nombre del archivo binario a leer\n");
gets(nomb_arch);
strcat(nomb_arch,".bin");
/*Se le fija la extension */
arch = fopen(nomb_arch,"rb") ;
if( !arch ) {
printf("No se puede abrir el archivo ");
exit(1);
}
/* lee el archivo para contar los elementos */
k=0; /* Pone en cero el contador */
fread( &aux, sizeof(AGENDA), 1, arch);
while( !feof( arch ) ) {
k ++;
fread( &aux, sizeof(AGENDA), 1, arch);
}
/* pide memoria en la función*/
age = malloc(k * sizeof(AGENDA));
rewind(arch);
for (i=0; i< k ; ++i)
fread (age+i , sizeof(AGENDA) ,1, arch);
fclose(arch);
*pt_cant = k; /* copia la cantidad de estructuras en la
variable cant */
return age;
}
void mostrar (AGENDA *age, int cant) {
int i=0;
28
printf ("\n\n\n Orden \t\t\t\t Nombre \t\t Numero \n\n");
for(i=0 ;i < cant; ++i) {
printf (" %d ", age[i].num_ord);
printf ("\t\t %20s \t\t ",age[i].nombre);
printf ("%14s \n", age[i].telf);
}
}
PROBLEMA 5:
Leer los datos del último producto ingresado. Posicionarse al final del archivo e ingresar un
nuevo producto. Mostrar el contenido de todo el archivo.
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct{
int codigo;
char descripcion[50];
float precio_unit;
} PRODUCTO;
PRODUCTO cargar_producto( void );
void imprimir_producto( PRODUCTO aux );
int main( ) {
FILE *stock;
PRODUCTO aux;
int i, n;
printf(" Ingrese cantidad de productos\n");
scanf("%d",&n);
if ((stock = fopen("stock.dat", "wb+"))==NULL) {
printf(" No se puede abrir el archivo.\n");
exit(1);
}
for ( i=0; i<n ; ++i ) {
aux = cargar_producto();
fwrite(&aux,sizeof(PRODUCTO),1,stock);
}
printf(" El ultimo producto es\n" );
fseek( stock, (n-1)*sizeof(PRODUCTO), SEEK_SET );
fread( &aux, sizeof(PRODUCTO), 1, stock );
imprimir_producto(aux);
/* Se posiciona en el EOF para escribir una nueva
estructura al final */
printf("Ingrese un nuevo producto al finaldel archivo\n" );
fseek( stock, 0, SEEK_END);
aux = cargar_producto();
fwrite( &aux, sizeof(PRODUCTO), 1, stock);
/* Lista todo el archivo en forma secuencial */
29
printf(" Lista todos los Productos ");
rewind(stock);
fread( &aux, sizeof(PRODUCTO), 1, stock);
while( feof(stock)==0) {
imprimir_producto(aux);
fread ( &aux, sizeof(PRODUCTO), 1, stock);
}
fclose(stock);
system("pause");
}
PRODUCTO cargar_producto( void ) {
PRODUCTO temp;
printf( "Datos del producto\n" );
printf( "Codigo\n" );
scanf( "%d", &temp.codigo);
fflush( stdin );
printf( "Descripcion\n" );
fgets( temp.descripcion, 50, stdin );
/* si hay mas caracteres queda el buffer cargado */
fflush(stdin);
printf( "Precio\n" );
scanf("%f",&temp.precio_unit);
printf("\n\n");
return temp;
}
void imprimir_producto(PRODUCTO aux) {
printf("Datos del producto\n");
printf("Codigo:%d\n", aux.codigo );
printf("Descripcion:%s\n", aux.descripcion );
printf("Precio Unitario:%f\n", aux.precio_unit );
printf("\n\n");
}
PROBLEMAS PROPUESTOS CON ESTRUCTURAS Y ARCHIVOS
PROBLEMA 1:
Una empresa que produce aceites, almacena los datos de la producción diaria de cada una
de sus 2 filiales en estructuras del tipo:
• Nombre del aceite (char)
• Precio de Venta (float)
• Cantidad Vendida (entero)
• día (char)
Se cuenta con un archivo binario que posee la información de la producción por día de un
cierto periodo de la primer filial, ordenado de menor a mayor por Cantidad Vendida. Así
mismo, existe un archivo binario correspondiente al mismo periodo de la segunda filial
desordenado.
Se solicicta:
a) Intercalar los datos de ambos archivos en un único arreglo de estructuras ordenado por
el campo Cantidad Vendida y almacenarlo en un nuevo archivo texto.
30
b) Calcular el promedio de las ventas de cada filial y el de la producción conjunta (pesos)
por día.
c) Contar cuantas ventas de la primer filial superaron el promedio conjunto de ventas
calculado en el punto anterior.
PROBLEMA 2:
Una fábrica de cables desea evaluar los resultados de su producción durante un mes para
realizar el control de calidad de la misma. Los datos de los lotes de cables fabricados son:
• Número de Lote (entero positivo de cuatro cifras)
• Fecha de fabricación (cadena de 7 caracteres -> aammdd)
• Peso del cobre utilizado (real)
• Longitud del cable fabricado (real)
• Color del aislante (cadena de caracteres)
• Peso del aislante por metro de cable (real)
Los datos de la producción de un mes se encuentran ya grabados en un archivo tipo ASCII.
Se pide generar un programa en lenguaje C que lea los datos de este archivo y los procese
para obtener:
a) Un archivo binario que contenga los números de lote, longitud del cable y peso del cobre
de todos los lotes cuyo color del aislante coincidan con uno ingresado por el usuario
mediante teclado, ordenado por número creciente de lote. El nombre de este archivo será
el nombre del color seleccionado con la extensión .CBL (debe ser un nombre DOS
válido)
b) Un archivo ASCII que contenga los números de lote, longitud del cable y peso del cobre
de todos los lotes cuya longitud de cable sea igual a un valor ingresado por el usuario por
teclado con una tolerancia del 10% en más o menos, ordenados por fecha de producción.
c) Un listado por pantalla de los datos de todos los lotes fabricados en el mes que tengan
un peso de cobre superior al peso del lote correspondiente al que posee menor numero
de lote.
PROBLEMA 3:
Una estación de servicio durante un mes se relevó la información relativa a sus ventas. Para
esto se generó un archivo binario de nombre “estacion.bdd” con los siguientes Datos:
• Nombre del Cliente (máximo 30 caracteres)
• Fecha de la factura (año mes día) (7 caracteres)
• Número de factura (entero doble precisión)
• Cantidad de litros (entero)
• Precio total de la venta (real)
• Tipo de nafta (S , C o R) (caracter)
Considerando que este archivo existe, desarrollar un programa en C que realice las
siguientes operaciones:
a) Leer el archivo.
b) Calcular y mostrar por pantalla el promedio de ventas por día, e indicar el dia de mayor
venta.
c) Generar un archivo de texto que contenga las ventas realizadas en el mes cuyas
cantidades de litros están comprendidas entre 35 y 45 litros de nafta S (Súper).
Ordenadas alfabéticamente por nombre del cliente.
d) Calcular y mostrar el porcentaje sobre el total de las ventas que corresponde a nafta
súper y nafta común.
Nota: S, C o R se entiende como Súper, Común o Refinada.
PROBLEMA 4:
31
Un hospital dispone de un sistema automático de evaluación de fallas de sus equipos. Este
sistema, por cada máquina graba en un archivo binario (falla.bin) una estructura con la
siguiente información:
• Nombre de la máquina (17 caracteres)
• Nro. de serie (entero ocho dígitos numéricos)
• Ubicación (15 caracteres)
• modelo (5 caracteres)
• tiempo entre fallas (arreglo de 200 muestras, cada muestra expresada en minutos)
• MTBF (real)
El tiempo entre fallas es un arreglo de enteros que almacena los intervalos entre fallas, por
ejemplo: 60, 30, 45, 15,..., 0,0,0,0....
a) Calcular el tiempo medio entre fallas (MTBF) para cada máquina y almacenarlo en el
campo MTBF de la estructura de datos. Este se calcula como el promedio de los tiempos
entre fallas para cada maquina.
b) Almacenar la información en otro archivo (de texto ) falla2.txt, ordenado por MTBF y
modelo de mayor a menor.
c) Calcular el MTBF promedio de las máquinas que con número de serie entre 100.000 y
200.000, y mostrarlo por pantalla.
d) Calcular el porcentaje de máquinas del total cuyo MTBF sea inferior al promedio
calculado en el punto anterior.
PROBLEMA 5:
Dada la siguiente estructura de datos:
struct Integrado{
int Codigo;
int Cantidad;
float PrecioUnitario;
char Descripcion[40];
char Proveedor[40];
};
Realizar un programa en lenguaje C compuesto de cuatro funciones, cada una de las cuales
debe permitir:
a) Leer todas las estructuras del tipo mencionado, que existan en el archivo A:\circ.dat", el
cual es de tipo binario.
b) Ingresar nuevas estructuras tomando los datos desde teclado.
c) Ordenar las estructuras por el campo Código en forma creciente y guardarlas ordenadas
en el archivo de tipo ascii "c:\almacen\lista.txt"
d) Actualizar el archivo binario "c:\almacen\circ.dat"
El programa, al iniciarse, debe reservar memoria, levantar todas las estructuras existentes y
presentar un menú de opciones al usuario, a fin de que realice cualquiera de las
operaciones descriptas o pueda abandonar el programa. Cuando se realiza la reserva de
memoria prever que se deben agregar nuevas estructuras y cuando se agregan de no
superar la memoria solicitada.
PROBLEMA 6:
Una compañía fabricante de tornillos recibe diariamente por correo electrónico un archivo
binario conteniendo las especificaciones de los tornillos que fabricará ese día. El archivo
consiste en un conjunto de bloques de datos que contienen las siguientes especificaciones:
• Código o tipo del tornillo (alfanumérico de 12 caracteres válidos).
métrico, P
pulgadas)
• Sistema de medida del tornillo (un único carácter : M
• Largo del tornillo en mm (Real)
• Diámetro del tornillo en mm (Real)
• Número de filetes por unidad de medida (entero)
32
• Cantidad de tornillos a fabricar con esas especificaciones (entero)
La empresa dispone de un torno de mando numérico que fabrica automáticamente los
tornillos, el cual requiere que la información de cada tipo de tornillo a construir le sea
entregada en un archivo de texto. Es necesario entonces construir a partir del archivo binario
recibido un conjunto de archivos de texto (uno para cada tipo de tornillo) cuyo nombre sea
igual a los ocho primeros caracteres del código y con la extensión .tor. La información
contenida en cada archivo así generado es la misma que existe en el bloque de datos
correspondiente con la excepción del código del tornillo. La generación de los archivos
debe hacerse ordenada por código.
Se deberá listar por pantalla aquellos tipos de tornillo fabricados en el sistema métrico cuyo
volumen total de material utilizado no supere 150000 mm3.
Se deberá ingresar por teclado un tipo de tornillo especificado, e indicar el número total de
filetes que este posee, ordenados por cantidad a fabricar.
Nota: Se deberá realizar al menos 4 funciones.
PROBLEMA 7:
Una empresa dedicada al tratamiento de agua desea realizar un algoritmo en lenguaje C
para procesar la información relativa al proceso durante un año. La información producida
por el equipo de purificación se almacena en un archivo binario de nombre “purific.bdd” con
los siguientes datos:
• fecha de lectura (caracter 9) en formato aaaammdd
• hora de lectura (caracter 7) en formato hhmmss
• porcentaje de cloro (real)
• cantidad de metros cúbicos procesados (real)
• tiempo de procesamiento (caracter 7) en formato hhmmss
• estación del año (I, V, O, P) caracter.
Además se dispone de otro archivo binario con 4 estructuras cuyo nombre es ¨epoca.bdd¨,
con la siguiente información:
• estación del año (I, V, O, P)
• porcentaje de cloro ideal
• tolerancia del porcentaje de cloro
• tiempo de procesamiento ideal.
Realizar un programa en C que realice lo siguiente
a) A través de una función leer la base de datos y almacenarla en un arreglo dinámico de
memoria.
b) A través de una función listar ordenado por fecha y hora los datos correspondientes a
Primavera y Verano.
c) Mediante una función generar un archivo de texto ¨Audit.txt¨ que contenga la información
de todos aquellos registros que cumplan con la especificación , que se encuentra en el
segundo archivo, para invierno.
d) Ingresar dos fechas por teclado, buscar y listar todos los registros comprendidos entre
ellas.
PROBLEMA 8:
Una empresa dedicada a la fabricación de diskettes desea relevar información de la
producción. A cada disquete se le asocian los siguientes datos:
• Número de Serie (long)
• Tipo (String: FD1.44, FD1.2,FD720, FD360)
• Calidad (entero: 10-8: Buena, 7-5: Regular, 5-0: Mala)
• Color caja (String)
• Test( Carácter: 'A': Aprobado, 'R': Rechazado)
33
Se dispone de un archivo binario denominado diskette.bin con la información de la
producción de los disquetes. Se pide:
a) Leer el contenido del archivo (con asignación dinámica de memoria).
b) Analizar cada disquete y llenar el campo test de acuerdo a la calidad de cada uno, siendo
'A'= Calidad buena, 'R'= calidad regular o mala.
c) Generar un archivo de texto (ASCII) denominado buenos.txt, en el directorio
c:\diskettes con la información de los disquetes aceptados ordenados por tipo.
d) Hacer un listado ordenado por test y tipo indicando el porcentaje de disquetes aprobados
y rechazados para cada tipo.
PROBLEMA 9:
En el control de tránsito aéreo se almacenan los datos de las solicitudes de distintos aviones en
vuelo y los que están con posibilidad de decolaje utilizando estructuras de datos que poseen los
siguientes datos:
• Fecha (string “dd:mm:aaaa”)
• Hora (string “hh:mm:ss”)
• Altitud (entero sin signo, es un código de nivel)
• Mensaje (string long. Máxima de 250 caracteres útiles)
• Respuesta (string long. Máxima de 80 caracteres útiles)
• Código del avión (entero sin signo)
• Código de la empresa (entero sin signo)
Se necesita realizar un programa en C que permita realizar las siguientes tareas:
a) Leer todas las estructuras almacenadas en el archivo binario (“C:\vuelo\datos.bin”),
realizando reserva dinámica de memoria, y previendo una cantidad adicional de 100
estructuras, a los fines de permitir eventuales incorporaciones de nuevas estructuras.
b) Agregar por teclado nuevas estructuras, solicitando al operador cada uno de los campos.
c) Generar un archivo de texto que contenga los códigos de avión y empresa de aquellos
aviones que se hubieren comunicado entre dos momentos determinados, ordenado por
empresa y luego por avión
d) Muestre por pantalla un listado de todos aquellos aviones cuya altitud sea mayor que una
ingresada por teclado, ordenado por fecha y hora.
e) Actualizar el archivo binario.
f) Eliminar una estructura cuyo código de empresa y avión se ingrese.
g) Implementar un menú para realizar las operaciones de b) a f) en forma reiterada.
PROBLEMA 10:
Una empresa que fabrica telas almacena los datos de su producción utilizando estructuras
que contienen los siguientes datos para cada lote:
• Fecha (string “aaaa:mm:dd”)
• Hora (string “hh:mm:ss”)
• Longitud en metros (real)
• Ancho en metros (real)
• Color (string de 10 caracteres útiles)
• Código del lote (entero sin signo)
Se necesita realizar un programa en C que permita realizar las siguientes tareas:
a) Leer todas las estructuras almacenadas en el archivo binario (C:\stock\datos.bin”),
realizando reserva dinámica de memoria, y previendo una cantidad adicional de 50
estructuras más, a los fines de permitir eventuales incorporaciones de nuevas
estructuras.
b) Agregar por teclado nuevas estructuras, solicitando al operador cada uno de los campos.
c) Generar un archivo de texto que contenga las longitudes y anchos de los lotes de un
color determinado, ordenados por fecha y hora de fabricación en orden ascendente (los
más viejos arriba).
34
d) Muestre por pantalla un listado de todos aquellos lotes que hayan sido fabricados en un
determinado día y cuyo ancho esté comprendido entre dos límites determinados,
ordenado por color.
e) Actualizar el archivo binario.
PROBLEMA 11:
Una empresa de telefonía lleva un registro detallado de cada uno de los teléfonos que
produce. La información relevante para cada uno de ellos es la siguiente:
• Número de serie del teléfono (string de 10 caracteres alfanuméricos con el siguiente
formato: LnnSxxTyyy, donde nn son dos dígitos que indican el número de lote, ss son
dos dígitos que indican el número de semana del año cuando se fabricó el teléfono e
yyy son tres letras minúsculas que indican el tipo de teléfono: ang si es analógico o dig
si es digital).
• Cantidad de memorias para discado rápido (entero positivo).
• Color del teléfono (string que puede tomar los valores “BLANCO”, “GRIS” o “NEGRO”)
• Calidad de fabricación (entero positivo que puede tomar los siguientes valores: 0 si es
de primera calidad, 1 si es de segunda calidad o –1 si es para descarte).
Los datos de la fabricación del último año se encuentran grabados en un archivo binario con
el nombre “telefono.bin”, pero se desconoce la cantidad de registros grabados en el mismo
(hay que contarlos).
Se necesita un programa en lenguaje C que permita las siguientes operaciones sobre estos
datos:
a) Cargar desde disco a memoria todos los datos del archivo telefono.bin (es obligatorio
usar asignación dinámica de memoria).
b) Listar por pantalla el número de serie y la calidad de fabricación de todos los teléfonos
negros que tienen más de cuatro (4) memorias de discado rápido, ordenados por
numero de serie.
c) Generar un archivo de tipo texto (ASCII), llamado descarte.txt, con todos los datos de
los teléfonos cuya calidad es de descarte, que pertenezcan al lote número 13 y que
hayan sido fabricados antes de la semana 24.
d) Calcular y mostrar la cantidad de teléfonos y el porcentaje que ella representa sobre el
total, de todos aquellos teléfonos GRISES cuya calidad es de segunda.
PROBLEMA 12:
Dos Empresas dedicadas a la fabricación de DVD transfieren información relevante de la
producción a través de un archivo binario que se llama “datosdvd.bin”. La Empresa
número 1 se dedica a la fabricación del DVD virgen con la caja, la segunda empresa se
encarga de grabar, etiquetar y distribuir cada uno de los DVD que le llegan de acuerdo a la
demanda del publico. El archivo binario a través del cual se transfiere la información entre
las empresas, posee los siguientes datos:
• Numero de serie (entero largo positivo)
• Color (string)
• Control de Calidad (string: Ver más abajo el formato de este campo)
• Capacidad (entero largo).
• Tipo (string: M=Musica, V=Video, S=Software Operativo, A= Software de Aplicación,
I=Multimedia, ver más abajo)
• Distribuidora (string)
La empresa 1 llena solamente los campos numero de serie, color y control de calidad,
siendo este último un string de la forma E1nn donde nn es 00 si esta defectuoso, 01 si
posee una cara útil, 10 si posee la otra cara útil y 11 si las dos caras son útiles.
La Empresa 2 al recibir el archivo completa la estructura con todos los datos faltantes,
agregando al campo control de calidad un string de la forma E2xx, donde xx significa: 00 si
35
no se pudo grabar la información, 11 si la grabación fue un éxito y está listo para ser
comercializado.
Importante: El campo tipo por su lado puede ser una combinación de caracteres de acuerdo
a lo explicitado en la definición (P.ej: M o MV o MSA, etc..., es decir, cualquier combinación
válida de los caracteres se permite).
Se pide:
a) Hacer un programa en C que lea el archivo binario enviado por la Empresa 1 y permita la
carga de la información faltante por la empresa 2 según el proceso explicado (usar
asignación dinámica de memoria).
b) Regenerar el archivo binario original, de forma tal que en él solo aparezcan todos los
datos de aquellos DVD que tienen al menos una cara útil y cuya grabación fue exitosa y
que son de color “VERDE”, ordenados por número de serie.
c) Calcular la cantidad de DVD defectuosos entregados por la empresa 1 y la cantidad de
DVD que no han sido grabados por la Empresa 2. Calcular también el porcentaje que
estas dos cantidades representan del total de DVD fabricados.
PROBLEMA 13:
La Policía de San Juan está realizando un relevamiento de los conductores de automóviles
para obtener información del pago o no del incentivo docente. Con tal motivo la información
recabada para cada conductor es:
• Nombre y Apellido (string de 40 caracteres)
• Tipo de vehículo (A=auto, M=moto, C=camioneta)
• Modelo (string de 15 caracteres)
• Marca (string de 15 caracteres)
• Monto pagado (real)
• Fecha actual(string de la forma aaaa-mm-dd)
• Fecha de Pago (string de la forma aaaa-mm-dd)
• Condición (carácter) (P = pagado, M= moroso)
Con esta información se genera un archivo binario de nombre incentiv.bdd que luego es
enviado a la Sec. de Hacienda para calcular datos estadísticos de importancia.
Se solicita implementar un programa en lenguaje C que permita realizar las siguientes
tareas:
a) Leer el archivo binario utilizando asignación dinámica de memoria.
b) Generar un archivo texto denominado Regla.txt con los datos de la base ordenados por
tipo de vehículo y por nombre de los conductores que han pagado el incentivo docente.
c) Generar un nuevo archivo binario (ATiempo.bdd) con los datos de los conductores que
hayan pagado antes del primero de agosto del año 1999 ordenados por fecha de Pago.
d) Calcular el porcentaje de morosos.
e) Desarrollar una única función que se invoque tres veces que permita calcular los
porcentajes de Autos, motos y camionetas que han pagado el incentivo.
PROBLEMA 14:
El Ente Regulador del Transporte Público de Pasajeros de nuestra ciudad ha solicitado se
realice un programa en Lenguaje C para ejecutar las siguientes operaciones. Esta Institución
entrega un archivo binario denominado Unidades.bdd con la siguiente información
• Nombre de la Empresa (string 20 caracteres)
• Numero de unidad
• Numero de Línea a la cual la unidad está afectada (entero sin signo)
• Nombre del chofer (string de 20 caracteres)
• Tiempo promedio de una vuelta del recorrido (real)
• Cantidad promedio de pasajeros por vuelta (real)
• Observaciones (A – asalto, C – choque, M – averiada, S – sin observaciones)
36
Se pide realizar el programa para extraer la siguiente información:
a) Lectura del archivo binario con asignación de memoria dinámica
b) Calcular y mostrar el tiempo de recorrido promedio y la cantidad de pasajeros promedio
por cada Línea de ómnibus
c) Generar un archivo ASCII (Empresas.txt) con la información de Nombre de la empresa,
numero de línea, tiempo promedio de recorrido, cantidad promedio de pasajeros
ordenado por nombre de la empresa y numero de Línea de aquellas unidades que no
posean observaciones.
d) Calcular y mostrar la Cantidad de recorridos que realiza cada unidad sabiendo que las
mismas comienzan a las 6 de la mañana y finalizan a las 0 horas, además averiguar la
cantidad de pasajeros que transporta por día, por mes y por año cada unidad.
PROBLEMA 15:
Una editora de libros desea contar con información relativa a la fabricación de sus productos.
Para ello nos envía un archivo en formato texto denominado “libros.txt” con información de
su producción. Para cada conjuntos de libros producidos el archivo contiene la siguiente
información de cada uno de los libros:
• Titulo del libro (máximo 50 caracteres).
• Autor(máximo 30 caracteres)
• Cantidad de paginas
• Precio
• Presentación (caracter D: Tapas duras, B:Tapas blandas)
• Cantidad de libros.
Se pide realizar un programa en lenguaje C que permita procesar esta información:
a) Leer los datos de cada libro a un arreglo dinámico en memoria.
b) Se deberá realizar una función que calcule el precio de cada libro y se llene el campo de
la estructura correspondiente teniendo en cuenta que cada página cuesta $0.001 y la
encuadernación de tapas blandas $5 y de tapas duras $8.
c) Generar un archivo binario denominado “libros2.bdd” ordenado por Autor y
simultáneamente por cantidad de paginas con la siguiente información: Título del Libro,
Autor. numero de paginas y precio.
d) Permitir que el usuario introduzca una cierta cantidad de lestras del nombre del Autor vía
teclado y muestre la información para cada Autor que sus primeras letras coincidan con
las letras ingresadas toda la información de cada uno de sus libros.
PROBLEMA 16:
En una empresa maderera se desea llevar el registro de los productos que comercializa,
para lo cual se dispone de un archivo ASCII denominado “madera.txt” con la información:
• Especie de árbol (string 20)
• Tipo de madera (carácter M= Machimbre, L= Listón, C = Cabio)
• Ancho en pulgadas
• Alto en pulgadas
• Largo en pulgadas
• Precio de la pulgada cúbica
• Cantidad en stock
Se pide se desarrolle un programa en “C” que ejecute la siguiente tarea:
a) Leer el archivo entregado por la empresa y almacenarlo en memoria usando asignación
dinámica de memoria.
b) Permitir que el usuario ingrese una cierta cantidad de madera necesitada, la especie de
árbol y el tipo de madera. La función deberá verificar su existencia en stock y en caso
afirmativo se deberá descargar del mismo la cantidad solicitada. Este proceso debe
continuar hasta que el operador manifieste que no necesita ingresar nuevos datos.
37
c) Generar un archivo binario con la información anterior pero agregándole el precio de
cada unidad de madera. En este caso deberá agregar más información que la que posee
la estructura dada, la cual consiste en el precio de cada madera.
d) Generar un Listado ordenado por Especie de árbol y por cantidad en stock de aquellas
maderas que en stock se superen las 100.
PROBLEMA 17:
Un supermercado atiende a los grandes clientes a través de un sistema de computo que
genera un archivo binario de nombre clientes.bdd. La información contenida en este archivo
es la siguiente:
• Nombre del Cliente (string de 30 caracteres)
• Razón Social (string de 20 caracteres)
• Fecha del pedido (string, aaaa-mm-dd)
• Código del producto mas vendido al cliente (entero)
• Cantidad de productos comprados (entero)
• Monto total de la compra (real)
Al final del día se extrae información del archivo. Se pide se haga un programa en C que
permita realizar la siguiente tarea:
a) Leer el archivo binario utilizando asignación dinámica de memoria
b) Calcular y mostrar cual fue el código del producto mas vendido durante el día y a que
Clientes se vendieron.
c) Generar un archivo ASCII con la información de Nombre del cliente, Razón Social,
Código del producto más vendido y monto total de la compra solo para aquellos clientes
que satisfacen la condición dada en b).
d) Realizar un listado total ordenado por Nombre del Cliente y Código del producto más
vendido de aquellos clientes que compraron mas de $100 o que la cantidad de productos
comprados superaron los 40.
PROBLEMA 18:
Una empresa de turismo para hacer las reservas de los pasajes de avión de los usuarios
genera un archivo ASCII, con la siguiente información.
• Nombre del cliente.
• Fecha de vuelo (string de la forma aaaa-mm-dd).
• Código de vuelo (string de 5 caracteres).
• Cantidad de asientos
• Código de destino(string de 5 caracteres)
• Precio del pasaje.
Se extrae información de los pasajes vendidos durante el día. Para esto se pide realizar un
programa en C que cumpla lo siguiente:
a) Leer el archivo ASCII utilizando asignación dinámica de memoria.
b) Calcular y mostrar cuántos pasajes se vendieron de cada vuelo y el monto recaudado.
c) Calcular y mostrar cuál fue el destino al que viajará mayor cantidad de pasajeros.
d) Generara un archivo binario con la información de Nombre del cliente, Código del vuelo,
Código de destino, Cantidad de asientos vendidos y Precio total de la venta.
PROBLEMA 19:
Una fábrica de resmas de papel genera diariamente un archivo binario en el que se
encuentra la información de la producción de ese día. Esta información consta de los datos
de todas y cada una de las resmas fabricadas, según el siguiente detalle:
• Número de serie de cada resma. (string de 15 caracteres útiles)
• Peso del papel por metro cuadrado, en gramos. (entero)
• Dimensiones del papel de la resma. (largo y ancho en centímetros; reales)
38
• Cantidad de hojas de papel que forman la resma. (entero)
• Hora de fabricación de la resma. (string en el formato hh:mm:ss )
Se pide realizar un programa en lenguaje C que permita:
a) Generar un archivo ASCII (texto) con el número de serie y la hora de fabricación de
todas las resmas cuyo tamaño sea de 21 cm por 29.7 cm y con un peso de papel
superior a los 70 grs., ordenado por hora de fabricación.
b) Generar un archivo binario con todos los datos de las resmas cuyo peso (peso de la
resma, no del papel) supere los 2000 grs.
c) Imprimir por pantalla el número de serie y hora de fabricación de todas las resmas que
han sido fabricadas entre las 06:00:00 hs. y las 10:30:00 hs, ordenadas Por número de
serie.
PROBLEMA 20:
Una fábrica dispone de una archivo con información de sus productos denominado prod.bdd
con la siguiente información:
• Código del producto (entero sin signo)
• Nombre del Producto (string de 25 caracteres)
• Tipo de producto (carácter)
• Cantidad de productos en stock (entero)
• Precio Unitario del producto (real)
• Fecha última reposición de productos (string aaaammdd).
Se pide realizar un programa en C que ejecute lo siguiente:
a) Volcar la información del archivo a la memoria utilizando asignación dinámica.
b) Mediante una función realizar un listado ordenado por tipo de producto y nombre de
producto de aquellos productos con fecha de última reposición en el rango dado a
continuación. Se debe permitir el ingreso de una fecha por teclado, se calcula el rango
como la fecha ingresada y la fecha de un año antes de esta.
c) Mediante una función se pide generar un nuevo arreglo de estructuras que contenga
código y cantidad de productos cuyo stock esté por debajo de 10.
d) Mediante una función se deberá generar un archivo de texto con la información contenida
en el arreglo generado en el punto anterior.
e) Mediante una función se deberá calcular el capital disponible de la empresa ( total de
cantidad de productos por precio unitario). Este valor también deberá guardarse en el
archivo generado en el punto anterior.
PROBLEMA 21:
La Facultad de Ingeniería necesita de un programa en C para evaluar el rendimiento de los
alumnos durante el cursado, para cada una de las 12 Carreras de Grado. Sección alumno
entrega la información de cada alumno en un archivo binario con la siguiente información:
• Numero de registro del alumno;
• Nombre de la Carrera a la que pertenece
• Semestre de cursado
• Cantidad de materias que cursa
A su vez se dispone de un archivo de texto con la siguiente información:
• Numero de registro del alumno
• Cantidad de materias que cursa
• Nota de cada una de las materias que cursa.
En cada uno de estos archivos existe solo un registro por cada alumno de la Facultad. Se
pide:
a) Mediante una función realizar la carga de los datos de cada alumno que se encuentra en
los archivos. Esto se debe hacer en forma dinámica respetando la siguiente estructura de
datos
39
•
•
•
•
•
b)
c)
d)
e)
Numero de registro del alumno (entero largo sin signo)
Nombre de la Carrera a la que pertenece (string de 40 caracteres válidos)
Semestre de cursado (entero sin signo)
Cantidad de materias que cursa (entero sin signo)
Arreglo de 10 enteros con las notas obtenidas por los alumnos en cada una de las
asignaturas que cursa.
• Promedio de notas.
Mediante una función calcular la nota promedio por alumno y almacenarla en la
estructura (llenar el campo vacío).
Mediante una función calcular las notas promedio por Carrera.
Realizar un listado ordenado por Carrera y Semestre de la nota promedio de los
exámenes, indicando en cada caso la cantidad de alumnos que han rendido.
Generar un archivo binario con el nombre de la Carrera, Semestre y nota promedio, solo
de aquellas Carreras en las cuales la nota promedio ha superado los 6 puntos.
PROBLEMA 22:
Un laboratorio de análisis clínicos necesita de un programa en C que le permita obtener
información acerca de los estudios que realizan. Para este motivo por cada estudio realizado
se llena la siguiente información:
• Código del Estudio (string 5 caracteres válidos)
• Numero de afiliado (entero largo)
• Obra Social del paciente (string 15 caracteres válidos)
• Cantidad de Glóbulos Rojos (máximo valor = 15.000.000)
• Cantidad de Glóbulos Blancos (máximo valor = 50.000)
• Cantidad de Plaquetas (máximo valor = 1.000.000)
• Eritrosedimentación (entero)
• Diagnóstico (string 20 caracteres vacío)
Esta información se guarda en un archivo binario, cuyo nombre es ingresado por el
operador.
Se pide realizar mediante un programa en C las siguientes tareas:
Leer el archivo binario y asignarlo a un arreglo de estructuras en forma dinámica en la
memoria.
Para cada uno de los pacientes se debe rellenar el campo diagnostico con la información
consignada en la tabla siguiente.
Condición
Cantidad de Glóbulos Rojos inferior a 2.000.000.
Cantidad de Glóbulos Blancos superior a 15.000 y
Eritrosedimentación en el rango 10 a 19mm.
Cantidad de Glóbulos Blancos superior a 20.000 y
Eritrosedimentación en el rango 20 a 30mm.
Cantidad de Glóbulos Blancos superior a 35.000 y
Eritrosedimentación superior a 31 mm
Cantidad de plaquetas en el rango 230.000 a 270.000
En otro caso se deberá indicar por pantalla la información
concerniente a Cantidad de Glóbulos rojos, blancos y
plaquetas y requerir al operador que ingrese el diagnostico.
Diagnostico
Anemia
Infección leve
Infección media
Infección severa
Reservado
Ingresado por el
operador
a) Realizar un listado ordenado por Obra Social y Diagnostico de todos los pacientes
con eritrosedimentación entre 21mm y 35mm.
b) Generar un archivo de texto cuyo nombre sea COddmmaa.txt. Donde ddmmaa es la
fecha que debe ser ingresada por el operador. El archivo debe contener la siguiente
información y según el siguiente formato,
40
Obra Social
Numero de Afiliado
...
Numero de Afiliado
Obra Social
Numero de Afiliado
...
Numero de Afiliado
Código de Estudio
Código de Estudio
Código de Estudio
Código de Estudio
PROBLEMA 23:
Una empresa dedicada al riego por goteo dispone de un archivo binario denominado
“clientes.bdd” con los cuales desea relevar cierta información estadística. Por cada
propiedad de los clientes dispone de la siguiente información en el archivo:
• Nombre del Cliente (string de 30 caracteres)
• Cantidad de Hectáreas de propiedad (entero)
• Numero de experimentos a realizar (entero por defecto 0)
• Gotas por Hora por Experimento (arreglo de 100 enteros)
• Rendimiento de las plantas (arreglo de 100 floats)
La información en el archivo esta disponible parcialmente.
Se desea:
a) Leer el archivo binario utilizando asignación dinámica de memoria. Completar los datos
de acuerdo al resultado de cada experimento. Los datos a completar son Numero de
experimentos, Gotas por hora por experimento y rendimiento. Para poder llevar a cabo
esta tarea se deberá requerir al operador (por teclado) el nombre de un Cliente y
completar la información necesaria. Debe tener en cuenta que un mismo Cliente puede
poseer mas de una estructura, este proceso finaliza cuando el nombre del cliente
comience con la las letras “RPN”.
b) Listar todos los datos de las clientes a los que se les haya completado la información
ordenado por Nombre de cliente y cantidad de hectáreas.
c) Generar un archivo de texto con la información del Cliente que más experimentos haya
realizado. En caso de igualdad se deberá considerar el de mayor cantidad de hectáreas.
El nombre del archivo debe ser, el nombre del cliente (8 primeros caracteres) y extensión
“.txt”. La información a grabar en el archivo debe ser: Cantidad Total de hectáreas,
Número total de experimentos, Promedio de rendimiento, Máximo y Mínimo rendimiento
obtenido.
Utilizar por lo menos 5 funciones y no se deben utilizar variables globales
PROBLEMA 24:
Una empresa de turismo promociona viajes para estudiantes a distintos destinos dentro de la
República Argentina. Para esto carga la siguiente información de cada estudiante como
preinscripción del viaje.
• Nombre Completo
• Documento
• Teléfono
• Dirección
• Destino
Esta información se guarda en un archivo binario cuyo nombre es: viajes.bdd.
Suponiendo que se dispone de este archivo se pide realizar un programa en C que permita:
a) Cargar la información del archivo en un arreglo dinámico de memoria.
b) Permitir que se pueda confirmar el viaje agregando a la información disponible de cada
estudiante la fecha del viaje, el costo del viaje y un campo carácter de confirmación
(´C´confirma, otra cosa no confirma). También se debe permitir agregar estudiantes que
a último momento decidieron realizar el viaje.
41
c) Mediante una función se pide realizar un listado ordenado por Destino y Nombre de
estudiante de acuerdo al siguiente detalle:
Destino
Nombre
…….
Total Destino:
Documento Telefono
$costo
$(costo total)
Mediante una función averiguar cual es el destino mas elegido por los estudiantes y que
porcentaje de estudiantes representa. (Esta información debe ser mostrada en el main).
Generar un archivo de texto con la siguiente información: Nombre del estudiante,
documento, teléfono, destino.
Nota: Para la resolución de los programas, se deben utilizar no menos de 3 o 4
funciones, que sean lógicas desde el punto de vista de la buena práctica de la
programación. No se pueden utilizar variables globales.
PROBLEMA 25:
El Gremio que nuclea los docentes de San Juan necesita procesar la información de sus
afiliados. La información de los mismos se encuentran guardados en un archivo de texto
denominado “Afil.txt” que se encuentra ubicado dentro del directorio Recursos del disco C:,
teniendo en cuenta la siguiente estructura:
• Apellido y Nombre del Docente (String de 30 caracteres, separados por espacio en
blanco)
• Numero de afiliado (entero largo)
• Título profesional del docente(String de 15 caracteres)
• Edad (entero sin signo)
• Cantidad de cargos que ocupa (Entero sin signo)
• Cantidad de horas cátedra que dicta todas las escuela (entero sin signo)
• Antigüedad docente (entero sin signo)
• Sueldo (Real)
Nota: El campo de sueldo se encuentra inicialmente vacío.
a) Leer el archivo de texto y asignarlo a un arreglo de estructuras en forma dinámica en la
memoria, teniendo en cuenta que se pueden agregar nuevos docentes. Se debe dejar a
criterio del operario si se integran nuevos docentes en la lista. En ese caso es necesario
actualizar el archivo original inmediatamente.
b) Completar el sueldo que cobra cada docente, teniendo en cuenta si el docente cobra por
cargo o por horas cátedras. En caso de que cobre por cargo se debe partir que el sueldo
básico es 1250$, a ello se le debe agregar 1300$ en adicionales por suma fija más un
15% respecto del básico, por cada 5 años de antigüedad que tenga. Un docente con 2 o
más cargos solo se le agrega una vez la antigüedad y las sumas fijas. En caso de que
tenga horas cátedras se le debe computar un básico de 120$, más 40$ por cada hora
que dicta, incluyendo un 15% más por antigüedad con respecto al total de horas.
Pueden existir docentes con cargos y horas cátedras.
c) Generar los respectivos archivos binarios que agrupan los docentes por cada título
profesional que posee, donde cada archivo debe tener como nombre las primeras 8
letras del título, más la extensión “. bnn”. En dicho archivo se deberá colocar: Apellido y
Nombre, número de afiliado, antigüedad, y sueldo. Se recomienda ordenar por título
antes de realizar esta función.
d) Generar un archivo binario de aquellos docentes que estén a punto de jubilarse. Se debe
tener en cuenta que la antigüedad llegue o supere los 30 años y sea mayor de 60 años.
Se exige el Apellido y Nombre, el número de Afiliado, la cantidad de Cargos, la
cantidad total de horas cátedra. Al final del archivo guardar la cantidad total de docentes
en esa condición.
e) Se dispone de un archivo binario denominado “Listado.txt”, que contiene los números de
afiliado y (separado por un tabulador: \t) el monto total en sueldos atrasados que el
42
estado le adeuda a cada afiliado. Leer el archivo binario y generar un único string con los
apellidos separados por un guión (-) y un espacio en blanco de todos los docentes
afiliados en esa lista. Mostrar el nuevo string en el main().
PROBLEMA 26:
Los datos relevantes de un grupo de alumnos de la Facultad de Ingeniería son:
• Nombre (Cadena de caracteres)
• Registro (Entero)
• Código de especialidad (Carácter)
• Cantidad de exámenes rendidos (Entero)
• Notas de los exámenes (un conjunto de hasta 60 notas posibles).
• Promedio de los exámenes (Real, sin incluir los aplazos. Este miembro no debe ser
ingresado, debe ser calculado por el programa).
Se pide escribir un programa en C que sea capaz de leer estos datos de todos los alumnos
desde un archivo de texto cuyo nombre se debe ingresar por teclado. El archivo tiene
extensión “.txt” y está ubicado en la unidad E:\ del disco duro. Hacer la lectura de datos al
menos en una función.
Se pide:
a) Listar todos los alumnos que no tienen ningún examen reprobado, ordenados por código
de especialidad y registro. Utilizar dos funciones.
b) Se debe ingresar por teclado el código de una especialidad. Con estos valores crear un
nuevo arreglo de estructuras de otro tipo con los datos correspondientes a Nombre,
Número de Registro y Promedio formado por todos los datos de todos los alumnos que
pertenezcan a la especialidad ingresada. Usar asignación dinámica de memoria.
Utilizar como mínimo una función.
c) Listar todos los datos correspondientes a los alumnos del arreglo creado, cuyo promedio
sea superior a 6 (seis). Hacer en una función.
d) Calcular y mostrar el promedio de notas correspondiente a cada especialidad. Indicar
cuál es la especialidad que posee mayor promedio y mostrar su valor. Hacer en una
función.
e) Generar un archivo binario de nombre “Mejores.bin” que contenga el Nombre, registro,
especialidad y promedio de notas de los mejores alumnos de cada especialidad. Hacer
en una función.
Nota: No usar variables globales
PROBLEMA 27:
Un instituto de capacitación recibe inscripciones para sus cursos de verano. Para cada
inscripto se disponen de los siguientes datos.
• Apellido y nombre
• Edad
• Cantidad de cursos que va a tomar
• Código de cada uno de los cursos en los que se inscribió (arreglo de enteros máximo 5
elementos)
• Turno elegido para todos los cursos. (M
Mañana ó T
Tarde).
• Monto a pagar (este campo no está en el archivo, pero debe ser incluido en la
estructura)
Los cursos están codificados con enteros de la siguiente manera:
0 Matemática
1 Física
2 Química
3 Computación
4 Redes
43
5 Sistemas Contables.
Implementar un programa en lenguaje C que realice las siguientes tareas utilizando
funciones. Los datos de los inscriptos se encuentran almacenados en un archivo de texto
"Inscrip.txt", estos datos deberán transferirse a memoria utilizando asignación dinámica y
previendo que se pueden agregar unos cincuenta alumnos más a los ya inscriptos.
Mediante un menú de opciones se deben realizar los siguientes ítems:
a) Permitir la inscripción de un alumno en un curso. Puede pasar que el alumno sea nuevo,
o bien que el alumno ya esté inscripto en algún curso y quiera hacerlo en otro, para esto
se le debe requerir al operador la información que sea necesaria según el caso. Se debe
tener en cuenta de que un alumno no podrá inscribirse dos veces en el mismo curso, y
que para los cursos de Matemática y Física no admiten más de 30 alumnos por turno y
que la cantidad total de alumnos no supere lo previsto en la reserva de memoria.
b) (*) Permitir eliminar la inscripción de un alumno a un curso. En el caso que el alumno no
esté inscripto en ningún curso, se lo debe borrar del arreglo de estructuras.
c) Calcular y almacenar el monto a pagar de cada uno de los alumnos teniendo en cuenta
que los cursos de Química y Matemática cuestan $190 c/u, y el resto $240 c/u.
d) Ingresar por teclado un turno y generar un archivo binario que contenga los datos de los
inscriptos en ese turno ordenado alfabéticamente por Apellido y nombre, escribiendo:
Apellido y nombre, cantidad de cursos y el nombre completo de cada uno de los cursos
en los que se inscribieron. El nombre del archivo estará formado por una primera letra
que corresponde al turno ingresado, seguido del año que deberá ser leído también por
teclado y con la extensión ".dat". Utilice todas las funciones que crea necesarias.
e) Calcular cual es el curso que tiene más inscriptos indicando el nombre del curso
correspondiente.
PROBLEMA 28:
Una entidad financiera que administra y gerencia una tarjeta de crédito, al final del día,
guarda en un archivo de texto toda la información de las compras realizadas por sus clientes
durante el día que transcurrió. Los datos por cada compra realizada son los siguientes:
DNI del usuario (entero largo)
Apellido y Nombre del Usuario (alfanumérico)
Código del comercio donde realizó la compra (entero)
Hora de la compra (entero largo en la forma hhmmss)
Cantidad de tipos de productos comprados (entero de 1 a 10)
Cantidades de cada uno de los productos comprados (conjunto de enteros)
Precio unitario de cada tipo de los productos comprados (conjunto de reales).
El archivo se denomina “CreditMMDD.txt”, donde MMDD corresponde al mes y día del
corriente año, los cuales deberán en forma separada ingresarse por teclado y validarse
sus valores antes de usarlos. Se pide diseñar un programa en lenguaje C que realice las
siguientes tareas.
a) Leer el contenido del archivo de texto y almacenarlo en un arreglo dinámico de
estructuras. Tenga en cuenta que deberá agregar a la estructura arriba descripta un
campo destinado a almacenar el monto total de la compra para cada usuario.
b) Calcular el importe total de cada compra, completando el campo correspondiente en la
estructura de datos.
c) Se debe calcular y mostrar el monto total que deberá abonar la empresa a cada uno de
los comercios en los que se realizaron las operaciones de compra (tener en cuenta que
en un mismo comercio pueden haber comprado más de un usuario). Además, esta
misma información debe ser almacenada en un archivo de texto de nombre “pagos.txt”,
donde se especifique el código de cada comercio y el monto a pagar, de manera que
cada línea en este archivo de texto tenga la forma:
[codigo de comercio] [monto a pagar]
44
d) Listar por pantalla los códigos de los comercios en los que se realizó por lo menos una
compra en un intervalo de tiempo de media hora en más o en menos respecto de una
hora y minutos ingresados por teclado.
e) Se dispone de un archivo binario llamado “limite.dtt”, el cual contiene los DNI de todos
los usuarios y su importe límite de crédito disponible hasta el momento. Este archivo
debe ser actualizado con aquellos usuarios que hicieron uso de la tarjeta durante el día,
descontando de dicho límite el monto gastado. En caso de haber un exceso de compra
sobre el importe límite, este tomará un valor negativo, en ese caso se deberá mostrar
por pantalla el nombre y DNI de los usuarios que tienen excedido el límite de compra.
45