Ejercicio 1: Evaluación de la función ex por desarrollo en serie.
Ejercicio 1: Evaluación de la función
ex por desarrollo en serie.
Ejercicio
2: Otra forma de terminar un bucle.
Ejercicio
3: Desarrollo en serie de sen(x).
Ejercicio
4: Máximo de un conjunto de tres números.
Ejercicio
5: Potencias.
Ejercicio
6: Una función que no toma argumentos.
Ejercicio
7: Modificar el ejercicio 4.
Ejercicio
8: Giro de una barra extensible.
Ejercicio
9: Modificar el ejercicio 8.
Ejercicio
10: Máximo de un conjunto de tres números.
Ejercicio
11: Operaciones con vectores (Ejercicio 8 de la práctica 6).
Ejercicio
12: Una función que se llama a sí misma (función
recursiva).
Ejercicio
13: Otra función recursiva: La suma de los N primeros números
enteros.
Ejercicio 1: Evaluación de la función ex por desarrollo en serie. |
|
Según la fórmula de Taylor, podemos expresar la función exponencial ex mediante la siguiente serie:
En el programa que te presentamos a continuación, las variables z y numero, argumentos formales de la función, reciben una copia de x y terminos respectivamente, que son los argumentos actuales. La variable frac va almacenando la fracción a sumar en cada término del sumatorio. Así para cada nuevo sumando no hay más que multiplicar el anterior valor por z/i:
Guarda el programa como serie.c.
/* fichero serie.c */
#include <stdio.h>
#include <math.h>
void main(void)
{
int terminos;
double x, valor_estimado, valor_exacto;
double serie(double ,int );
printf("%s%s",
"Este programa calcula \"e\" elevado a \"x\" por desarrollo",
"en serie\n con el numero de terminos que quieras\n");
printf("Teclea x:");
scanf("%lf",&x);
printf("\nTeclea el numero de terminos:");
scanf("%d", &terminos);
printf("%s%lfcon %d %s%16.6lf\n",
"El resultado de e elevado a ", x, "terminos es ",
terminos, serie(x, terminos));
printf("Error cometido: %16.6lf\n", serie(x, terminos) - exp(x));
}
double serie(double z, int numero)
{
double miserie = 1, frac;
int i;
frac = z;
miserie += rac;
i = 2;
if (numero == 1) {
miserie = 1;
return miserie;
}
while (i <= numero) {
frac = frac*z/i++;
miserie += frac;
}
return miserie;
}
Comentario: La complejidad de este tipo de programas reside en el tipo de algoritmo que se utilice. En este caso, la condición que tiene el bucle para finalizar la iteración es el número de términos que se ha introducido por el teclado. La forma de calcular la serie es añadiendo una nueva fracción a la serie. Para el cálculo de esta nueva fracción utilizamos el valor que tenía la fracción en la iteración anterior, según explica el enunciado del ejercicio.
Ejercicio 2: Otra forma de terminar un bucle. |
|
En el programa anterior el bucle while terminaba al llegar al número de términos solicitado por el usuario. Vamos a emplear ahora otro criterio para terminar ese bucle.
El programa que se presenta a continuación tiene tres variables importantes: serie1, serie2 y frac. Al final del bucle while tenemos dos variables que serán distintas: serie1 y serie2. La diferencia entre ambas está en frac. Como frac va disminuyendo su valor, habrá un momento en que los decimales de serie1 y serie2 coincidirán (el ordenador no puede tener información de todos los decimales). Por esta razón, lo que nos marca el límite del bucle es la comparación entre serie1 y serie2. Este programa se ha realizado sin emplear ninguna función. Guárdalo como serie2.c.
/* fichero serie2.c */
#include <stdio.h>
#include <math.h>
void main(void)
{
double x, serie1, serie2, frac;
int i;
printf("Teclea el valor de x:\n");
scanf("%lf", &x);
serie1 = 1.0;
frac = x;
serie2 = serie1 + frac;
i = 2;
while (serie1 != serie2) {
serie1 = serie2;
frac = frac*x/i++;
serie2 = serie1 + frac;
}
printf("Valor estimado:%20.16e\n", serie2);
printf("Valor exacto:%20.16e.\n", exp(x));
printf("Numero de terminos utilizados:%d\n", i);
}
Comentario: Este ejercicio es similar al anterior. En este caso la diferencia estriba en la condición de finalización de las iteraciones. Para este ejercicio utilizamos un bucle while y dos series (con el nombre de serie1 y serie2) cuya diferencia entre ambas es de un término, es decir, en la comparación la serie2 tiene un término más que la serie1. La razón de esta forma de calcular la serie la encontramos una vez más en la capacidad de almacenamiento de las variables tipo double: la fracción que calculamos y que añadimos a la serie es cada vez más pequeña y, por tanto, la diferencia entre las dos series también. Llega un momento en el que las cifras significativas que puede almacenar la variable no son apreciables y la fracción que sumamos no representa cambio en las variables: en ese momento las series toman el mismo valor, se igualan y, por tanto, se termina la ejecución del bucle.
Ejercicio 3: Desarrollo en serie de sen(x). |
|
Realiza un programa análogo al anterior que emplee una función para calcular sen(x), cuyo desarrollo en serie es:
Guarda el programa como serie3.c.
/* fichero serie3.c */
#include <stdio.h>
#include <math.h>
void main(void)
{
int i, n;
double x, serie1, serie2, frac;
double fac(int);
double pot(double, int);
printf("Este programa calcula el valor del seno.\n");
printf("Introduzca el valor del angulo en radianes:\n");
scanf("%lf", &x);
serie2 = x;
serie1 = 0.0;
i = 2;
while (serie1 != serie2) {
serie1 = serie2;
n = 2*i-1;
frac = -frac * (x*x/(n*(n-1));
serie2 += frac;
i++;
}
printf("Valor estimado: %20.16e\n", serie2);
printf("Valor exacto: %20.16e\n", sin(x));
printf("Numero de terminos utilizados: %d\n", i);
}
Comentario: En este programa cada fracción que se añade a la serie se calcula también a partir del anterior. Se tiene en cuenta que los distintos términos cambian de signo alternativamente, y que cada uno es el anterior multiplicado por x al cuadrado, y dividido por (2*i-1)*(2*i-2).
Ejercicio 4: Máximo de un conjunto de tres números. |
|
Realiza un programa principal que lea tres números enteros por teclado, los almacene en tres variables (x, y, z) y llame a una función tal y como maximo(), de tres argumentos, que devuelva el máximo de estos tres valores. Guarda el programa como maxval.c.
/* fichero maxval.c */
#include <stdio.h>
void main(void)
{
int x, y, z;
int maximo(int, int, int);
printf("Introduzca tres valores:\n");
printf("primero: ");
scanf("%d", &x);
printf("segundo: ");
scanf("%d", &y);
printf("tercero: ");
scanf("%d", &z);
printf("El maximo de los tres valores introducidos es: \n");
printf("%d\n", maximo(x, y, z));
}
int maximo(int a, int b, int c)
{
int max;
max = a;
if (b > max)
max = b;
if (c > max)
max = c;
return max;
}
Comentario: Como la función maximo() devuelve un valor entero no es necesario declararla dentro de la función main(), aunque en este caso se haya hecho. Las variables a, b, y c, argumentos formales de la función, reciben una copia de los argumentos actuales: x, y, z. La forma de calcular el máximo de una lista de números es ya conocido.
Ejercicio 5: Potencias |
|
Realiza un programa que calcule las potencias de la 2 a la 10 del número PI y la raíz cuadrada de dicha potencia. Para ello construye una función que calcule la potencia n-ésima de un número cualquiera y utiliza después la función sqrt de la librería matemática del C. Guarda el programa como potencia.c.
/* fhchero potencia.c */
#include <stdio.h>
#include <math.h>
#define PI 3.14159265359
void main(void)
{
int i;
double poten(double, int);
for (i=2; i<=10; i++) {
printf("PI elevado a %d es %5.2lf y su ra¡z es %5.2lf\n",
i, poten(PI, i), sqrt(poten(PI, i)) );
}
}
double poten(double a, int b)
{
int i;
double resul;
resul = 1.0;
for (i=1; i<=b; i++)
resul *= a;
return resul;
}
Comentario: Para calcular las potencias de la 2 a la 10 del número PI, se utiliza un bucle for que va de i=2 a i=10, llamando en cada ejecución a la función poten(). A esta función se le pasa una constante double, que es el número PI, y el exponente entero i. La función poten() sirve para calcular la potencia i-ésima de cualquier número. En este caso, la variable a de la función toma el valor de PI en todas las llamadas mientras que la variable b copia el valor de i que será distinto en cada una de las llamadas
Ejercicio 6: Una función que no toma argumentos. |
|
Pues sí, hay funciones (y personas) que por no tomar no toman ni argumentos. El siguiente programa calcula la diferencia en minutos entre dos horas distintas. La función cogemins() acepta el tiempo que el usuario introduce en horas y minutos y lo convierte a minutos devolviendo este valor entero. La función presenta la particularidad de no tomar ningún argumento. Guarda el programa como tiempo.c.
Otra novedad de este programa es la existencia de dos puntos (:) entre los dos especificadores de formato, %d y %d, de la instrucción scanf(). Esto hace que el usuario deba introducir los dos puntos entre los números que conforman el formato del tiempo. Estos números son capturados por la función mediante los especificadores %d. Los dos puntos sustituyen a los caracteres de espaciado tradicionales (espacio, tabulador, nueva línea). Así el usuario puede introducir el tiempo en el formato estándar de horas y minutos, utilizando los dos puntos para separarlos.
/* fichero tiempo.c */
/* calcula la diferencia entre dos horas distintas */
void main(void)
{
int minutos1, minutos2;
printf("Escribe la primera hora (formato 3:22):");
minutos1 = cogemins(); /* obtiene los minutos */
printf("Escribe la segunda hora (posterior): ");
minutos2 = cogemins(); /* obtiene los minutos*/
printf("La diferencia es %d minutos.", minutos2 - minutos1);
}
int cogemins(void)
{
int horas,minutos;
scanf("%d:%d", &horas, &minutos);
return (horas*60+minutos);
}
Ejercicio 7: Modificar el Ejercicio 4. |
|
No podemos dejar pasar la ocasión de modificar un programa tan sencillo como el anterior. Modifica el programa tiempo.c de manera que permita introducir las dos horas, incluidos los segundos, utilizando el formato 3:22:17 y calcule la diferencia en horas, minutos y segundos. Además deberá avisar en el caso de que la segunda hora sea anterior a la primera y si se teclea una hora errónea, es decir, que el número correspondiente a las horas sea mayor que 24 ó el de los minutos mayor que 60, etc. Guarda este programa como tiempo2.c.
/* fichero tiempo2.c */
#include <stdio.h>
void main(void)
{
int horas, minutos;
long int diferencia, segundos1, segundos2;
long int cogesegs(void);
printf("Escribe la primera hora (formato 3:22:14):");
segundos1 = cogesegs();
do {
printf("Escribe la segunda hora (posterior): ");
segundos2 = cogesegs();
} while(segundos2 <= segundos1);
diferencia = segundos2 - segundos1;
horas = (int)(diferencia/3600);
diferencia = diferencia%3600;
minutos = (int)(diferencia/60);
diferencia = diferencia%60;
printf("La diferencia es %d hora(s), %d minuto(s), %d segundo(s).",
horas, minutos, diferencia);
}
long int cogesegs(void)
{
int horas, minutos, segundos, pass = 0;
long int total;
do {
pass = 0;
scanf("%d:%d:%d", &horas, &minutos, &segundos);
if (horas > 24)
pass = 1;
if (minutos > 60)
pass = 1;
if (pass == 1) {
printf("Hora incorrecta!!!!\n");
printf("Escriba la hora correcta: ");
}
} while(pass == 1);
total = (long int)horas*3600;
total += (minutos*60 + segundos);
return total;
}
Comentario: Para calcular la diferencia entre las dos horas es necesario convertirlas antes en segundos, para así poder restarlas. Después hay que convertir este número, en segundos, a horas, minutos y segundos. Para obtener las horas se divide el numero entre 3600 segundos/hora, quedándonos con el número entero que resulta. El resto de esta división, es decir, el resto de los segundos se convertirán a minutos dividiendo por 60 segundos/minuto. El número entero resultante de esta división serán los minutos y el resto los segundos. Dentro de la funcion cogesegs() aparece un bulce do while, que como ya sabemos siempre se ejecuta al menos una vez. En nuestro caso el bucle se ejecutará sólo una vez, si el usuario teclea correctamente la hora. De lo contrario, es decir, si se equivoca al teclear el número correspondiente a las horas, los minutos o los segundos, la variable pass tomará el valor 1, que es la condición para que el bucle se vuelva a ejecutar. De esta forma se pueden teclear otra vez los datos.
Obsérvese que la función cogesegs() devuelve un valor de tipo long int, esto es debido a que si la diferencia entre horas es 24 (máximo valor posible). Este valor en segundos (86400) supera la capacidad de una variable de tipo int.
Dentro de main() también hay otro bucle do while, este bucle se ejecuta más de una vez en el caso de que la segunda hora sea anterior a la primera, dando así la posibilidad de volver a teclear la hora.
Ejercicio 8: Giro de una barra extensible. |
|
En la siguiente figura se muestra una barra AB extensible, es decir, de longitud variable, que gira alrededor de su extremo fijo A. Las coordenadas (xi,yi) de su extremo móvil B son conocidas en diez instantes del movimiento.
Las coordenadas del extremo B son las siguientes:
(2,0), (1.5,3), (-1,3), (-1.5,2), (-2.5,0), (-2.5,-1), (-1.5,-1.5), (0,-1), (1,-2), (1.5,-1.5)
Estas coordenadas se almacenarán en el fichero datos.d.
Realiza un programa que calcule el ángulo formado por la barra con la horizontal y su longitud, en cada uno de los diez instantes. El ángulo se calculará leyendo los datos del fichero datos.d, calculando a partir de éstos el arcotangente.
La librería matemática de C dispone de dos funciones para calcular el arcotangente: atan() y atan2(), cuyos prototipos son:
double atan(double a) que calcula el arcotangente de a
double atan2(double b, double a) que calcula el arcotangente de b/a.
El ángulo que devuelven estas dos funciones está en radianes: atan() devuelve un ángulo comprendido entre (-p/2, p/2), mientras que atan2() devuelve un ángulo comprendido entre (-p, p).
Te pedimos que programes una función similar a atan2() y que llamarás atan2a(), empleando para ello atan() de manera que el ángulo que devuelva esté comprendido entre (-p, p).
La salida del programa deberá ser similar a la siguiente:
En el instante 1 la barra tiene una longitud de 2 y forma un ángulo de 0 radianes o de 0 grados con la horizontal.
En el instante 2 la barra tiene una longitud de 1.765 y forma un ángulo de 0.17823 radianes o 10.21 grados con la horizontal.
En el instante 3 ...
(Los valores que se muestran son inventados y no han de concidir con los que calcules).
Guarda el programa como barra.c.
/* fichero barra.c */
#include <stdio.h>
#include <math.h>
#define PI 3.141592654
void main(void)
{
int i;
FILE *fi;
double x, y;
double radianes, grados, longitud;
double calcula_longitud(double, double);
double atan2a(double, double);
fi = fopen("datos.d", "r");
for (i=1; i<=10; i++) {
fscanf(fi,"%lf", &x);
fscanf(fi,"%lf", &y);
longitud = calcula_longitud(x,y);
radianes = atan2a(x,y);
grados = radianes*180.0/PI;
printf("En el instante %d la barra tiene una longitud de %lf\n",
i, longitud);
printf("y forma un angulo de %lf radianes ", radianes);
printf("o %lf grados con la horizontal.\n", grados);
getchar();
}
fclose(fi);
}
double calcula_longitud(double x, double y)
{
double resul;
resul = sqrt( x*x + y*y );
return(resul);
}
double atan2a(double x, double y)
{
double resul, aux;
if (x == 0.0)
if (y > 0.0)
resul = PI/2;
else
resul = -PI/2;
else
aux = atan(y/x);
if ((x < 0.0)&&(x != 0.0))
if (y >= 0.0) /*si el angulo esta en el segundo cuadrante */
resul = aux + PI;
else
resul = aux - PI; /* si el angulo esta
en el tercer cuadrante */
else if ( x != 0.0 )
resul = aux; /* si el angulo esta
en el primer o cuarto cuadrante */
return resul;
}
Comentario: Este programa va leyendo las coordenadas x e y para cada posición de la barra y llama a las funciones calcula_longitud() que calcula la longitud de la barra y atan2a() que devuelve el ángulo que forma la barra en radianes.
En cuanto a la función atan2a(), queremos que devuelva un ángulo comprendido entre -p y p radianes basándonos en la función atan() que devulve un ángulo comprendido entre -p/2 y p/2. Para ello hay que tener en cuenta que:
Si x>0 e y>0: el ángulo pertenece al primer cuadrante, por lo tanto atan2a()=atan().
Si x>0 e y<0: el ángulo pertenece al cuarto cuadrante, por lo tanto atan2a()=atan().
Si x<0 e y>0: el ángulo pertenece al segundo cuadrante, por lo tanto atan2a()=atan()+p.
Si x<0 e y<0: el ángulo pertenece tercer cuadrante, por lo tanto atan2a()=-atan()-p.
Hay que tener cuidado cuando x=0, pues se realiza una división por cero que produce un error al ejecutar el programa. Esto se evita muy fácimente ya que cuando x=0, la barra se encuentra en posición vertical, bien formando un ángulo de p/2 radianes si y>0, o de -p/2 si y<0.
Ejercicio 9: Modificar el Ejercicio 8. |
|
Con el mismo programa principal anterior sustituye la función atan2a() por la función atan2b(), también programada por ti, ¡cómo no!, que devuelva un ángulo comprendido entre (0, 2p) radianes.
/* fichero barra2.c */
#include <stdio.h>
#include <math.h>
#define PI 3.141592654
double calcula_longitud(double, double);
double atan2b(double, double);
void main(void)
{
FILE *fi;
double x, y;
int i;
double radianes;
double grados;
double longitud;
fi = fopen("datos.d", "r");
for ( i = 1; i <= 10; i++)
{
fscanf(fi,"%lf", &x); fscanf(fi,"%lf", &y);
longitud = calcula_longitud(x,y);
radianes = atan2b(x,y);
grados = radianes*180.0/PI;
printf("En el instante %d la barra tiene una longitud de %lf\n", i, longitud);
printf("y forma un ngulo de %lf radianes o %lf grados con la horizontal.\n", radianes, grados);
getchar();
}
fclose(fi);
}
double calcula_longitud( double x, double y)
{
double resul;
resul = sqrt( x*x + y*y );
return(resul);
}
double atan2b(double x, double y)
{
double resul;
double aux;
if ( x == 0.0 )
if ( y > 0.0 )
resul = PI/2;
else
resul = 3*PI/2;
else
aux = atan(y/x);
if (x < 0.0)
resul = aux + PI;
else if ( x > 0.0 )
if (y<0.0)
resul=2*PI+aux;
else
resul = aux;
return (resul);
}
Comentario: El programa es idéntico al anterior con la salvedad del cálculo de la tangente que se hace de forma similar al programa anterior.
Ejercicio 10: Máximo de un conjunto de tres números. |
|
No, no se trata de repetir el Ejercicio 2, sino de realizarlo de otro modo. Realiza este nuevo programa, maxref.c, que lea también tres números enteros, los almacene en un vector y llame a una función maximo() que devuelva el máximo valor de entre los tres. El vector se pasará por referencia.
/* fichero maxref.c */
#include <stdio.h>
void main(void)
{
int vector[3];
int maximo(int*);
printf("Introduzca tres valores:\n");
printf("primero: ");
scanf("%d", &vector[0]);
printf("segundo: ");
scanf("%d", &vector[1]);
printf("tercero: ");
scanf("%d", &vector[2]);
printf("El maximo de los tres valores introducidos es: \n");
printf("%d\n", maximo(vector));
}
int maximo(int *a)
{
int max;
max = a[0];
if (a[1] > max)
max = a[1];
if (a[2] > max)
max = a[2];
return max;
}
Comentario: Este programa es muy fácil de entender y no requiere ningún comentario particular.
Ejercicio 11: Operaciones con vectores (Ejercicio 8 de la práctica 6). |
|
El siguiente programa es el mismo que se sugirió en la Práctica 6, pero puestos a escribirlo se ha introducido una novedad: la sentencia switch.
La sentencia switch funciona de la siguiente manera: se evalúa la expresión que se encuentra a la derecha del switch y entre paréntesis. A continuación se rastrean las etiquetas hasta que se encuentra una que corresponda a dicho valor; entonces se transfiere el control del programa a dicha línea. Si ninguna de las etiquetas encaja se transfiere el control a la línea marcada con la etiqueta default. La sentencia break, que es opcional, hace que el programa salga del switch y se dirija a la sentencia situada inmediatamente después del mismo. De no utilizar el break, se ejecutarían todas las sentencias situadas entre la etiqueta correspondiente y el final del switch. Las etiquetas de un switch deben ser constante de tipo entero (incluyendo char) o bien expresiones de constantes. ¡Nunca se pueden emplear variables!
/* fichero vectors2.c */
#include <stdio.h>
void main(void)
{
double vector1[3], vector2[3], vector3[3];
int i,numero;
void suma(double *, double *, double *);
void resta(double *, double *, double *);
double producto_escalar(double *, double *);
void producto_vectorial(double *, double *, double *);
printf("Este programa realiza las siguientes operaciones:");
printf("con dos vectores:\n");
printf("1.- Suma\n\b2.-Resta\n\b");
printf("3.- Multiplica escalarmente\n\b");
printf("4.- Multiplica vectorialmente\n");
printf("Que operacion deseas realizar? ");
printf("Teclea su numero correspondiente:");
scanf("%d", &numero);
printf("Dame las componentes del primer vector:\n");
for (i=0; i<3; i++) {
printf("vector1[%d]=", i+1);
scanf("%lf", &vector1[i]);
printf("\n");
}
printf("Dame las componentes del segundo vector:\n");
for(i=0; i<3; i++) {
printf("vector2[%d]=", i+1);
scanf("%lf", &vector2[i]);
printf("\n");
}
switch (numero) {
case 1:
suma(vector1, vector2, vector3);
printf("La suma de los dos vectores es el vector:\n");
printf("{ ");
for (i=0; i<3; i++)
printf("%lf ",vector3[i]);
printf("}\n");
break;
case 2:
resta(vector1, vector2, vector3);
printf("La resta de los dos vectores es el vector:\n");
printf("{ ");
for (i=0; i<3; i++)
printf("%lf ",vector3[i]);
printf("}\n");
break;
case 3:
printf("El producto escalar de los dos vectores es: %lf\n",
producto_escalar(vector1, vector2));
break;
case 4:
producto_vectorial(vector1, vector2, vector3);
printf("El producto vectorial de los dos vectores es:\n");
printf("{ ");
for(i=0; i<3; i++)
printf("%lf ", vector3[i]);
printf("}\n");
break;
}
}
void suma(double *a, double *b, double *c)
{
int i;
for (i=0; i<3; i++)
c[i] = a[i]+b[i];
}
void resta(double *a, double *b, double *c)
{
int i;
for (i=0; i<3; i++)
c[i] = a[i]-b[i];
}
double producto_escalar(double *a, double *b)
{
int i;
double escalar=0;
for (i=0; i<3; i++)
escalar += a[i]*b[i];
return(escalar);
}
void producto_vectorial(double *a, double *b, double *c)
{
int i;
c[0] = a[1]*b[2]-a[2]*b[1];
c[1] = -a[0]*b[2]+a[2]*b[0];
c[2] = a[0]*b[1]-a[1]*b[0];
}
Ejercicio 12: Una función que se llama a sí misma (función recursiva): n!. |
|
El siguiente programa calcula el factorial de un número entero n utilizando la siguiente fórmula recursiva:
n! = n * (n-1)!
teniendo en cuenta que: 1! = 1.
Guarda el programa que se da a continuación en el disco con el nombre factor2.c.
/* fichero factor2.c */
#include <stdio.h>
void main(void)
{
int n;
double factor(int);
printf("Teclea un número entero positivo: \n");
scanf("%d", &n);
printf("El factorial de %d es %lf\n", n, factor(n));
}
double factor(int n)
{
if(n <= 1)
return 1.0;
return (n * factor(n-1));
}
Comentario: Las funciones recursivas se llaman a sí mismas, y es muy importante que este proceso tenga un final. Para ello es fundamental que esté presente el caso de terminación, que en esta función es el caso n<=1. Para este valor, la función devuelve valor sin llamarse a sí misma.
Ejercicio 13: Otra función recursiva: La suma de los N primeros números enteros. |
|
Seguro que con la experiencia adquirida en el ejercicio anterior no tienes ninguna dificultad en desarrollar tu propia función recursiva para hallar la suma de los n primeros números enteros impares. Llama sum2.c al fichero correspondiente. En este caso, la función se puede basar en la fórmula recursiva siguiente:
/* fichero sum2.c */
#include <stdio.h>
void main(void)
{
int n;
double suma(int);
printf("Teclea un numero entero positivo: \n");
scanf("%d", &n);
printf("La suma de los %d primeros impares es %lf\n", n, suma(n));
}
double suma(int n)
{
if(n <= 1)
return 1.0;
return ((2*n - 1) + suma(n - 1));
}
Comentario: Sólo reseñar que no se trata de la suma de los impares hasta el número que se teclea, sino que es la suma de los n primeros números impares, es decir si por ejemplo tecleamos 3, el resultado será 9 que es la suma de 1 más 3 más 5.