Descomposición funcional. Parte. Programación Estructurada. M.Sc. Ana María Salgado G.

Descomposición funcional. Parte II Programación Estructurada 2013 M.Sc. Ana María Salgado G.

Más sobre funciones Todo programa C está formado además de por la función main, que es el punto de entrada y de salida del programa, por otras funciones, las cuales se comunican entre sí pasándose argumentos siempre que sean requeridos. Vamos a centrarnos en cuestiones más específicas como pasar argumentos a funciones que sean, matrices, estructuras y punteros, o bien devolver estos tipos de datos. Pasar una matriz como argumento a una función En C todos los arrays se pasan por referencia(dirección). Cuando se llama a una función y se utiliza un array como parámetro, se debe tener cuidado de no modificar los arrays en una función llamada. C trata automáticamente la llamada a la función como si hubiera situado el operador de dirección & delante del nombre del array. #include <stdio.h> #include <string.h> void cambiar(char c[4]); int main() char palabra[4] = "ABC"; cambiar(palabra); puts(palabra); return 0; void cambiar(char c[4]) puts(c); strcpy(c,"ama"); Cuando se pasa un array a una función, se pasa realmente sólo la dirección de la celda de memoria donde comienza el array. Este valor se representa por el nombre del array. La función puede cambiar entonces el contenido del array accediendo directamente a las celdas de memoria en donde se almacenan los elementos del array. Los elementos del array se pueden cambiar como si se pasara por referencia. Cuando pasamos un array a una función lo que se escribe como argumento en la llamada a esa función es el nombre del array, es decir, el argumento que se pasa es la dirección del array, por lo que el parámetro formal correspondiente tiene que ser también un array, el cual, después de la llamada, queda inicializado con esa dirección. M.Sc. Ana María Salgado G. Página 2

Los arrays son siempre pasados por referencia, porque no se pasa una copia de todos sus elementos. Tanto la función que invoca, como la función invocada trabajan sobre el mismo espacio de memoria(sobre el mismo array). #include <stdio.h> #define L 10 void leerarray(double a[], int *); void imprimirarray(const double [], int); int main() double a[l]; int n; leerarray(a, &n); printf("\nel array a tiene %d elementos, estos son\n",n); imprimirarray(a,n); return 0; void leerarray(double a[], int *num) int n ; puts("introduzca datos. Para terminar pulsar 0.\n"); for(n = 0; n < L; n++) printf("%d: ",n); scanf("%lf",&a[n]); if(a[n] == 0) break; *num = n; void imprimirarray(const double a[], int n) int i; for(i = 0; i<n; i++) printf("\t%d: %g\n",i,a[i]); M.Sc. Ana María Salgado G. Página 3

Cuando se declara un array unidimensional como parámetro de una función, no se requiere que se especifique su dimensión(no se hace una reserva de memoria para una copia total del array), ya que lo que se pasa es la dirección del array. int leer(tficha bibli[ ], int NMAX); Precauciones Cuando se utiliza una variable array como argumento, la función receptora puede no conocer cuántos elementos existen en el array. Sin su conocimiento una función no puede utilizar el array. Aunque la variable array puede apuntar al comienzo de él, no proporciona ninguna indicación de dónde termina el arreglo. La función SumaDeEnteros() suma los valores de todos los elementos de un array y devuelve el total. int SumaDeEnteros(int *ArrayEnteros) int main() int lista[5] = 10, 11, 12, 13, 14; SumaDeEnteros(lista); Aunque SumaDeEnteros() conoce dónde comienza el array, no conoce cuántos elementos hay en el array, en consecuencia, no sabe cuántos elementos hay que sumar. Se pueden utilizar dos métodos alternativos para permitir que una función conozca el número de argumentos asociados con un array que se pasa como argumento de una función: Situar un valor de señal al final del array, que indique a la función que se ha de detener el proceso en ese momento. Pasar un segundo argumento que indica el número de elementos del array. Todas las cadenas utilizan el primer método ya que terminan en nulo. Una segunda alternativa es pasar el número de elementos del array siempre que se pasa el array como un argumento. El array y el número de elementos se convierten entonces en una pareja de argumentos que se asocian con la función llamada. La función SumaDeEnteros(), por ejemplo, se puede actualizar así: int SumaDeEnteros(int ArrayEnteros[], int noelementos) M.Sc. Ana María Salgado G. Página 4

