BUCLE FOR:

Programa q realiza la suma de los primeros 20 numeros pares y manda el resultado a pantalla madiante un ciclo for.

#include <stdio.h>

int main(void)

{

int a,b;

a=0;

for(b=2;b<=40;b+=2)

{

a=a+b;

}

printf("%d\n",a);

return 0;

}

Bucle While

La palabra "while" en inglés significa "mientras". Es obvio que una estructura iterativa while contiene por tanto, una pregunta o condición de finalización del bucle del estilo "mientras ocurra tal condición continúa iterando". Esta condición es en realidad cualquier expresión que devuelva un valor numérico entero. Un valor de la expresión igual a 0 hace que la condición se evalúe como falsa, y cualquier otro valor, distinto de 0, hace que se evalúe como verdadera. El pseudocódigo de un bucle que se escriba con esta sentencia sería del estilo:

InicializaciónMientras se cumpla la condición:

OperacionesSiguiente iteracion

Dentro de las operaciones del bucle lo normal será encontrarse alguna sentencia que actualice la condición del bucle. En lenguaje C la forma de escribir un bucle while (la sintaxis) es similar:

while (condicion) <sentencia>;

Como siempre, la sentencia puede ser una única línea de código o un bloque entero rodeado de llaves. La sentencia sería el "cuerpo" del bucle, y en general contendrá la actualización necesaria de la condición que se evaluará en el while.

Por ejemplo, para escribir un bucle que debe iterarse un número N fijo de veces usando un bucle while se debe recurrir a una variable que actúe de "contador", y que se vaya incrementando dentro del cuerpo del bucle. Así la traducción a C de tal figura sería:

i=0;while (i<N){

<operaciones a realizar>;i++;

}

Como se observa claramente, en la primera iteración la variable que hace de contador, i, tiene el valor 0, de forma que se ejecutaría una primera iteración (suponiendo que N es distinto de cero). Al final de la misma se incrementa el valor de i, y entonces se vuelve hacia atrás, donde se evalúa la condición del bucle while, comparando i con N. Así se repetirían las operaciones del cuerpo del bucle, hasta que i alcance el valor de N (N iteraciones). Hay que advertir aquí, que siempre ha de comprobarse con certeza que la condición del bucle es la deseada. Cometer un error en la misma es bastante frecuente, y conduce a un error de programación difícil de depurar. En nuestro ejemplo, es probable que el programador cometa una equivocación o dude entre el uso del operador de comparación < y el <=. En este ejemplo, si se hubiese usado este último, el bucle habría iterado una vez más, es decir N+1 veces.

Como ya hemos visto en otros ejemplos, el lenguaje C puede combinar varias operaciones en cada línea de código, de forma que podemos encontrarnos el bucle anterior escrito de la siguiente manera:

i=0;while (i++<N){

<operaciones a realizar>; /*Aqui i vale 1 unidad mas en cada iteracion */}

Nótese que el operador elegido para incrementar i, es el de post-incremento, concordando así con el código anterior. Si se hubiera usado el operador de pre-

incremento, habríamos cometido un error, puesto que el bucle iteraría una vez menos, desde i=1 hasta i=N-1. Es importante tener en cuenta el comentario que se ha añadido, ya que el uso del operador de post-incremento, conduce a que la variable i se incremente antes de la ejecución de las operaciones del cuerpo del bucle. Sin embargo, en general en lenguaje C es más usual iterar los bucles empezando por el valor 0 de la variable contador, y llegando hasta el valor N-1. Por tanto, así lo haremos en el resto de ejemplos salvo indicación contraria.

En ocasiones, nos interesará que el contador cuente hacia atrás. Esto no es mayor problema, si la condición del while se cambia para que sea falso en cuanto que el contador rebase el límite inferior de la cuenta y se utilice el operador de decremento en lugar del de incremento.

Por otra parte, dado que la condición del while puede ser cualquiera, los bucles cuyo número de iteraciones no es constante o está contenido en alguna variable se pueden escribir bastante directamente con bucles while. Sólo habría que poner la condición requerida en el paréntesis del while. Incluso tal condición puede estar compuesta de varias comparaciones unidas por los operadores lógicos Y u O (que en C son: && o ||). De momento analizaremos un ejemplo donde la condición del bucle no es fácil de conocer cuando se escribe el código, sino que depende de la computación que se realiza al ejecutarlo, y, por tanto, no se sabe a priori cuantas iteraciones ha de realizar el bucle. Se trata de hallar el primer elemento de la serie

Fórmula

en MathML: Sumatorio desde ka igual a uno hasta ka igual a eme de ka al cubo

que supera el valor 10000. La forma más simple de encontrar tal elemento es calcular todos los términos de la serie y preguntar cuando se supera el valor 10000 (condición de finalización del bucle). Si desarrollamos la serie usando la calculadora y anotamos los diferentes términos en una tabla, obtenemos esto:

Serie de m al cubom m3 Suma

1 1 1

