Descomposicion funcional parte ii 2013 2

Pro

gra

ma

ció

n E

stru

ctu

rad

a

20

13

De

sco

mp

osi

ció

n f

un

cio

na

l. P

art

e

II

M.Sc. Ana María Salgado G.

Descomposición funcional. Parte II

M.Sc. Ana María Salgado G. Página 2

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.



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]);

}



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)

{

…

}



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;



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';



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;

}



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" };



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)

{


printf("%s\n", listaFinal[ind]);

}

else

Error( );

/* Liberar la memoria ocupada por el array listaFinal */


free(listaFinal[ind]);

free(listaFinal);

}



/****************************************************************

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);


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);


strcpy(listaF[indF++], listaA[ind]);

}

for (ind = indN; ind < dimN; ind++)

{

listaF[indF] = (char *)malloc(strlen(listaN[indN]) + 1);


strcpy(listaF[indF++], listaN[ind]);

}

return(1);

}

void Error(void)

{

puts("Longitud no válida de la lista resultante");

exit(1);

}



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;

}



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.


#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("ca = ");


printf("cb = ");


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.



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.


#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("ca = ");


printf("cb = ");


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;

}



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



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 ex ( e = 2.718282)

#include <math.h>

double exp(double x);



• 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: xy. 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 xy 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);



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á.



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;

};



/**************** 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);

}



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));

}



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);

}



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);

}



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);



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;



c[fila][col] = a[fila][col] + b[fila][col];

return;

}

void sacarsalida(int a[ ][MAXCOL], int m, int n)

{

int fila,col;


{


printf("%d\t",a[fila][col]);

printf("\n");

}



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

0 1 1 2 3 5 8 13 21 34

// fibonacci.c

//

#include <stdio.h>

#include <stdlib.h>

int fibonacci(int);

int main()

{

int n = 0, i = 0, *f;

printf("¿Cuántos números de Fibonacci, a partir del ");

printf("primero, se quieren calcular?\n");



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);

}



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.



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.



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.

4

3

2

1

Izquierda Centro Derecha



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.

Documents

Descomposicion funcional parte ii 2013 2