El segundo argumento, noelementos, es un valor entero que indica a la función int SumaDeEnteros() cuántos elementos se procesarán en el array ArrayEnteros. Este método suele ser el utilizado para arrays de elementos que no son caracteres. Ejemplo: /********************** Programa Alumnos **********************/ // Versión con punteros #include <stdio.h> #include <stdlib.h> #include <ctype.h> #include <string.h> #define N 100 /* número máximo de alumnos */ typedef struct char matricula[10]; char apellidos[30]; char nombre[20]; char direccion[30]; ficha; int leer(ficha *, const int); void buscar(ficha *, char *, int, int); int menu(void); void main( ) static ficha lista[n]; char dato[30]; /* dato a buscar */ int opcion; /* opción elegida en el menú */ int n = 0; /* número de alumnos leídos */ while (1) /* bucle infinito. Se sale con break. */ opcion = menu( ); if (opcion!= 4) switch (opcion) case 1: /* entrada de los datos de los alumnos */ n = leer(lista, N); break; case 2: /* búsqueda por el número de matrícula */ system("cls"); printf("número de matrícula "); gets(dato); buscar(lista, dato, n, opcion); break; M.Sc. Ana María Salgado G. Página 5

case 3: /* Búsqueda por los apellidos */ system("cls"); printf("apellidos... "); gets(dato); buscar(lista, dato, n, opcion); break; else break; /**************************************************************** Función para visualizar el menú ****************************************************************/ int menu(void) int op; do system("cls"); printf("\n\t1. Entrada de datos de alumnos\n"); printf("\n\t2. Busqueda por nro. de matricula\n"); printf("\n\t3. Busqueda por apellidos\n"); printf("\n\t4. Fin\n"); printf("\n\nteclee la opcion deseada: "); scanf("%d", &op); fflush(stdin); while (op < 1 op > 4); return (op); /**************************************************************** Función para leer los datos correspondientes a un alumno ****************************************************************/ int leer(ficha *lista, const int NMAX) int n = 0; char resp = 's'; M.Sc. Ana María Salgado G. Página 6

while (tolower(resp) == 's' && n < NMAX) do system("cls"); printf("alumno numero %d\n\n", n+1); printf("numero de matrícula: "); gets(lista[n].matricula); printf("apellidos... "); gets(lista[n].apellidos); printf("nombre... "); gets(lista[n].nombre); printf("dirección... "); gets(lista[n].direccion); printf("\n\n Datos correctos? s/n "); fflush(stdin); resp = getchar(); while (tolower(resp)!= 's'); n++; printf("\n\n Más datos a introducir? s/n "); resp = getchar(); fflush(stdin); return (n); /**************************************************************** Función para buscar si existe o no un dato ****************************************************************/ void buscar(ficha *lista, char *x, int alumnos, int opcion) const int NO = 0; const int SI = 1; int existe = NO, i = 0; char resp; switch(opcion) case 2: /* búsqueda por número de matrícula */ while (!existe && i < alumnos) if (strcmp(lista[i++].matricula, x) == 0) existe = SI; break; case 3: /* Búsqueda por apellidos */ while (!existe && i < alumnos) if (strcmp(lista[i++].apellidos, x) == 0) existe = SI; break; M.Sc. Ana María Salgado G. Página 7

if (existe) printf("\n%s\n%s %s\n%s\n", lista[i-1].matricula, lista[i-1].apellidos, lista[i- 1].nombre, lista[i-1].direccion); else printf("\n%s no existe", x); printf("\n\npulse <Entrar> para continuar "); resp = getchar( ); fflush(stdin); Si el array es multidimensional, no es necesario especificar la primera dimensión, pero sí las restantes. void CopiarArray(float destino[ ][COLS], float origen[ ][COLS]); El nombre de un array y un puntero no son lo mismo, pero en lugar del nombre de una array unidimensional, podemos usar un puntero que almacene la dirección de comienzo del array para acceder a los elementos del mismo. El identificador de un array y un puntero no son lo mismo, lo que imposibilita en el caso de arrays de dos dimensiones utilizar en lugar del nombre del array, un puntero a un puntero que almacene la dirección de comienzo del array para acceder a los elementos del mismo. /************** Fusionar dos listas clasificadas **************/ /* Versión con punteros */ #include <stdio.h> #include <stdlib.h> #include <string.h> #define NML 120 /* número máximo de líneas */ #define CPL 60 /* caracteres por línea */ int fusionar(char **, int, char **, int, char **, const int); void Error(void); void main( ) /* Inicializamos las listas a clasificar con el fin de no tener * que leer los datos y realizar así una prueba rápida. */ static char *listaactual[ ] = "Ana", "Carmen", "David", "Francisco", "Javier", "Jesús", "José", "Josefina", "Luís", "María", "Patricia", "Sonia" ; M.Sc. Ana María Salgado G. Página 8

