Transcript Clase5

CI2125 TEORIA
semana 5
• Estructuras de Iteracion (Repetitivas )
• while , for,, do-while
• Comparación
Recordemos: Estructura de programas - Estilo en C
/* programa.c
Lee dos numeros enteros y los imprime */
#include <stdio.h>
Comentarios
Archivos cabeceras
La función main
void main()
Cuerpo
{
int n1, n2;
/* Pre Cond: numeros tipo entero */
printf(“Introducir dos enteros: \n”);
scanf(“%d %d \n”, &n1, &n2);
/* Post: imprime en pantalla dos numeros */
printf(“Numeros enteros: %d y %d\n”,n1,n2);
}
Encabezamiento
Declaración
variables locales
Sentencias
Estructura Algorítmica: ITERACION
REPETITIVA
• Operaciones que se deben ejecutar
varias veces
• Los datos varían, cada vez
F
C
• Todo ciclo debe terminar, luego de
repetirse un numero finito de veces
V
A1
A2
• Debe haber una acción de PARADA o
Fin del Ciclo
• En cada iteración, se evalúan las
condiciones para decidir si se debe
seguir o se debe detener
• La condición debe ser dependiente
con la acción de PARADA
Estructura Algorítmica: ITERACION
MIENTRAS
Cl  ValorIni
Se usa cuando:
No podemos establecer
de antemano el numero
de veces en que se va a
repetir el ciclo
F
CI
V
Proceso
Cl  Modifica CI
Las veces en que se
ejecute depende de una
de las acciones dentro
del ciclo, que modifica la
condición
Estructura Algorítmica: ITERACION
MIENTRAS
Cl  ValorIni
En Lenguaje C:
F
CI
V
Proceso
Cl  Modifica CI
condicion = ValorIni;
while ( condicion )
{
sentencia1;
sentencia2;
….
sent_modifica_condicion;
}
Estructura Algorítmica: ITERACION
MIENTRAS ( while )
Problema: Leer los pagos efectuados en el mes, obtener la suma total de los mismos.
Se deben leer un numero no determinado de
Pagos Pi, en variable de tipo real, que
representa el pago “i-esimo”.
Asumiremos que se ingresara el valor cero
como ultimo dato, es decir cuando Pi=0, para
indicar que no hay mas pagos.
A medida que vamos leyendo los pagos,
debemos ir acumulando en una variable la
suma de los pagos
SumaP = 0
Pi
Pi != 0
F
V
SumaP = SumaP + Pi
SumaP = SumaP + Pi
Debo inicializar SumaP a cero para asegurar,
que comienza la suma con el primer pago
Usare la estructura Repetitiva “mientras” haya
pagos que leer, ósea, Pi no sea igual a cero
Entradas: real Pi
Salida: real SumaP
Inicio
1
Pi
SumaP
Fin
2
Estructura Algorítmica: ITERACION
MIENTRAS ( while )
Problema: Leer los pagos efectuados en el mes, obtener la suma total de los mismos.
Verificar !, con datos
3
#include <stdio.h>
int main()
{
float Pi, SumaP = 0;
scanf(“ %f ”,&Pi);
while ( Pi != 0 )
{
SumaP = SumaP + Pi;
scanf(“ %f ”,&Pi);
}
printf( “Total de Pagos: %f \n", SumaP );
}
4
Estructura Algorítmica: ITERACION
Cuando se conoce el No de Repeticiones
cont  VI
F
cont ( <,>,<=,>=) VF
V
Se usa cuando:
Se conoce de antemano el
numero de veces en que se
va a repetir el ciclo
El numero de veces en que
se repite el ciclo NO
depende de las acciones
Proceso
Se debe tener un contador
para determinar cuando se
alcanzan las repeticiones
deseadas
cont  cont (+,-) Inc
Y un incremento o
decremento para modificar
el contador
Estructura Algorítmica: ITERACION
MIENTRAS - for
En Lenguaje C:
for ( cont = VI; cont (<,>,<=,>=)VF, cont = cont(+,-) Inc )
{
sentencia1;
….;
}
Ejemplos:
/* Imprime los números del 1 al 100 */
for ( cont=1; cont <=100; cont++)
printf( "Ya voy por el %i \n", cont );
/* Suma los primeros 20 numeros enteros, de dos en dos */
acumulador = 0;
for ( cont=0; cont <=20; cont=cont+2)
acumulador += cont;
printf( “La suma acumulada es %i \n", acumulador );
Estructura Algorítmica: ITERACION (Repetitiva)
En C:
while , for
Ejemplo: Comparando while y for
cont = 0;
while ( condición )
{
accion1;
accion2;
….
cont ++;
}
for ( cont=0; condición; cont++)
{
accion1;
accion2;
….
}
Estructura Algorítmica: ITERACION (Repetitiva)
En C:
sintaxis del for
for (valores iniciales; condicion; incrementos)
{
accion1;
accion2;
….
}
valores iniciales:
pueden haber mas de una variable inicial
incrementos:
Se definen los incrementos o decrementos de las
variables iniciales
Estructura Algorítmica: ITERACION (Repetitiva)
En C:
for (ejemplo)
#include <stdio.h>
void main()
{
int i, j;
for( i=0, j=5 ; i<10 ; i++, j=j+5 )
{
printf( "Hola " );
printf( "Esta es la línea %i\n", i );
printf( "j vale = %i\n", j );
}
}
Imprime:
Hola Esta es la línea 0
j vale = 5
Hola Esta es la línea 1
j vale = 10
Hola Esta es la línea 2
j vale = 15
….
Hola Esta es la línea 9
j vale = 50
Estructura Algorítmica: ITERACION
MIENTRAS ( for)
Problema: Leer los salarios de 15 Profesores de un colegio , obtener el total de la nomina
En este caso se conocen que son 15
profesores por lo que la estructura es un “for”
Inicio
Nomina = 0
Entrada: Leer salario tipo real, Sal
Salida: Imprimir Nomina, Nomina
cont = 1
PROF= 15
Constante: 15 profesores
cont < PROF
Proceso, leer en ciclo “for” los 15 salarios y
acumularlos en variable Nomina, con la que
vamos calculando la Nomina del Colegio
F
V
Sal
Nomina = Nomina + Sal
Nomina
1
Fin
2
Estructura Algorítmica: ITERACION
MIENTRAS ( for )
Problema: Leer los salarios de 15 Profesores de un colegio , obtener el total de la nomina
Verificar !, con datos
3
#include <stdio.h>
#define PROF 15
int main()
{
float Sal, Nomina = 0;
int cont;
for ( cont =1; cont< PROF; cont++ )
{
printf( “Ingrese el salario del Profesor No: %d:\n“,cont);
scanf(“ %f ”,&Sal);
Nomina += Sal;
}
}
printf( “Total de Nomina: %f \n", Nomina );
4
Estructura Algorítmica: ITERACION ( for )
Ejemplo: Imprime conversión Fahrenheit a Celsius, F = 0, 20, 40,..., 300
FARI =0
FARF=300
SALTO=20
Far = FARI
F
Far <= FARF
V
Cel = (5.0/9.0)*(Far-32.0)
Far, Cel
Far = Far + Salto
Estructura Algorítmica: ITERACION ( for )
Ejemplo: Imprime conversión Fahrenheit a Celsius, F = 0, 20, 40,..., 300
/*Programa que imprime la tabla de conversión de
Fahrenheit a Celsius para F = 0, 20, 40,..., 300 */
#include <stdio.h>
#define FARI 0
#define FARF 300
#define SALTO
20
void main()
{
float Far, Cel;
Far = FARI;
for(Far = FARI; Far <= FARF; Far +=SALTO)
{
Cel = (5.0/9.0) * (Far - 32.0);
printf("%4.0f F -> %6.1f C\n", Far, Cel);
} /* fin del for */
} /* fin del main */
Estructura Algorítmica: ITERACION (Repetitiva) while
Ejemplo: Uso de ciclos “whiles” anidados. Imprime Tabla de multiplicación.
#include <stdio.h>
void main()
{
int i=1,j;
while(i <= 12) /* imprime cada nueva linea */
{
j = 1;
while(j <= 12) /* imprime 12 productos por linea */
{
printf(" %3d",i*j);
j++;
}
printf("\n"); /* fin de línea, salto de linea */
i++;
}
}
Estructura Algorítmica: ITERACION (Repetitiva) while
Ejemplo: Uso de ciclos “whiles” anidados.
Imprime Tabla de multiplicación, del 1 al 12.
1
2
3
4
5
6
7
8
9
10
11
12
2
4
6
8
10
12
14
16
18
20
22
24
3
6
9
12
15
18
21
24
27
30
33
36
4
8
12
16
20
24
28
32
36
40
44
48
5
10
15
20
25
30
35
40
45
50
55
60
6
12
18
24
30
36
42
48
54
60
66
72
7
14
21
28
35
42
49
56
63
70
77
84
8
16
24
32
40
48
56
64
72
80
88
96
9 10 11 12
18 20 22 24
27 30 33 36
36 40 44 48
45 50 55 60
54 60 66 72
63 70 77 84
72 80 88 96
81 90 99 108
90 100 110 120
99 110 121 132
108 120 132 144
Estructura Algorítmica: ITERACION
HACER – MIENTRAS ( do –while )
A diferencia de las estructuras
for, while, las condiciones se
evalúan al final del ciclo
A1
V
A2
Esto implica que el conjunto
de acciones se ejecuta al
menos una vez sin importar la
condición
C
Se utiliza principalmente para
validar los datos de entrada
F
La condición cambia de
acuerdo a la modificación de
la misma en una acción
Estructura Algorítmica: ITERACION
HACER – MIENTRAS ( do –while )
En Lenguaje C:
Proceso
Modifica C
V
C
F
do
{
sentencia1;
sentencia2;
….
sent_modifica_condicion;
} while ( condicion );
Estructura Algorítmica: ITERACION (Repetitiva)
En C:
do - while
/* Programa que pide al usuario un número entero entre 1 y 10.
Se continúa pidiendo el valor hasta que cumpla la condición */
#include <stdio.h>
void main()
{
int n, error;
do {
printf("Ingrese un número entero entre 1 y 10: ");
scanf("%d", &n);
if (error = (n < 1 || n > 10))
printf("\n ERROR: Intentelo nuevamente!! \n");
} while( error );
/* ahora puedo procesar el valor ingresado sabiendo que es correcto. */
/* sigo con el proceso siguiente del programa
…
Estructura Algorítmica: ITERACION (Repetitiva)
En C:
for (ejemplo)
/* Programa que calcula el factorial de n, n! */
#include <stdio.h>
void main()
{
/* declaracion de variables */
int i;
int factorial=1;
/* Entrada, Pre-condicion: n numero entero positivo */
printf( “Introduzca un numero entero positivo\n");
scanf(“%d”, &n);
/* proceso: calculo del factorial , n! = n.(n-1).(n-2)…(n-(n-1)) */
for( i=n ; i>=1 ; i-- )
factorial = factorial*i;
/* salida, Post-condicon: imprimir el factorial de n */
printf( “Factorial de n %i es %i \n", n, factorial );
}