|
|
| Contenidos > 10.3
Repetitiva para en pseudocódigo |
|
En
pseudocódigo,
para escribir una instrucción
repetitiva para
se utiliza la sintaxis:
para
<variable> ←
<valor_inicial> hasta
<valor_final>
[ incremento
<valor_incremento> ] hacer
<bloque_de_instrucciones>
fin_para
|
En una instrucción repetitiva para,
siempre se utiliza una <variable>
a la que se debe asignar un <valor_inicial>.
En cada iteración
del bucle,
al valor de la <variable>
se le suma el <valor_incremento>
y, cuando la <variable>
supera el <valor_final>,
el bucle finaliza.
En consecuencia, cuando el flujo
de un algoritmo llega a un bucle para,
en primer lugar, se asigna el <valor_inicial>
a la <variable>
y, a partir de ese instante, existen dos posibilidades:
- Si el valor de
la <variable>
es mayor que el <valor_final>,
entonces no se ejecuta el bloque de instrucciones, y el bucle para
finaliza sin realizar ninguna iteración.
- Si el valor de
la <variable>
es menor o igual que el <valor_final>,
entonces, se ejecuta el bloque de instrucciones y, después,
se le suma el <valor_incremento>
a la <variable>,
volviéndose, de nuevo, a comparar el valor de la <variable>
con el <valor_final>.
Y así sucesivamente, hasta que, el valor de la <variable>
sea mayor que el <valor_final>.
En resumen, una instrucción repetitiva
para
permite ejecutar, repetidamente, un bloque de instrucciones, en base a
un valor inicial y a un valor final.
El bucle para
es ideal usarlo cuando, de antemano, ya se sabe el número de
veces (iteraciones) que tiene que ejecutarse un determinado bloque de
instrucciones.
El bucle para
es una variante del bucle mientras
y, al igual que éste, puede iterar cero o más
veces. Sin embargo, el bucle para
sólo se suele usar cuando se conoce el número
exacto de
veces que tiene que iterar el bucle. Éste es el caso del
problema planteado en el ejemplo
del apartado 10.1.1 Variable contador,
en el cual, se sabe de antemano
que el bucle tiene que iterar, exactamente, diez veces.
Ejemplo
1: Por tanto, dicho problema,
se puede resolver con una instrucción repetitiva para
de la siguiente forma:
algoritmo
Numeros_del_1_al_10
variables
entero
contador
inicio
para
contador ←
1 hasta 10 incremento 1 hacer
escribir( contador )
fin_para
fin |
Ejemplo 2:
Cuando el incremento es 1, se puede omitir la palabra reservada incremento,
y su valor.
algoritmo
Numeros_del_1_al_10
variables
entero
contador
inicio
/*
Al no aparecer el valor del incremento,
se entiende que es
1. */
para
contador ←
1 hasta 10 hacer
escribir( contador )
fin_para
fin |
La traza
de ambos algoritmos es la misma:
Secuencia: |
Acción
(instrucción): |
Valor
de:
contador |
| 1 |
contador ←
1 |
1 |
| 2 |
(Comprobar
si contador
es menor o igual que 10
) |
1 |
|
contador
sí es menor o igual que 10.
Inicio de la iteración 1. |
|
| 3 |
escribir( contador ) |
1 |
|
Fin
de la iteración 1. |
|
| 4 |
(Sumar
a contador
el valor 1 ) |
2 |
| 5 |
(Comprobar
si contador
es menor o igual que 10
) |
2 |
|
contador
sí es menor o igual que 10.
Inicio de la iteración 2. |
|
| 6 |
escribir( contador ) |
2 |
|
Fin
de la iteración 2. |
|
| ... |
|
|
| n-3 |
(Comprobar
si contador
es menor o igual que 10
) |
10 |
|
contador
sí es menor o igual que 10.
Inicio de la iteración 10. |
|
| n-2 |
escribir( contador ) |
10 |
|
Fin
de la iteración 10. |
|
| n-1 |
(Sumar
a contador
el valor 1 ) |
11 |
| n |
(Comprobar
si contador
es menor o igual que 10
) |
11 |
|
contador no
es menor o igual que 10.
El bucle finaliza después de 10 iteraciones. |
|
Figura. Traza
de los ejemplos 1 y 2.
Explicación de la traza:
- Primeramente, se
le asigna el valor 1
a contador
(acción 1).
- A
continuación, se comprueba si contador
es menor o igual que 10
(acción 2) y, puesto que esto es verdadero, se
ejecuta el bloque de instrucciones del bucle para
(una sola instrucción en este caso).
- Así
pues, se muestra por pantalla el valor de contador
(acción 3).
- Después,
se incrementa en 1
el valor de la variable contador
(acción 4).
- Posteriormente,
se vuelve a comprobar si contador
es menor o igual que 10
(acción 5).
- Y así
sucesivamente, mientras que, el valor de contador
sea menor o igual que 10,
o dicho de otro modo, hasta que, el valor de contador
sea mayor que 10.
- En este
algoritmo, el bloque de instrucciones del bucle para
se ejecuta diez veces (iteraciones).
Ejemplo 3: Para
resolver el problema del ejemplo del apartado 10.1.2 Cambios en un bucle mientras,
utilizando un bucle para,
debe utilizarse un incremento negativo.
algoritmo
Numeros_del_10_al_1
variables
entero
contador
inicio
para
contador ←
10 hasta 1 incremento -1 hacer
escribir( contador )
fin_para
fin |
En este algoritmo, el <valor_inicial>
y el <valor_final>
son el 10 y
el 1,
respectivamente, al revés que en el algoritmo anterior. De
manera que, el bucle iterará, hasta que, el valor de contador
sea menor que 1,
o dicho de otro modo, mientras que, el valor de contador
sea mayor o igual que 1.
Ejemplo
4: Por otra parte,
también es posible omitir la palabra reservada incremento
y su valor, entendiéndose, en ese caso, que es -1, ya que, el <valor_inicial>
es mayor que el <valor_final>
y, por tanto, sólo es razonable un incremento negativo.
algoritmo
Numeros_del_10_al_1
variables
entero
contador
inicio
/*
Al no aparecer el valor del incremento,
se entiende que es
-1. */
para
contador ←
10 hasta 1 hacer
escribir( contador )
fin_para
fin |
Para los casos en que el incremento es negativo, también se
puede utilizar la sintaxis:
para
<variable> ←
<valor_inicial> hasta
<valor_final>
[ decremento
<valor_decremento> ] hacer
<bloque_de_instrucciones>
fin_para
/*
En vez de "incremento", se utiliza "decremento". */
|
Ejemplo 5: Así,
podemos escribir:
algoritmo
Numeros_del_10_al_1
variables
entero
contador
inicio
para
contador ←
10 hasta
1 decremento
1
hacer
escribir( contador )
fin_para
fin |
Por consiguiente, la sintaxis completa de una instrucción
repetitiva para
es:
para
<variable> ←
<valor_inicial> hasta
<valor_final>
[ incremento
<valor_incremento> |
decremento
<valor_decremento> ] hacer
<bloque_de_instrucciones>
fin_para
|
El carácter tubería ( |
) se utiliza para indicar que, o bien se escribe
incremento
<valor_incremento>
o bien se escribe
decremento
<valor_decremento>
pero, no ambos.
|
|
|
|
|