static char *listanueva[ ] = "Agustín", "Belén", "Daniel", "Fernando", "Manuel", "Pedro", "Rosa", "Susana" ; /* Calcular el número de elementos de los arrays anteriores */ const int dima = sizeof(listaactual)/sizeof(listaactual[0]); const int dimn = sizeof(listanueva)/sizeof(listanueva[0]); /* Definir el array resultante de fusionar los anteriores */ static char **listafinal; // referencia el array resultante int ind, r; /* Asignar memoria para el array de punteros listafinal */ listafinal = (char **)malloc((dima+dimn) * sizeof(char *)); if (listafinal = = NULL) Error( ); /* Inicializa el array de punteros. Esto evita problemas al liberar memoria, en el supuesto de un error por falta de memoria */ for (ind = 0; ind < dima+dimn; ind++) listafinal[ind] = NULL; /* Fusionar listaactual y listanueva y almacenar en resultado en * listafinal. La función "fusionar" devuelve un 0 si no se * pudo realizar la fusión. */ r = fusionar(listaactual, dima, listanueva, dimn, listafinal, NML); /* Escribir el array resultante */ if (r) for (ind = 0; ind < dima+dimn; ind++) printf("%s\n", listafinal[ind]); else Error( ); /* Liberar la memoria ocupada por el array listafinal */ for (ind = 0; ind < dima+dimn; ind++) free(listafinal[ind]); free(listafinal); M.Sc. Ana María Salgado G. Página 9

/**************************************************************** F U S I O N A R ****************************************************************/ int fusionar(char **listaa, int dima, char **listan, int dimn, char **listaf, const int nml) int ind = 0, inda = 0, indn = 0, indf = 0; while (inda < dima && indn < dimn) if (strcmp(listaa[inda], listan[indn]) < 0) listaf[indf] = (char *)malloc(strlen(listaa[inda]) + 1); if (listaf[indf] = = NULL) return 0; strcpy(listaf[indf++], listaa[inda++]); else listaf[indf] = (char *)malloc(strlen(listan[indn]) + 1); if (listaf[indf] = = NULL) return 0; strcpy(listaf[indf++], listan[indn++]); /* Los dos lazos siguientes son para prever el caso de que, * lógicamente una lista finalizará antes que la otra. */ for (ind = inda; ind < dima; ind++) listaf[indf] = (char *)malloc(strlen(listaa[inda]) + 1); if (listaf[indf] = = NULL) return 0; strcpy(listaf[indf++], listaa[ind]); for (ind = indn; ind < dimn; ind++) listaf[indf] = (char *)malloc(strlen(listan[indn]) + 1); if (listaf[indf] = = NULL) return 0; strcpy(listaf[indf++], listan[ind]); return(1); void Error(void) puts("longitud no válida de la lista resultante"); exit(1); M.Sc. Ana María Salgado G. Página 10

Pasar una estructura a una función Una estructura puede ser pasada a una función por valor o por referencia. Cuando pasamos una estructura por valor, el parámetro actual que representa la estructura se copia en el correspondiente parámetro formal, produciéndose un duplicado. Si alguno de los miembros del parámetro formal se modifica, los cambios no afectan al parámetro actual correspondiente. Si pasamos la estructura por referencia, lo que recibe la función es el lugar de la memoria donde se localiza dicha estructura. /**************** Operaciones con complejos ****************/ #include <stdio.h> typedef struct float real; float imag; tcomplejo; void SumarComplejos(tcomplejo c1, tcomplejo c2, tcomplejo *p); void main( ) tcomplejo ca, cb, cc; printf("\nintroducir datos de la forma: x yi\n"); printf("ca = "); scanf("%f %f", &ca.real,&ca.imag); fflush(stdin); printf("cb = "); scanf("%f %f", &cb.real,&cb.imag); fflush(stdin); SumarComplejos(ca, cb, &cc); printf("resultado: %g%+gi\n", cc.real, cc.imag); void SumarComplejos(tcomplejo c1, tcomplejo c2, tcomplejo *p) p->real = c1.real + c2.real; p->imag = c1.imag + c2.imag; M.Sc. Ana María Salgado G. Página 11

