SENTENCIA DO…WHILE

La sentencia do while ejecuta una sentencia, simple o compuesta, una o

más veces dependiendo del valor de una expresión. Su sintaxis es:

do Sentencia: while(condición); Donde condición es cualquier expresión numérica, relacional o lógica y sentencia es una sentencia simple o compuesta. Observe que la estructura do…while finaliza con un punto y coma. La ejecución de una sentencia do…while sucede de la siguiente forma: 1.-Se ejecuta el bloque (sentencia o compuesta) de do. 2.- se evalúa la expresión correspondiente a la condición de finalización del bucle. 3.-si el resultado de la evaluación es cero (falso), pasa el control a la siguiente sentencia en el programa. 4.-Si el resultado de la evaluación es distinto de cero (verdadero), el proceso descrito se repite desde el punto 1. double n; do//ejecutar las sentencias siguientes { Printf(“numero: “); scanf(“%1f”,&n); } while(n< 0)://mientras n esa menor que 0 cuando se utiliza una estructura do…while el bloque de sentencias se ejecuta al menos una vez, porque la condición se evalua al final. En cambio, cuando se ejecuta una estructura while puede suceder que el bloque de sentencias no se ejecute, lo que ocurrirá siempre que la condición sea inicialmente falsa. Ejercicio:

1.-Realizar un programa que calcule la raíz cuadrada un numero n por el método de newton. La solución de este problema puede ser de la siguiente manera:

Primero definimos las variables que vamos a utilizar en los cálculos: Double n; //numero Double aprox; //aproximación a la raíz cuadrada. Double antaprox;//anterior aproximación a la raíz cuadrada. Double epsilon;//coeficiente de error

A continuación leemos los datos n,aprox y épsilon. Printf(“Numero: “); Scanf(“%1f”,&n); Printf (“Raiz cuadrada aproximada:”); Scanf (“%1f”, &aprox); Printf (“Coeficiente de error: “); Scanf (“%1f”,”épsilon);

Después, se aplica la formula de Newton. do { antaprox=aprox; aprox=(n/anataprox +antaprox)/2; al aplicar la formula por primera vez, la variable anataprox contiene el valor aproximado a la raíz cuadrada que hemos introducido a través del teclado. Para sucesivas veces, anataprox contendrá la última aproximación calculada.

Cuando la condición especificada en la estructura do...while mostrada anteriormente sea falsa, el proceso habrá terminado. Solo queda imprimir el resultado. Printf(“La raíz cuadrada de %.21f es%.21f\n”,n,aprox); El programa completo se muestre a continuación. Para no permitir la entrada de números negativos, se ha utilizado una estructura

do..while que preguntara por el valor solicitado mientras el introducido sea negativo. /********** La raíz cuadrada de un numero. Método de Newton **********/ #include<stdio.h> #include<conio.h> #include<math.h> main() { double n; //numero Double aprox; //aproximación a la raíz cuadrada double antaprox; //anterior aproximación double epsilon; //coeficiente de error do { printf (" Numero: "); scanf ("%lf", &n); } while (n<0); do { printf ("Raíz cuadrada aproximada: "); scanf ("%lf", &aprox); } while (aprox <=0); do { printf("Coeficiente de error: "); scanf("%lf", &epsilon); } while(epsilon <=0); do { antaprox=aprox; aprox=(n/antaprox + antaprox)/2; } while (fabs(aprox-antaprox)>=epsilon); printf("La raíz cuadrada de %.2lf es %.2lf\n", n, aprox); getch();

return 0;

SENTENCIA WHILE.

La sentencia while ejecuta una sentencia, simple o compuesta, cero o más veces, dependiendo de una condición. Su sintaxis es: while (condición) Sentencia; Donde condición es cualquier expresión numérica, relacional o lógica y sentencia es una sentencia simple o compuesta. La ejecución de la sentencia while sucede así: 1.-Se evalúa la condición. 2.-Si le resultado de la evaluación es cero (falso), la sentencia no se ejecuta y pasa el control a la siguiente sentencia en el programa. 3.-Si el resultado de la evaluación es distinto de cero (verdadero),se ejecuta la sentencia y el proceso descrito se repite desde el punto 1. Por ejemplo, en el siguiente código, que podrá ser incluido en cualquier programa, solicita obligatoriamente una de las dos respuestas posibles: s/n(si o no). #include<stdio.h> #include<conio.h> main() { char car='\0'; printf("Desea continuar s/n(si o no) "); car=getchar(); while (car!='s' && car !='n') { fflush(stdin); printf("Desea continuar s/n (si o no) "); car=getchar(); } getch(); return 0;

} Observe que antes de ejecutarse la sentencia while se visualiza el mensaje “Desea continuar s/n (si o no)” y se inicia la condición; esto se asigna un carácter a la variable car que interviene en la condición de la sentencia while. La sentencia while se interpreta de la forma siguiente: mientras el valor de car no sea igual ni al carácter ‘s’ ni al carácter ‘n’, visualizar el mensaje “Desea continuar s/n (si o no)” y leer otro carácter. Esto obliga al usuario a escribir el carácter ‘s’ o ‘n’ en minúsculas. El ejemplo expuesto, puede escribirse de forma más simplificada así: #include<stdio.h> #include<conio.h> main() { char car='\0'; printf("Desea continuar s/n (si o no) "); while ((car=getchar()) !='s' && car !='n') { fflush(stdin); printf("Desea continuar s/n (si o no) "); } getch(); return 0; } La diferencia de este ejemplo con respecto al anterior es que ahora la condición incluye la lectura de la variable car, que se ejecuta primero por estar entre paréntesis. A continuación se compara car con los caracteres ’s’ y ‘n’. El siguiente ejemplo, que visualiza el código ASCII de cada uno de los caracteres de una cadena de texto introducida por el teclado, da lugar a un bucle infinito, porque la condición es siempre cierta(valor distinto de cero).Para salir del bucle infinito tiene que pulsar la tecla Ctrl+C /********** Código ASCII **********/ #include<stdio.h>