2 8 93 27 364 64 1005 125 2256 216 4417 343 7848 512 12969 729 202510 1000 302511 1331 435612 1728 608413 2197 827114 2744 1101515 3375 14390

La tercera fila se halla fácilmente sabiendo que

Fórmula

en MathML: El sumatorio desde ka igual a cero hasta ka igual a eme de ka al

cubo es igual al sumatorio desde ka igual a cero hasta ka igual a eme menos

uno de ka al cubo más eme al cubo

Es decir, para hallar el término m-ésimo de la serie basta con coger el término anterior y sumarle el valor de m al cubo.

Para calcular los términos de la serie, se van acumulando en una variable (suma) los cubos de los números enteros, representados por la variable n. Recuerde que el operador += permite acumular o incrementar una variable. Inicialmente tenemos que poner a 0 la variable acumuladora suma, y valorar n

con 1, para que n vaya luego recorriendo los números enteros. Entonces tal algoritmo podría escribirse con un bucle while así:

k=1; suma=0;while ( suma <= 10000 ){

suma += k*k*k;k++;

}printf ("El primer elemento que supera 10000 es el %d\n", k-1);

La solución del ejemplo anterior es el número 14 (compruebe la tabla anterior), luego

Fórmula

en MathML: El sumatorio desde ka igual a uno hasta ka igual a catorce de ka

al cubo es mayor que diez mil

. Obsérvese que la solución se corresponde con k-1, y no con k, puesto que antes de salir del bucle se había ejecutado la sentencia k++;.

Sin embargo, en los bucles que obedecen a esquemas donde la condición de finalización depende de lo que introduzca el usuario, es necesario leer tal número siempre antes de evaluar la condición. Esto quiere decir que el fragmento que lee tal número debe repetirse en dos sitios si se quiere usar un bucle while. Por ejemplo el esquema de la Figura 4.4 se escribiría en C como:

#include <math.h>......printf ("Dame numero (negativo para salir): ");scanf ("%f", &x);while (x>=0){

printf ("La raiz cuadrada es: %f\n", sqrt(x) );printf ("Dame numero (negativo para salir): ");scanf ("%f", &x);

}

Observemos que antes del bucle se solicita un número, entonces la condición de finalización del mismo pregunta si es negativo. Si es negativo, el bucle acaba, pero si no lo es, se calcula la raíz cuadrada y al final del bucle se vuelve a pedir otro número para así volver a empezar. Para hallar la raíz cuadrada se está usando la función sqrt (del inglés square root). Para usar esta función debe incluirse al principio del fichero de código la línea #include <math.h>

Dame numero (negativo para salir): 4La raiz cuadrada es: 2Dame numero (negativo para salir): 144La raiz cuadrada es: 12Dame numero (negativo para salir): 745.98La raiz cuadrada es: 27.31263443Dame numero (negativo para salir): -6

Bucle For

Los bucles se usan a menudo para recorrer una serie de elementos, indexar un vector, contar algo, etc.. A causa de lo común de estas operaciones dentro de un programa medianamente útil, C incorpora una notación más legible para este tipo de bucle: el bucle for. La palabra inglesa "for" se corresponde con la preposición española "para". En concreto un bucle for, podría traducirse en pseudocódigo algo como: "para todos los elementos que cumplen cierta condición, realiza la sentencia del cuerpo del bucle, y tras cada iteración ejecuta ciertas actualizaciones". Un ejemplo de un "para" lo tenemos también en el signo que se emplea en la notación matemática para formular teoremas. Por ejemplo: significaría "para todos los números naturales entre 1 y 10, hacer...". Las palabras que hemos señalado en cursiva son las acciones de que consta un bucle for, y su sintaxis es así:

for (inicializacion; condicion; actualizacion) <sentencia>;

Igualmente a los otros dos bucles, la sentencia ("cuerpo" del bucle) puede ser una única línea de código o un bloque entero rodeado de llaves {}. Pero lo que da legibilidad al for, es que se incluyen en su sintaxis la inicialización y la actualización, las cuales pueden incluir lo que el programador desee, de forma que para bucles simples no es necesario que en la sentencia se incluyan las actualizaciones necesaria para evaluar la condición del bucle, como pasaba en los bucles anteriores. También las operaciones de inicialización permiten evitar que el bucle vaya precedido de forma poco elegante de las mismas.

Recordar cuál es cuál dentro de los tres campos separados por ';' del bucle for puede no ser fácil al principio; por eso aconsejamos que se recuerde el caso más típico de bucle que itera N veces (como siempre desde 0 hasta N-1, pues es lo habitual en lenguaje C), y que escrito con for y usando i como variable contadora, queda como:

for (i=0; i<N; i++){

<operaciones a realizar>;}

Aquí se distingue claramente como inicializamos la variable contador a 0, establecemos como condición de salida que se alcance el valor N, y tras cada iteración se incrementa i. Nótese la elegancia de este código respecto del escrito con un bucle while, puesto que todo lo relativo a la iteración de las operaciones queda encerrado en los paréntesis del for.