Función que retorna un puntero Cuando una función retorna un puntero a un objeto, el objeto debe persistir después de finalizar la función. /**************** Operaciones con complejos ****************/ #include <stdio.h> #include <stdlib.h> typedef struct float real; float imag; tcomplejo; tcomplejo *SumarComplejos(tcomplejo c1, tcomplejo c2); void main( ) tcomplejo ca, cb, *pcr; printf("\nintroducir datos de la forma: x yi\n"); printf("ca = "); scanf("%f %f", &ca.real,&ca.imag); fflush(stdin); printf("cb = "); scanf("%f %f", &cb.real,&cb.imag); fflush(stdin); pcr = SumarComplejos(ca, cb); printf("resultado: %g%+gi\n", pcr->real, pcr->imag); tcomplejo *SumarComplejos(tcomplejo c1, tcomplejo c2) tcomplejo cx; cx.real = c1.real + c2.real; cx.imag = c1.imag + c2.imag; return &cx; El programa anterior presenta resultados inesperados. La función SumarComplejos, utiliza un complejo local cx del cual retorna su dirección. Cuando la función finalice el complejo cx se destruirá automáticamente, con lo que el puntero pcr que apunta al resultado, estará apuntando a un objeto inexistente. M.Sc. Ana María Salgado G. Página 12

La solución radica en hacer que la función SumarComplejos cree un objeto que persista a lo largo de la ejecución del programa, asignando memoria dinámicamente para el objeto. /**************** Operaciones con complejos ****************/ #include <stdio.h> #include <stdlib.h> typedef struct float real; float imag; tcomplejo; tcomplejo *SumarComplejos(tcomplejo c1, tcomplejo c2); void main( ) tcomplejo ca, cb, *pcr; printf("\nintroducir datos de la forma: x yi\n"); printf("ca = "); scanf("%f %f", &ca.real,&ca.imag); fflush(stdin); printf("cb = "); scanf("%f %f", &cb.real,&cb.imag); fflush(stdin); pcr = SumarComplejos(ca, cb); printf("resultado: %g%+gi\n", pcr->real, pcr->imag); /* Liberar la memoria asignada */ free(pcr); tcomplejo *SumarComplejos(tcomplejo c1, tcomplejo c2) tcomplejo *pcx; /* Asignar memoria para el complejo suma */ pcx = (tcomplejo *)malloc(sizeof(tcomplejo)); if ( pcx = = NULL ) printf("memoria insuficiente\n"); exit(-1); pcx->real = c1.real + c2.real; pcx->imag = c1.imag + c2.imag; return pcx; M.Sc. Ana María Salgado G. Página 13

Funciones recursivas Una función recursiva es aquella que se llama a sí misma. El compilador C permite cualquier número de llamadas recursivas a una función. Cada vez que la función es llamada, los parámetros formales son inicializados. Se utiliza una función recursiva, cuando el proceso a programar es por definición recursivo. Por ejemplo, el cálculo del factorial de un número por definición es un proceso recursivo. n! = n(n-1)! /************* Cálculo del factorial de un número *************/ #include <stdio.h> unsigned long factorial(int n); void main( ) int numero; unsigned long fac; do printf(" Número? "); scanf("%d", &numero); while (numero < 0 numero > 12); fac = factorial(numero); printf("\nel factorial de %d es %ld\n", numero, fac); unsigned long factorial(int n) if (n == 0) return 1; else return n*factorial(n-1); Para n = 4, el proceso seguido por la función es: Nivel de recursión Proceso de ida Proceso de vuelta 0 factorial(4) 24 1 4 * factorial(3) 4 * 6 2 3 * factorial(2) 3 * 2 3 2 * factorial(1) 2 * 1 4 1 * factorial(0) 1 * 1 factorial(0) 1 M.Sc. Ana María Salgado G. Página 14

El uso de la recursión debe evitarse cuando haya una solución obvia por iteración. La llamada a una función recursiva consume mucho espacio de pila debido a que por cada llamada las variables que intervienen en la función son salvadas en la pila para posteriormente poder iniciar la vuelta. Funciones predefinidas en c Funciones matemáticas: Las declaraciones para estas funciones están en el fichero math.h Los argumentos y el resultado son de tipo double. En muchos casos utilizaremos conversión cast para convertir explícitamente los argumentos al tipo deseado. Ejemplo: a = tan((double)valor); Las funciones matemáticas se clasifican en: Funciones trigonométricas Funciones hiperbólicas. Funciones exponencial y logarítimica. Funciones varias. cos: La función cos da como resultado el coseno de x ( x en radianes). #include <math.h> double cos(double x); sin: La función sin da como resultado el seno de x ( x en radianes). #include <math.h> double sin(double x); tan: La función tan da como resultado la tangente de x ( x en radianes). #include <math.h> double tan(double x); cosh: La función cosh da como resultado el coseno hiperbólico de x ( x en radianes). #include <math.h> double cosh(double x); sinh: La función sinh da como resultado el seno hiperbólico de x ( x en radianes). #include <math.h> double sinh(double x); tanh: La función tanh da como resultado la tangente hiperbólica de x ( x en radianes). #include <math.h> double tanh(double x); exp Da como resultado el valor de e x ( e = 2.718282) #include <math.h> double exp(double x); M.Sc. Ana María Salgado G. Página 15