#include<conio.h> main() { char car=0;//car=caracter nulo (\0) printf("Introduzca una cadena de texto: "); while (1) { car=getchar(); if(car!= 'n') printf("El codigo ASCII de %c es de %d\n", car, car); else printf("Introduzca una cadena de texto: "); } getch(); return 0; } A continuación ejecutamos la aplicación. Introducimos, por ejemplo, el carácter ‘a’ y observamos los siguientes resultados: Introduzca una cadena de texto: a [Entrar] El código ASCII de a es 97 Introduzca una cadena de texto: Este resultado demuestra que cuando escribimos ‘a’ y pulsamos la tecla Entrar para validar la entrada, solo se visualiza el código ASCII de este carácter; el carácter \n introducido al pulsar entrar es ignorado por que así se ha programado. Cuando se han leído todos los caracteres del flujo de entrada, se solicitan nuevos datos. Lógicamente, habrá comprendido que aunque se lea carácter a carácter se puede escribir, hasta pulsar Entrar, un texto cualquiera. Por ejemplo: Introduzca una cadena de texto: hola [Entrar] El código ASCII de h es 104 El código ASCII de o es 111 El código ASCII de l es 108 El código ASCII de a es 97 Introduzca una cadena de texto:

El resultado obtenido permite observar que bucle while se está ejecutando sin pausa mientras hay caracteres en el flujo de entrada. Cuando dicho flujo queda vacio y se ejecuta la función getchar de nuevo, la ejecución se detiene a la espera de nuevos datos. Modifiquemos ahora el ejemplo anterior con el objetivo de eliminar el bucle infinito. Esto se puede hacer incluyendo en el while una condición de terminación; por ejemplo, leer datos hasta alcanzar la marca de fin de fichero. /********** Código ASCII **********/ #include<stdio.h> #include<conio.h> main() { char car=0;//car=caracter nulo (\0) printf("Introduzca una cadena de texto.\n "); printf(“Para terminar pulse ctrl+z\n”); while ((car=getchar())!=E0F) { If(car=!= ‘\n’) Printf(“El codigo ASCII de %c es %d\n”,car,car); getch(); return 0; } Una solución posible de este programa es la siguiente: Introduzca una cadena de texto. Para terminar pulse Ctrl+z Hola [Entrar] El código ASCII de h es 104 El código ASCII de o es 111 El código ASCII de l es 108 El código ASCII de a es 97 Adiós [Entrar] El codigo ASCII de a es 97 El codigo ASCII de d es 100