En un bucle for se puede inicializar más de una variable. Para ello basta separar las sentencias de asignación por comas, de esta forma:

for (i=0, j=0 ; ...... ; .......)

La acción de actualización puede ser indistintamente la sentencia i++; como la ++i; puesto que se ejecutan independientemente del cuerpo del bucle: después del cuerpo y antes de volver a evaluar la condición. También es importante recordar que cuando el bucle se acaba, la actualización se ha realizado una vez más, precisamente para que la condición no sea cierta. Esto significa, por ejemplo en el bucle anterior, que la variable i vale N al salir del bucle y no N-1, aunque la última iteración hubiese sido la i=N-1. O lo que es lo mismo, en este bucle tipo, N conserva el número de veces que se ha ejecutado el bucle.

Al igual que en los otros bucles, la condición para continuar iterando puede ser cualquiera, incluso compuesta por varias comparaciones. Y además las

acciones de inicialización y actualización también pueden ser cualesquiera sentencias válidas de C, o incluso dejarse vacías. Por todo eso el bucle for es muy flexible y denso, permitiendo representar muy diversos bucles en sólo una línea. Por ejemplo, con éste se puede escribir un bucle while de forma obvia:

for (; condicion;) <sentencia>;

equivaldría a:

while (condicion) <sentencia>;

puesto que se han dejado vacías las acciones de inicialización y actualización (nótese que los ';' del bucle for deben permanecer para no cometer un error sintáctico). Como ejercicio, trate de poner en la forma más compacta posible con un bucle for, el ejemplo visto para el bucle while que trataba de hallar el primer elemento de la serie

Fórmula en

mathML: Sumatorio desde ka igual a uno hasta ka igual a eme de ka al cubo

que superase el valor 10000 (y por supuesto, ¡la solución debe ser la misma!).

De forma análoga, las acciones de inicialización y actualización pueden ser cualesquiera, permitiendo muchas posibilidades. A continuación se muestran algunas posibilidades, en las que se la sentencia elegida sirve para comprobar el valor que va tomando la variable índice del bucle:

El bucle que muestra solo los primeros N números pares (análogo para los impares)

Obsérvese como i va "saltando" de dos en dos:

for (i=2; i<=2*N; i+=2) printf ("Valor de i: %d\n", i);Valor de i: 2

Valor de i: 4Valor de i: 6......

El bucle que itera N veces usando i como variable contadora, pero contando hacia atrás desde N-1 hasta 0, inclusive

for (i=N-1; i>=0; i--)printf ("Valor de i: %d\n", i);

Valor de i: 4 (suponemos que N vale 5 al entrar en el for)Valor de i: 3Valor de i: 2Valor de i: 1Valor de i: 0

Un bucle donde la variable contador no se incrementa sino que se multiplica como una progresión geométrica de razón r

Aquí x es variable real, float o double.

for (x=r; x<=r*r*r*r*r*r; x=x*r)printf ("Valor de x: %f\n", x);

Valor de i: 0.5 (suponemos que r vale 0.5 al entrar en el for)Valor de i: 0.25Valor de i: 0.125Valor de i: 0.0625Valor de i: 0.03125Valor de i: 0,00048828125

El alfabeto del código ASCII

Se pueden usar como contadores variables de tipo char

char c;

for (c='A'; c<='Z'; c++)printf ("%c", c);

ABCDEFGHIJKLMNOPQRSTUVWXYZ

Suma de términos de una progresión

Las variables implicadas en la inicialización, condición y actualización son iguales a cualesquiera otras, y por tanto pueden ser modificadas en cualquier parte del cuerpo del bucle o de nuestro programa. La suma de m+1 términos una progresión geométrica de razón

Fórmula en

MathML: Uno partido de dos

(serie

Fórmula en

MathML: Sumatorio desde ka igual a cero hasta ka igual a eme de uno partido

de dos elevado a ka

) que se puede codificar de muchas formas con los bucles que ya hemos visto, podría escribirse así:suma=1.0;k=1;/* el primer termino se inicializa fuera del bucle*/

for (increm=1.0; k++<=m; suma+=increm)increm=increm/2.0;

printf ("La suma de %d terminos es: %f\n", k-1, suma);

Como puede observarse la variable contador del bucle es k, pero la inicialización se ha puesto (como simple evidencia del funcionamiento) fuera del mismo. Por el contrario, en la inicialización se ha colocado la variable increm, que va calculando los términos de la progresión geométrica. El post-incremento de k introducido en la condición es correcto, y el bucle itera justamente m veces, pero k contiene m+2 al finalizar, lo cual se tiene en cuenta en la impresión de resultados. De todas formas, en general no es aconsejable escribir este tipo de

códigos enrevesados, ya que son más difíciles de depurar, y aquí se ha mostrado solamente como ejemplo de la flexibilidad del bucle for. Intente como ejercicio escribir tal código de una manera más sencilla, al estilo del primer for que se mostró en esta sección y dejando para el cuerpo las operaciones de las otras variables (por supuesto no olvide comprobar que obtiene los mismos resultados).