log Da como resultado el logaritmo natural de x. #include <math.h> double log(double x); log10 Da como resultado el logaritmo en base 10 de x. #include <math.h> double log10(double x); ceil Resultado: un valor double, que representa el entero más pequeño que es mayor o igual que x. #include <math.h> double ceil(double x); double x = 2.8, y = -2.8; printf( %g %g\n,ceil(x),ceil(y)); fabs Calcula el valor absoluto de x( siendo x un valor real en doble precisión). Las funciones abs y labs calculan el valor absoluto de un int y un long respectivamente. #include <math.h> double fabs(double x); floor Resultado: un valor double, que representa el entero más grande que es menor o igual que x. double floor(double x); double x = 2.8, y = -2.8; printf( %g %g\n,floor(x),floor(y)); pow Resultado: x y. Si x es 0 e y es negativo o si x e y son 0 o si x es negativo e y no es entero, se obtiene un error(argumento fuera del dominio da la función). Si x y da un resultado superior al valor límite para el tipo double, el resultado es el valor límite(1.79769e+308) double pow(double x); double x = 2.8, y = -2.8; printf( %g\n,pow(x,y)); sqrt Calcula la raíz cuadrada de x. Si x es negativo, ocurre un error(argumento fuera del dominio de la función). #include <math.h> double sqrt(double x); M.Sc. Ana María Salgado G. Página 16

Números seudoaleatorios rand Da como resultado un número seudoaleatorio entero, entre 0 y el valor máximo para un int. #include <stdlib.h> int rand(void); Funciones de fecha y hora time Resultado: el número de segundos transcurridos desde las 0 horas del 1 de Enero de 1970. #include <time.h> time_t time(time_t *seg); ctime Convierte un tiempo almacenado como un valor de tipo time_t, en una cadena de caracteres de la forma: Thu Jul 08 12:01:29 2010 #include <time.h> char *ctime(const time_t *seg); Devuelve un puntero a la cadena de caracteres resultante o un puntero nulo si seg representa un dato anterior al 1 de Enero de 1970. #include <stdio.h> #include <time.h> main( ) time_t segundos; printf("el numero de segundos transcurridos desde el 01/01/1970 es %ld\n",time(&segundos)); printf("la fecha actual es %s",ctime(&segundos)); El tipo time_t está definido así: typedef long time_t; Funciones para manipular bloques de memoria memset Permite iniciar un bloque de memoria. #include <string.h> void *memset(void *destino, int b, size_t nbytes); destino: dirección del bloque de memoria que se desea inicializar. b: valor empleado para iniciar cada byte del bloque. nbytes: número de bytes del bloque que se iniciará. M.Sc. Ana María Salgado G. Página 17

double a[10][10]; memset(a, 0, sizeof(a)); memcpy Copia un bloque de memoria en otro. #include <string.h> void *memcpy(void *destino, const void *origen, size_t nbytes); destino: es la dirección del bloque de memoria destino de los datos. origen: es la dirección del bloque de memoria origen de los datos. nbytes: número de bytes que se copiarán desde el origen al destino. double a[10][10], b[10][10]; memcpy(b, a, sizeof(a)); memcmp Compara byte a byte dos bloques de memoria. #include <string.h> int memcmp(void *bm1, const void *bm2, size_t nbytes); bm1, bm2: son las direcciones de los bloques de memoria a comparar. nbytes: número de bytes que se compararán. double a[10][10], b[10][10]; if(memcmp(a, b, sizeof(a)) == 0) printf( Las matrices contienen los mismos datos\n ); else printf( Las matrices no contienen los mismos datos\n ); Ejercicios resueltos 1. Realice un programa que utilice la siguiente función: struct fraccion *MultiplicarFracciones(struct fraccion f1, struct fraccion f2); Haga uso de la siguiente estructura: struct fraccion int numerador; int denominador; ; M.Sc. Ana María Salgado G. Página 18