El codigo ASCII de i es 105 El codigo ASCII de o es 162 El codigo ASCII de s es 115 [Ctrl][z] Otro ejemplo Generar 5, 10, 15, 20, 25, 30, 35....n: #include<stdio.h> #include<conio.h> int main () { int n, c=1, serie=5; printf("Cantidad de términos: "); scanf("%d",&n); while(c<=n) { printf("%d,", serie); serie+=5; c++; } getch(); } Otro ejemplo: Elabore un programa que calcule el promedio de una lista de x números. #include stdio.h> #include conio.h> main ( ) { int n , contar=1; float x , promedio , suma=0; printf ("Cuantos números desea leer?: "); scanf ("%d", &n); while (contar <= n) { printf ("x= "); scanf ("%f", &x); suma +=x; ++contar; } promedio=suma/n;

printf ("\n El promedio es: %.2f\n", promedio); system(“pause”); return 0; } El siguiente problema es del teorema de Pitágoras: /********** Teorema de Pitágoras **********/ #include<stdio.h> #include<conio.h> #include<math.h> main() { int X=1, Y=1, Z=0; printf("%10s %10s %10s\n","Z", "X", "Y"); printf(" _______________________\n"); while (X<=50) { /*Calcular z, como z es un entero, almacena la parte entera de la raíz cuadrada*/ Z=(int)sqrt(X*X+Y*Y); while(Y<=50 && Z<=50) { /*Si la raíz cuadrada anterior fue exacta escribir Z, X e Y*/ if (Z*Z==X*X+Y*Y) printf("%10d %10d %10d\n", Z, X, Y); Y=Y+1; Z= (int)sqrt(X*X+Y*Y); } X=X+1; Y=X; } getch(); return 0; }

SENTENCIA FOR.

La sentencia for permite ejecutar una sentencia simple o compuesta, repetidamente un número de veces conocido. Su sintaxis es la siguiente:

For (*v1=e1*,v2=e2+…+;*condición+;*progresión-condición]) sentencia;

V1,v2,…representan variables de control que serán iniciadas con los valores de las expresiones e1,e2;

Condición s una expresión booleana que si se omite, se supone verdadera;

Progresión-condición es una o más expresiones separadas por comas cuyos valores evolucionan en el sentido de que se cumpla la condición para finalizar la ejecución de la sentencia for;

Sentencia: es una sentencia simple o compuesta. La ejecución de la sentencia for sucede de la siguiente forma: 1.-Se inician las variables v1, v2,… 2.-Se evalúa la condición:

a) Si el resultado es distinto de cero (verdadero), se ejecuta el bloque de sentencias, se evalúa la expresión que da lugar a la progresión de la condición y se vuelve al punto 2.

b) Si el resultado es cero (falso), la ejecución de la sentencia for se da por finalizada y se pasa el control a la siguiente sentencia del programa.

Por ejemplo, la siguiente sentencia for imprime los números del 1 al 100.Literalmente dice: desde i igual a 1, mientras i sea menor que 100, incrementando la i de uno en uno, escribir el valor de i. /********** Incrementos de 1 en 1 **********/ #include<stdio.h>

#include<conio.h> main() { int k; for (k=1; k<=100; k+=1) printf("%4d", k); getch(); return 0; } El siguiente ejemplo imprime los múltiplos de 7 que hay entre 7 y 112. #include<stdio.h> #include<conio.h> main() { int k; for (k=7; k<=112; k+=7) printf("%4d", k); getch(); return 0; } En el siguiente ejemplo se puede observar la utilización de la coma como separador de las variables de control y de las expresiones que hacen que evolucionen los valores que intervienen en la condición de finalización. /********** Coma como separador de variables **********/ #include<stdio.h> #include<conio.h> main() { int f, c; for (f=3, c=6; f+c <40; f++,c+=2) printf("f=%d\tc= %d\n",f,c); getch(); return 0; }