/**************** Operaciones con fracciones ****************/ /* fraccion.c */ #include <stdio.h> #include <stdlib.h> struct fraccion int numerador; int denominador; ; struct fraccion *MultiplicarFracciones(struct fraccion f1, struct fraccion f2); void main() struct fraccion f1, f2, *fr; printf("fraccion # 1: \n"); printf("numerador = "); scanf("%d",&f1.numerador); fflush(stdin); printf("denominador = "); scanf("%d",&f1.denominador); fflush(stdin); printf("\nfraccion # 2: \n"); printf("numerador = "); scanf("%d",&f2.numerador); fflush(stdin); printf("denominador = "); scanf("%d",&f2.denominador); fflush(stdin); fr = MultiplicarFracciones(f1,f2); printf("resultado: %d/%d\n", fr->numerador, fr->denominador); /* Liberar la memoria asignada */ free(fr); M.Sc. Ana María Salgado G. Página 19

struct fraccion *MultiplicarFracciones(struct fraccion f1, struct fraccion f2) struct fraccion *producto; /* Asignar memoria para el racional producto */ producto = (struct fraccion *)malloc(sizeof(struct fraccion)); if ( producto == NULL ) printf("memoria insuficiente\n"); exit(-1); producto->numerador = f1.numerador * f2.numerador; producto->denominador = f1.denominador * f2.denominador; return producto; 2. Dado un array constituido de números enteros que contiene N elementos, siendo N >=1, realice una función recursiva que calcule la suma de todos los elementos del array. //recur2.c #include <stdio.h> void main( ) int numeros[25]; int N, i; printf("cuantos numeros tiene el arreglo? \n"); scanf("%d",&n); printf("introduzca el arreglo: "); for(i = 0; i < N; i++) scanf("%d",&numeros[i]); printf("%d \n", sumarray(numeros,0,n)); int sumarray(int numeros[ ], int posicion, int N) if(posicion == N - 1) return numeros[posicion]; else return(numeros[posicion] + sumarray(numeros, posicion + 1, N)); M.Sc. Ana María Salgado G. Página 20

3. El calendario Gregoriano actual obedece a la reforma del calendario juliano que ordenó el Papa Gregorio XIII en 1582. Se decidió, después de algunas modificaciones, que en los sucesivo fuesen bisiestos todos los años múltiplos de 4, pero que de los años seculares(los acabados en dos ceros) sólo fuesen bisiestos aquellos que fuesen múltiplos de 400. Construir un programa para que dada una fecha(día, mes y año) devuelva como resultado el día correspondiente de la semana. /********************************************************* CALENDARIO PERPETUO *********************************************************/ /* Dada una fecha (dia, mes, año) * indicar el día correspondiente de la semana. */ #include <stdio.h> #include <stdlib.h> void LeerFecha (int *dia, int *mes, int *anyo); void EntradaDatos(int *dia, int *mes, int *anyo); int DatosValidos(int dia, int mes, int anyo); int AnyoBisiesto(int anyo); void EscribirFecha( int dd, int mm, int aa); int DiaSemana(int dia, int mes, int anyo); void main(void) /* Función Principal */ int dia, mes, anyo; LeerFecha(&dia, &mes, &anyo); EscribirFecha(dia, mes, anyo); /********************************************************* FUNCIONES *********************************************************/ void LeerFecha(int *dia, int *mes, int *anyo) int datos_validos; do EntradaDatos(dia, mes, anyo); datos_validos = DatosValidos(*dia, *mes, *anyo); while (!datos_validos); M.Sc. Ana María Salgado G. Página 21

void EntradaDatos(int *dia, int *mes, int *anyo) printf("día (1-31) "); scanf("%d", dia); printf("mes (1-12) "); scanf("%d", mes); printf("año (1582 -->) "); scanf("%d", anyo); int DatosValidos(int dia, int mes, int anyo) int r, anyob, mesb, diab; anyob = (anyo >= 1582); mesb = (mes >= 1) && (mes <= 12); switch (mes) case 2: if (r = AnyoBisiesto(anyo)) diab = (dia >= 1) && (dia <= 29); else diab = (dia >= 1) && (dia <= 28); break; case 4: case 6: case 9: case 11: diab = (dia >= 1) && (dia <= 30); break; default: diab = (dia >= 1) && (dia <= 31); if (!(diab && mesb && anyob)) printf("\ndatos NO VALIDOS\n\n"); printf("pulse <Entrar> para continuar "); r = getchar( ); fflush(stdin); return (0); else return (1); int AnyoBisiesto(int anyo) int verdad = 1, falso = 0; if ((anyo % 4 == 0) && (anyo % 100!= 0) (anyo % 400 == 0)) return (verdad); else return (falso); M.Sc. Ana María Salgado G. Página 22

void EscribirFecha(int dd, int mm, int aa) int d; static char dia[7][10] = "Sábado", "Domingo", "Lunes", "Martes", "Miércoles", "Jueves", "Viernes" ; static char mes[12][11] = "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre" ; d = DiaSemana(dd, mm, aa); printf("\n%s %d de %s de %d\n",dia[d], dd, mes[mm-1], aa); int DiaSemana(int dia, int mes, int anyo) if (mes <= 2) mes = mes + 12; anyo = anyo - 1; return ((dia+2*mes+3*(mes+1)/5+anyo+anyo/4-anyo/100+anyo/400+2)%7); 4. El siguiente ejercicio, lee dos tablas de enteros, calcula la suma de los elementos correspondientes, e imprime la nueva tabla que contiene esta suma. #include <stdio.h> #define MAXFIL 20 #define MAXCOL 30 /*Calcular la suma de los elementos de dos tablas de enteros */ main( ) int nfilas, ncols; static int a[maxfil][maxcol], b[maxfil][maxcol],c[maxfil][maxcol]; /* prototipos de funcion */ void leerentrada(int a[ ][MAXCOL], int nfilas, int ncols); void calcularsuma(int a[ ][MAXCOL], int b[ ][MAXCOL], int c[ ][MAXCOL], int nfilas, int ncols); void sacarsalida(int c[ ][MAXCOL], int nfilas, int ncols); M.Sc. Ana María Salgado G. Página 23

printf("cuantas filas?"); scanf("%d",&nfilas); printf("cuantas columnas?"); scanf("%d",&ncols); printf("\n\nprimera tabla: \n"); leerentrada(a,nfilas,ncols); printf("\n\nsegunda tabla: \n"); leerentrada(b,nfilas,ncols); calcularsuma(a,b,c,nfilas,ncols); printf("\n\nsumas de los elementos: \n\n"); sacarsalida(c,nfilas,ncols); void leerentrada(int a[ ][MAXCOL], int m, int n) int fila,col; for(fila = 0; fila < m ; ++fila) printf("\nintroducir datos para la fila no. %2d \n",fila+1); for(col = 0; col < n; col++) scanf("%d",&a[fila][col]); return; void calcularsuma(int a[ ][MAXCOL], int b[ ][MAXCOL], int c[ ][MAXCOL], int m, int n) int fila,col; for(fila = 0; fila < m ; ++fila) for(col = 0; col < n; col++) c[fila][col] = a[fila][col] + b[fila][col]; return; void sacarsalida(int a[ ][MAXCOL], int m, int n) int fila,col; for(fila = 0; fila < m ; ++fila) for(col = 0; col < n; col++) printf("%d\t",a[fila][col]); printf("\n"); M.Sc. Ana María Salgado G. Página 24

return; 5. El cálculo de los números de Fibonacci es un ejemplo de una definición matemática recursiva que se enuncia así: el número de Fibonacci f(i), siendo i el número de orden(0, 1, 2, 3, 4, 5,...) del número a calcular, es igual al número de Fibonacci f(i 1) más el número de Fibonacci f(i 2), sabiendo que f(0) es 0 y f(1) = 1. f(0) = 0 f(1) = 1 f(2) = f(1) + f(0) f(3) = f(2) + f(1)... f(i) = f(i - 1) + f(i 2) Realizar un programa que pregunte: cuántos números de Fibonacci, a partir del primero, se quieren calcular?, almacene esos números en una matriz del tamaño necesario y finalmente los muestre. Para ello se deberá utilizar una función recursiva con el prototipo indicado a continuación: int fibonacci(int n); La función fibonacci devolverá como resultado el número de Fibonacci cuyo número de orden(0, 1, 2,...) sea n. Una ejecución del programa podría ser: Cuántos números de Fibonacci, a partir del primero, se quieren calcular? n = 10 // fibonacci.c // #include <stdio.h> #include <stdlib.h> int fibonacci(int); int main() int n = 0, i = 0, *f; 0 1 1 2 3 5 8 13 21 34 printf(" Cuántos números de Fibonacci, a partir del "); printf("primero, se quieren calcular?\n"); M.Sc. Ana María Salgado G. Página 25

do printf("n = "); i = scanf("%d", &n); fflush(stdin); while ( i == 0 n < 1); // Crear una matriz dinámicamente f = (int *)malloc(n * sizeof(int)); if (f == NULL) printf("insuficiente memoria\n"); return -1; // Obtener los números de la serie for (i = 0; i < n; i++) f[i] = fibonacci(i); // Visualizar la matriz for (i = 0; i < n; i++) printf("%5d", f[i]); printf("\n"); // Liberar la memoria asignada a la matriz free(f); return 0; int fibonacci(int n) if ( n == 0 ) return 0; else if ( n == 1 ) return 1; else return fibonacci(n-1) + fibonacci(n-2); M.Sc. Ana María Salgado G. Página 26