Este otro ejemplo que se ve a continuación, imprime los valores desde 1 hasta 10 con incrementos 0.5. /********** Incrementos de 0.5 en 0.5 **********/ #include<stdio.h> #include<conio.h> main() { float i; for (i=1; i<=10; i+= 0.5) printf("\n%g", i); getch(); return 0; } El siguiente ejemplo imprime las letras de abecedario en orden inverso. /********** Abecedario reversa **********/ #include<stdio.h> #include<conio.h> main() { char car; for (car='z'; car>='a';car--) printf("\t%c", car); getch(); return 0; } El ejemplo siguiente indica como realizar un bucle infinito. Para salir de un bucle infinito tiene que pulsar las teclas ctrl+c. for ( ; ; ) Sentencias; Como aplicación de la sentencia for vamos a imprimir un tablero de ajedrez en el que las casillas blancas se simbolizaran con una B y las negras con una N. Así mismo, el programa deberá marcar con * las casillas a las que se pueden mover un alfil desde una posición dada.

La solución será similar a la siguiente: Posición del alfil: Fila 3 Columna 4 B * B N B * B N N B * B * B N B B N B * B N B N N B * B * B N B B * B N B * B N * B N B N B * B B N B N B N B * N B N B N B N B Desarrollo del programa:

Primero definimos las variables que vamos a utilizar en los cálculos. Int falfil, calfil; //posición inicial del alfil. Int fila, columna; //posición actual del alfil.

Leer la fila y la columna en la que se coloca el alfil. Printf (“Posición del alfil (fila, columna): “); Scanf (“%d %d,&falfil,&calfil);

Partiendo de la fila 1, columna1 y recorriendo el tablero por filas, For(fila=1;fila<=8; fila++) { For (columna=1; columna<=8;columna++) { //Pintar el tablero de ajedrez } Printf(“\n”); // cambiar de fila }

Imprimir un *, una B o una N dependiendo de las condiciones espeficadas a continuación:

Imprimir un * si se cumple, que la suma o diferencia de la fila y columna actuales coincide con la suma o diferencia de la fila y columna donde se coloca el alfil.

Imprimir una B si se cumple que la fila más columnas actuales es par.

Imprimir una N si se cumple que la fila más columnas actuales es impar. //Pintar el tablero de ajedrez if ((fila + columna == falfil + calfil)||(fila - columna == falfil - calfil)) printf("* "); else if ((fila + columna ) %2 ==0) printf("B "); else printf("N ");

El programa completo se muestra a continuación. /********** Tablero de ajedrez **********/ #include<stdio.h> #include<conio.h> main() { Clrscr(); int falfil, calfil; //Posición del alfil int fila, columna; //Posición actual printf("Posicion del alfil(fila, columna): "); scanf("%d %d", &falfil, &calfil); printf("\n"); //Dejar una línea en blanco //Pintar el tablero de ajedrez for(fila=1; fila<=8; fila++) { for(columna=1; columna <=8; columna++) { if ((fila + columna == falfil + calfil)||(fila - columna == falfil - calfil)) printf("* "); else if ((fila + columna) %2 ==0) printf("B ");

else printf("N "); } printf("\n"); //Cambiar de fila } getch(); return 0; } Otro ejemplo es: Hallar la sumatoria de: 2! + 4! + 6! + 8! + ... #include <stdio.h> #include <conio.h> int facto (int x) { Clrscr(); int f=1; for (int i=1;i<=x;i++) {f=f*i;} return (f); } int main () { int n, serie=2, suma=0; printf ("Inserte cantidad de terminos a generar: "); scanf ("%d",&n); for (int i=1;i<=n;i++) { printf ("%d! + ", serie); suma=suma+(facto(serie)); serie=serie+2; } printf (" = %d",suma); getch(); }