Ejercicios propuestos 1. Escribir una función que calcule el máximo de los primeros n elementos de un array especificado. Use la siguiente función prototipo: double maximo(const double a[], int n); 2. Realice un programa que introduzca una lista de 10 números enteros y calcule su suma y el valor máximo. Utilice los siguientes prototipos: int SumaDeEnteros(const int ArrayEnteros[], int noelementos); int máximo(const int ArrayEnteros[], int noelementos); 3. Diseñe una función que convierta los caracteres de sus argumentos a mayúsculas. Use el prototipo: void convierte_mayus(char cad[]); Utilice un bucle en la definición de la función, que termine cuando se alcance el fin de cadena(carácter nulo). 4. Haciendo uso de la siguiente estructura: struct info_persona char nombre[20]; char calle[30]; char ciudad[25]; char provincia[25]; char codigopostal[6]; ; Y de los prototipos de funciones: void entrada_pna(struct info_persona *pp); void ver_info(struct info_persona p); Lea e imprima los campos de la estructura haciendo uso de las funciones anteriores. M.Sc. Ana María Salgado G. Página 27

5. Realice la simulación y salida del siguiente programa: #include <stdio.h> void contar(int cima); void main(void) contar(10); return; void contar(int cima) if(cima >1) contar(cima - 1); printf("%d ",cima); 6. Dados dos números a (número entero) y b(número natural mayor o igual que cero). Realice una función recursiva para determinar a^b 7. Realice un programa para reordenar una lista de n enteros en una secuencia de valores algebraicos crecientes. El programa contendrá un array unidimensional de enteros llamado x, en el que se reordenará un elemento cada vez. La reordenación empezará recorriendo todo el array para encontrar el menor de los números, el cual será intercambiado con el primer elemento del array, colocando así el menor elemento en el principio de la lista. El resto de los n - 1 elementos del array se recorrerán para encontrar el menor, que se intercambiará con el segundo número. El resto de los n 2 números se recorrerán buscando el menor, que se intercambia con el tercer número, y así sucesivamente, hasta que el array completo sea reordenado. La función prototipo a utilizar es: void reordenar(int n, int x[ ]); Donde n indica la cantidad de enteros a introducir, y el array x es el arreglo donde se almacenarán dichos números. M.Sc. Ana María Salgado G. Página 28

Una salida típica podría ser: Cuantos números serán introducidos? 6 i = 1 x = 595 i = 2 x = 78 i = 3 x = -1505 i = 4 x = 891 i = 5 x = -29 i = 6 x = -7 Lista de números reordenada: i = 1 x = -1505 i = 2 x = -29 i = 3 x = -7 i = 4 x = 78 i = 5 x = 595 i = 6 x = 891 8. Modificar el ejercicio anterior, de tal forma, que la función prototipo sea: void reordenar(int n, int *x); Utilice un array unidimensional de enteros como parámetro actual en la llamada a dicha función. En otra ejecución, use como parámetro actual un puntero a entero. Qué sucede con cada uno de los cambios? 9. Las torres de Hanoi son un conocido juego de niños, se juega con tres pivotes y un cierto número de discos de distintos tamaños. Los discos tienen un agujero en el centro, con lo que se pueden apilar en cualquiera de los pivotes. Inicialmente, los discos se amontonan en el pivote extremo de la izquierda por tamaño decreciente, es decir, el más grande abajo y el más pequeño arriba, como se ilustra en la figura. 1 2 3 4 Izquierda Centro Derecha M.Sc. Ana María Salgado G. Página 29

El objeto del juego es conseguir llevar los discos del pivote más a la izquierda al de más a la derecha, sin colocar nunca un disco sobre otro más pequeño. Sólo se puede mover un disco cada vez, y cada disco debe encontrarse siempre en uno de los pivotes. La estrategia a seguir es considerar uno de los pivotes como origen, y el otro como destino. El tercer pivote se utilizará para almacenamiento auxiliar, con lo que podemos mover los discos sin poner ninguno sobre otro más pequeño. Supongamos que hay n discos, numerados del más pequeño al más grande. Si los discos se encuentran apilados inicialmente en el pivote izquierdo, el problema de leer los n discos al pivote derecho se puede formular de la siguiente forma recursiva: Mover los n 1 discos superiores del pivote izquierdo al del centro. Mover el n-ésimo disco(el más grande) al pivote de la derecha. Mover los n 1 discos del pivote del centro al de la derecha. Recuerde utilizar recursividad. M.Sc. Ana María Salgado G. Página 30