Ejercicios de Estructuras Repetitivas

Ejemplos resueltos de for / while ...

1. Elaborar un programa que muestre los numeros pares comprendidos entre 10 y 20 inclusive

#include<stdio.h>
main()
{
int i;
printf("Los numeros pares entre 10 y 20 inclusive son: \n");
for(i=10;i<=20;i=i+2)
printf("%d \n",i);
return 0;
}

2. Elaborar un programa que muestre los numeros pares comprendidos entre 20 y 10 inclusive
(orden descendente).

# include<stdio.h>
main()
{
int i;
printf("Los numeros pares entre 20 y 10 inclusive son: \n");
for(i=20;i>=10;i=i-2)
printf("%d \n",i);
return 0;
}

3. Mostrar la tabla de caracteres ASCII a partir del Código 32 (el espacio en blanco) hasta el
Código 164 (o sea la ñ) sin incluir las minúsculas (rango del 97 al 122)

# include<stdio.h>
main()
{
int i;
printf("Los Caracteres ASCII son: \n");
for(i=32;i<=164;i++) {
if(i<97 || i>122)
printf("%c %d \t",i,i);
}
return 0;
}

4. Elaborar un programa que calcule la suma de los números multiplos de 3 a partir del número 9 y
finaliza en el número 45, no deben incluirse en la suma los números comprendidos entre 21 y 27.

# include<stdio.h>
main()
{
int i,s;
s=0;
printf("Suma de los multiplos de 3: \n");
for(i=9;i<=45;i+=3) {
if(i<21 || i>27)
s = s + i;
}
printf("la suma es %d \n",s);
return 0;
}

5. Elaborar un programa que calcule la suma de los números multiplos de 3 y 7 a partir del número
9 y finaliza en el numero 45, no deben incluirse en la suma los números comprendidos entre 21 y
27.

# include<stdio.h>
main()
{
int i,m3,m7,s;
m3=0;
m7=0;
printf("Suma de los múltiplos de 3 y 7: \n");
for(i=9;i<=45;i++) {
if(i<21 || i>27) {
if (i%3 == 0) { m3 +=i;}
if (i%7 == 0) { m7 +=i;}
}
}
s = m3 + m7;
printf("la suma es %d \n",s);
return 0;
}

6. Generalizar el caso:
Elaborar un programa que calcule la suma de los números multiplos de M y N a partir del número X
y finaliza en el numero Y, no deben incluirse en la suma los números comprendidos entre A y B.
use scanf para ingresar los datos a las variables M,N,X,Y,A y B

# include<stdio.h>
main()
{
int m,n,x,y,a,b;
int i,mm,mn,s;
mm=0;
mn=0;

printf("Ingrese los valores que representan a los multiplos \n");

scanf("%d %d",m,n);

printf("Ingrese el rango desde-hasta \n");

scanf("%d %d",x,y);

printf("Ingrese el rango de exclusion desde-hasta \n");

scanf("%d %d",a,b);

printf("Suma de los múltiplos de %d y %d: \n",m,n);

for(i=x;i<=y;i++) {
if(i<a || i>b) {
if (i%3 == 0) { mm +=i;}
if (i%7 == 0) { mn +=i;}
}
}
s = mm + mn;
printf("la suma es %d \n",s);
return 0;
}

OTROS PROGRAMAS COMPLEMENTARIOS

QUE PUEDEN AYUDARNOS EN LAS ESTRUCTURAS REPETITIVAS
PROGRAMA QUE DEMUESTRA EL USO DE getchar()
esta funcion permite ingresar varios caracteres y da por terminado el ingreso cuando se presiona la
tecla ENTER o sea \n - getchar( ) esta definida en "stdio.h"
Tengase en cuenta que solo se memorizará la primera tecla presionada

#include <stdio.h>
main()
{
int i;
char ch;
printf("Ingresar un texto : \n");
ch = getchar();
printf("\n la primera tecla pulsada fue %c \n",ch);
return 0;
}

EJEMPLO DE COMO SE DEBE INGRESAR UN CARACTER USANDO getche()

#include <stdio.h>
#include <conio.h>
/* cuando quieras ingresar un caracter solamente puedes
la funcion usar getche()*/

main()
{
char ch;
printf("Ingrese un caracter : ");
ch = getche();
printf("\nIngresaste : %c \n", ch);
return 0;
}
// - observa que la tecla pulsada es la que se mostrará
// - getche() esta declarada en conio.h por eso debemos incluir
// la linea #include <conio.h>
// - tambien debemos incluir stdio.h porque alli
// se encuentra declarada printf

PROGRAMA PARA INGRESAR VARIOS CARACTERES USANDO getche()

el programa continuara ingresando texto hasta que se presione k

#include <stdio.h>
#include <conio.h>
main()
{
int i;
char ch;
i = 0;
printf("Ingresar caracteres hasta presionar k : \n");
while(i == 0) {
ch = getche();
if(ch == 'k') i=1;
}
printf("\n terminaste \n");
printf("\n la ultima tecla presionada fue %c \n",ch);
return 0;
}

Ejercicios Propuestos con For / While

los siguientes ejercicios deberán ser resueltos por partida doble: una
solución con "for", otra con "while"
1. Determinar el numero mayor de 10 numeros ingresados

2. Determinar el numero menor de 12 numeros ingresados

3. Calcular el factorial de un número dado (El programa solo admite datos entre 3 y 8)

4. Implemente el siguiente juego: el programa seleccionará un número aleatorio entre 0 y 100 y el

jugador debe acertarlo. En cada intento el jugador propondrá una solución y se le informará si el
número a acertar es menor o mayor que el propuesto. El juego termina cuando se acierte la cifra o
halla realizado un máximo de 12 intentos en cuyo caso se le mostrará al jugador la calificación
obtenida según la siguiente tabla:

Número de intentos Categoría

1-3 Suertudo
4-6 Genio
7 No está mal
8 Se puede mejorar
>= 9 Que pasa amigo

5. Realizar un programa que cuente las vocales cuando se ingresa una cadena de textos con
getchar()

6. Idem al anterior pero contar las consonantes

Estructura repetitiva while.
Representación gráfica de la estructura while:

No debemos confundir la representación gráfica de la estructura repetitiva while

(Mientras) con la estructura condicional if (Si)
Funcionamiento: En primer lugar se verifica la condición, si la misma resulta
verdadera se ejecutan las operaciones que indicamos por la rama del Verdadero.
A la rama del verdadero la graficamos en la parte inferior de la condición. Una
línea al final del bloque de repetición la conecta con la parte superior de la
estructura repetitiva.
En caso que la condición sea Falsa continúa por la rama del Falso y sale de la
estructura repetitiva para continuar con la ejecución del algoritmo.
El bloque se repite MIENTRAS la condición sea Verdadera.
Importante: Si la condición siempre retorna verdadero estamos en presencia de
un ciclo repetitivo infinito. Dicha situación es un error de programación, nunca
finalizará el programa.

Problema 1:

Realizar un programa que imprima en pantalla los números del 1 al 100.

Sin conocer las estructuras repetitivas podemos resolver el problema empleando
una estructura secuencial. Inicializamos una variable con el valor 1, luego
imprimimos la variable, incrementamos nuevamente la variable y así
sucesivamente.

Diagrama de flujo:
Si continuamos con el diagrama no nos alcanzarían las próximas 5 páginas para
finalizarlo. Emplear una estructura secuencial para resolver este problema produce
un diagrama de flujo y un programa en Java muy largo.
Ahora veamos la solución empleando una estructura repetitiva while:
Es muy importante analizar este diagrama:
La primera operación inicializa la variable x en 1, seguidamente comienza la
estructura repetitiva while y disponemos la siguiente condición ( x <= 100), se lee
MIENTRAS la variable x sea menor o igual a 100.
Al ejecutarse la condición retorna VERDADERO porque el contenido de x (1) es
menor o igual a 100. Al ser la condición verdadera se ejecuta el bloque de
instrucciones que contiene la estructura while. El bloque de instrucciones contiene
una salida y una operación.
Se imprime el contenido de x, y seguidamente se incrementa la variable x en uno.
La operación x=x + 1 se lee como "en la variable x se guarda el contenido de x
más 1". Es decir, si x contiene 1 luego de ejecutarse esta operación se
almacenará en x un 2.
Al finalizar el bloque de instrucciones que contiene la estructura repetitiva se
verifica nuevamente la condición de la estructura repetitiva y se repite el proceso
explicado anteriormente.
Mientras la condición retorne verdadero se ejecuta el bloque de instrucciones; al
retornar falso la verificación de la condición se sale de la estructura repetitiva y
continua el algoritmo, en este caso finaliza el programa.
Lo más difícil es la definición de la condición de la estructura while y qué bloque de
instrucciones se van a repetir. Observar que si, por ejemplo, disponemos la
condición x >=100 ( si x es mayor o igual a 100) no provoca ningún error sintáctico
pero estamos en presencia de un error lógico porque al evaluarse por primera vez
la condición retorna falso y no se ejecuta el bloque de instrucciones que
queríamos repetir 100 veces.
No existe una RECETA para definir una condición de una estructura repetitiva,
sino que se logra con una práctica continua solucionando problemas.
Una vez planteado el diagrama debemos verificar si el mismo es una solución
válida al problema (en este caso se debe imprimir los números del 1 al 100 en
pantalla), para ello podemos hacer un seguimiento del flujo del diagrama y los
valores que toman las variables a lo largo de la ejecución:
x
1
2
3
4
.
.
100
101 Cuando x vale 101 la condición de la estructura
repetitiva retorna falso,
en este caso finaliza el diagrama.
Importante: Podemos observar que el bloque repetitivo puede no ejecutarse
ninguna vez si la condición retorna falso la primera vez.
La variable x debe estar inicializada con algún valor antes que se ejecute la
operación x=x + 1 en caso de no estar inicializada aparece un error de
compilación.

Programa:

public class EstructuraRepetitivaWhile1 {

public static void main(String[] ar) {
int x;
x=1;
while (x<=100) {
System.out.print(x);
System.out.print(" - ");
x = x + 1;
}
}
}
Importante:Como podemos observar no hemos creado un objeto de la clase
Scanner. Esto debido a que en este programa no hay que ingresar datos por
teclado. Para las salidas utilizamos la función print, que se encuentra creada por
defecto en cualquier programa que codifiquemos en Java.
Recordemos que un problema no estará 100% solucionado si no hacemos el
programa en Java que muestre los resultados buscados.
Probemos algunas modificaciones de este programa y veamos que cambios se
deberían hacer para:
1 - Imprimir los números del 1 al 500.
2 - Imprimir los números del 50 al 100.
3 - Imprimir los números del -50 al 0.
4 - Imprimir los números del 2 al 100 pero de 2 en 2
(2,4,6,8 ....100).
Respuestas:
1 - Debemos cambiar la condición del while con x<=500.
2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condición x<=0.
4 - Inicializar a x con el valor 2 y dentro del bloque repetitivo
incrementar a x en 2
( x = x + 2 ).

Problema 2:

Escribir un programa que solicite la carga de un valor positivo y nos muestre

desde 1 hasta el valor ingresado de uno en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al 30.
Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la posterior
codificación en Java de los siguientes problemas, en varios problemas se
presentan otras situaciones no vistas en el ejercicio anterior.

Diagrama de flujo:
Podemos observar que se ingresa por teclado la variable n. El operador puede
cargar cualquier valor.
Si el operador carga 10 el bloque repetitivo se ejecutará 10 veces, ya que la
condición es “Mientras x<=n ”, es decir “mientras x sea menor o igual a 10”; pues x
comienza en uno y se incrementa en uno cada vez que se ejecuta el bloque
repetitivo.
A la prueba del diagrama la podemos realizar dándole valores a las variables; por
ejemplo, si ingresamos 5 el seguimiento es el siguiente:
n x
5 1 (Se imprime el contenido de x)
2 " "
3 " "
4 " "
5 " "
6 (Sale del while porque 6 no es menor o igual a 5)

Programa:

import java.util.Scanner;
 public class EstructuraRepetitivaWhile2 {
public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x;
System.out.print("Ingrese el valor final:");
n=teclado.nextInt();
x=1;
while (x<=n) {
System.out.print(x);
System.out.print(" - ");
x = x + 1;
}
}
}
Los nombres de las variables n y x pueden ser palabras o letras (como en este
caso)
La variable x recibe el nombre de CONTADOR. Un contador es un tipo especial de
variable que se incrementa o decrementa con valores constantes durante la
ejecución del programa.
El contador x nos indica en cada momento la cantidad de valores impresos en
pantalla.

Problema 3:

Desarrollar un programa que permita la carga de 10 valores por teclado y nos

muestre posteriormente la suma de los valores ingresados y su promedio.

Diagrama de flujo:
En este problema, a semejanza de los anteriores, llevamos un CONTADOR
llamado x que nos sirve para contar las vueltas que debe repetir el while.
También aparece el concepto de ACUMULADOR (un acumulador es un tipo
especial de variable que se incrementa o decrementa con valores variables
durante la ejecución del programa)
Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que se repita la
estructura repetitiva, la variable suma se incrementa con el contenido ingresado en
la variable valor.
La prueba del diagrama se realiza dándole valores a las variables:
valor suma x promedio
0 0
(Antes de entrar a la estructura repetitiva estos son los
valores).
5 5 1
16 21 2
7 28 3
10 38 4
2 40 5
20 60 6
5 65 7
5 70 8
10 80 9
2 82 10
8 90 11
9

Este es un seguimiento del diagrama planteado. Los números que toma la variable
valor dependerá de qué cifras cargue el operador durante la ejecución del
programa.
El promedio se calcula al salir de la estructura repetitiva (es decir primero
sumamos los 10 valores ingresados y luego los dividimos por 10)
Hay que tener en cuenta que cuando en la variable valor se carga el primer valor
(en este ejemplo 5) al cargarse el segundo valor (16) el valor anterior 5 se pierde,
por ello la necesidad de ir almacenando en la variable suma los valores
ingresados.

Programa:

import java.util.Scanner;

public class EstructuraRepetitivaWhile3 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int x,suma,valor,promedio;
x=1;
suma=0;
while (x<=10) {
 System.out.print("Ingrese un valor:");
valor=teclado.nextInt();
suma=suma+valor;
x=x+1;
}
promedio=suma/10;
System.out.print("La suma de los 10 valores es:");
System.out.println(suma);
System.out.print("El promedio es:");
System.out.print(promedio);
}
}

Problema 4:

Una planta que fabrica perfiles de hierro posee un lote de n piezas.

Confeccionar un programa que pida ingresar por teclado la cantidad de piezas a
procesar y luego ingrese la longitud de cada perfil; sabiendo que la pieza cuya
longitud esté comprendida en el rango de 1,20 y 1,30 son aptas. Imprimir por
pantalla la cantidad de piezas aptas que hay en el lote.

Diagrama de flujo:
Podemos observar que dentro de una estructura repetitiva puede haber
estructuras condicionales (inclusive puede haber otras estructuras repetitivas que
veremos más adelante)
En este problema hay que cargar inicialmente la cantidad de piezas a ingresar
( n ), seguidamente se cargan n valores de largos de piezas.
Cada vez que ingresamos un largo de pieza (largo) verificamos si es una medida
correcta (debe estar entre 1.20 y 1.30 el largo para que sea correcta), en caso de
ser correcta la CONTAMOS (incrementamos la variable cantidad en 1)
Al contador cantidad lo inicializamos en cero porque inicialmente no se ha cargado
ningún largo de medida.
Cuando salimos de la estructura repetitiva porque se han cargado n largos de
piezas mostramos por pantalla el contador cantidad (que representa la cantidad de
piezas aptas)
En este problema tenemos dos CONTADORES:
x (Cuenta la cantidad de piezas cargadas hasta el
momento)
cantidad (Cuenta los perfiles de hierro aptos)

Programa:

import java.util.Scanner;

public class EstructuraRepetitivaWhile4 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int x,cantidad,n;
float largo;
x=1;
cantidad=0;
System.out.print("Cuantas piezar procesará:");
n=teclado.nextInt();
while (x<=n) {
System.out.print("Ingrese la medida de la pieza:");
largo=teclado.nextFloat();
if (largo>=1.20 && largo<=1.30) {
cantidad = cantidad +1;
}
x=x + 1;
}
System.out.print("La cantidad de piezas aptas son:");
System.out.print(cantidad);
}
}
Problemas propuestos
Ha llegado la parte fundamental, que es el momento donde uno desarrolla
individualmente un algoritmo para la resolución de problemas.
El tiempo a dedicar a esta sección EJERCICIOS PROPUESTOS debe ser mucho
mayor que el empleado a la sección de EJERCICIOS RESUELTOS.
La experiencia dice que debemos dedicar el 80% del tiempo a la resolución
individual de problemas y el otro 20% al análisis y codificación de problemas ya
resueltos por otras personas.
Es de vital importancia para llegar a ser un buen PROGRAMADOR poder resolver
problemas en forma individual.

1. Escribir un programa que solicite ingresar 10 notas de alumnos y nos

informe cuántos tienen notas mayores o iguales a 7 y cuántos menores.
2. Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la
altura promedio de las personas.
3. En una empresa trabajan n empleados cuyos sueldos oscilan entre $100 y
$500, realizar un programa que lea los sueldos que cobra cada empleado e
informe cuántos empleados cobran entre $100 y $300 y cuántos cobran
más de $300. Además el programa deberá informar el importe que gasta la
empresa en sueldos al personal.
4. Realizar un programa que imprima 25 términos de la serie 11 - 22 - 33 - 44,
etc. (No se ingresan valores por teclado)
5. Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 -
16 - 24, etc.
6. Realizar un programa que permita cargar dos listas de 15 valores cada una.
Informar con un mensaje cual de las dos listas tiene un valor acumulado
mayor (mensajes "Lista 1 mayor", "Lista 2 mayor", "Listas iguales")
Tener en cuenta que puede haber dos o más estructuras repetitivas en un
algoritmo.
7. Desarrollar un programa que permita cargar n números enteros y luego nos
informe cuántos valores fueron pares y cuántos impares.
Emplear el operador “%” en la condición de la estructura condicional:
8. if (valor%2==0) //Si el if da verdadero luego es
par.

El algoritmo para calcular la división con Restas Sucesivas lo tengo así, espero que sea
lo que buscas:
Algoritmo TP3-2
Variables
Entero: A, B, CONT

Inicio
Escribir 'Ingrese nº Dividendo y Divisor'
Leer A, B
Si A>=B Entonces
CONT<-0
Mientras A>=B hacer
A<-A-B
CONT<-CONT+1
finmientras
Escribir 'Resultado:', CONT
sino
Escribir 'No se puede realizar la operación de división entera'
finsi
Fin

A es el dividendo; B el divisor; si se cumple la condición para dividir sólo números

enteros positivos, se va restando B a A en cada ciclo hasta que ya no sea posible y
obviamente el contador (CONT) es el cociente.

Capítulo 16:
 Estructuras iterativas. Estructura mientras.
Enlaces patrocinados Inglés en Canada y USA
Descuentos para Estudiantes Toronto, Vancouver, New York, Miami
sites.google.com/site/apren

Se llama Mientras a la estructura algorítmica que se ejecuta mientras la condición

evaluada resulte verdadera. Se evalúa la expresión booleana y, si es cierta, se ejecuta la
instrucción especificada, llamada el cuerpo del bucle. Entonces se vuelve a evaluar la
expresión booleana, y si todavía es cierta se ejecuta de nuevo el cuerpo. Este proceso de
evaluación de la expresión booleana y ejecución del cuerpo se repite mientras la
expresión sea cierta.

 Repetro - Databras Regime Especial Aduaneiro Repetro Databras

www.repetro.comEnlaces patrocinados

Cuando se hace falsa, finaliza la repetición. En la lección anterior iniciamos con

las estructuras repetitivas. La estructura While y la estructura Repeat, se conocen como
Iterativas. Se usan cuando no se conoce con anticipación el número de veces que se
ejecutará la acción.

La diferencia entre ambas es que la condición se sitúa al principio (Mientras) o al

final (Repetir) de la secuencia de instrucciones. Entonces, en el primero, el bucle continúa
mientras la condición es verdadera (la cual se comprueba antes de ejecutar la acción) y
en el segundo, el bucle continúa hasta que la condición se hace verdadera (la condición
se comprueba después de ejecutar la acción, es decir, se ejecutará al menos una vez).

La estructura Desde/Para suele utilizarse cuando se conoce con anterioridad el

número de veces que se ejecutará la acción y se le conoce como Estructura Repetitiva en
lugar de iterativa, para diferenciarla de las dos anteriores.

Las estructuras Mientras y Para/Desde suelen en ciertos casos, no realizar

ninguna iteración en el bucle, mientras que Repetir ejecutará el bucle al menos una vez.

Existe otro caso de estructura conocida como Salto (Goto), la cual no es muy
recomendable de usar ya que su uso dificulta la legibilidad de un programa y tiende a
confundir por el hecho de recurrir a numerosas etiquetas o números de línea.
 Observa en el flujograma, que se necesita una variable contadora (un índice), para
llevar la cuenta de las veces que entramos al cuerpo del ciclo. También es importante
notar que esta variable se inicializa antes de entrar al cuerpo del ciclo y dentro del cuerpo
se incrementa en una cantidad constante, por lo general en uno.

Esta variable a la vez, nos sirve para compararla con el valor dado en la condición,
cuando se cumple la condición, se sale del ciclo.

Representación pseudocodificada:

Español Inglés

Mientras <condición> While <condición> do

Acciones Acciones

Fin_mientras end_while

EJEMPLO:

Calcular la suma de los cuadrados de los primeros 100 números enteros y escribir
el resultado.

Solución.

Como recordarás, resolvimos este ejercicio en la lección anterior pero utilizando la

estructura Desde. Hoy lo haremos con la estructura Mientras.Que tendremos de
diferente?
 CENTINELAS Y BANDERAS.

Cuando no se conoce a priori el número de iteraciones que se van a realizar, el

ciclo puede ser controlado por centinelas.

CENTINELAS.

En un ciclo While controlado por tarea, la condición de While especifica que el

cuerpo del ciclo debe continuar ejecutándose mientras la tarea no haya sido completada.

En un ciclo controlado por centinela el usuario puede suspender la introducción de

datos cuando lo desee, introduciendo una señal adecuada llamada centinela. Un ciclo
Repetir controlado por centinela es cuando el usuario digita una letra para salir como por
ejemplo S o N para indicar si desea continuar o no. El bucle debe repetirse hasta que la
respuesta del usuario sea "n" o "N".
 Cuando una decisión toma los valores de -1 o algún posible valor que no esté
dentro del rango válido en un momento determinado, se le denomina centinela y su
función primordial es detener el proceso de entrada de datos en una corrida de programa.

Por ejemplo, si se tienen las calificaciones de un test (comprendida entre 0 y 100);

un valor centinela en esta lista puede ser -999, ya que nunca será una calificación válida y
cuando aparezca este valor se terminará de ejecutar el bucle.

Si la lista de datos son números positivos, un valor centinela puede ser un número
negativo. Los centinelas solamente pueden usarse con las estructuras Mientras y Repetir,
no con estructuras Desde/Para. ¿PODRÍAS DECIR POR QUÉ?

Ejemplo:

Suponga que debemos obtener la suma de los gastos que hicimos en nuestro
último viaje, pero no sabemos exactamente cuántos fueron.

Si definimos gasto1, gasto2, gasto3, ...., -1 donde gastoi: real es el gasto número i
y sumgas: real es el acumulador de gastos efectuados. -1 es el centinela de fin de datos.

Algoritmo:

Inicio

Sumgas . 0

Leer (gasto)

Mientras gasto <> -1 hacer

Sumgas . sumgas + gasto

Leer (gasto)

Fin_mientras

Escribir (sumgas)

Fin

BANDERAS.

Conocidas también como interruptores, switch, flags o conmutadores, son

variables que pueden tomar solamente dos valores durante la ejecución del programa, los
cuales pueden ser 0 ó 1, o bien los valores booleanos True o False. Se les suele llamar
interruptores porque cuando toman los valores 0 ó 1 están simulando un interruptor
abierto/cerrado o encendido/apagado.

Ejemplo 1:

Leer un número entero N y calcular el resultado de la siguiente serie: 1 - 1/2+ 1/3 -

1/4

+.... +/- 1/N.

Algoritmo:

Inicio

Serie . 0

I.1

Leer (N)

Band . "T"

Mientras I <= N hacer

Si band = "T" entonces

Serie . serie + (1/I)

Band . "F"

Sino

Serie . serie - (1/I)

Band . "T"

Fin_si

I¬I+1

Fin_mientras

Escribir (serie)
 Fin

Ejemplo 2.

Obtener suma de los términos de la serie: 2, 5, 7, 10, 12, 15, 17, .... 1800.

Sumser de tipo entero, es el acumulador de términos de la serie

Band de tipo carácter, es variable auxiliar que indica si al siguiente término de la

serie hay que sumarle 3 ó 2.

Algoritmo:

Inicio

I ¬2

Sumser ¬0

Band ¬T"

Mientras (I <= 1800) hacer

Sumser ¬sumser + I

Escribir (I)

Si band = "T" entonces

I ¬I + 3

Band ¬F"

Sino

I ¬I + 2

Band ¬T"

Fin_si

Fin_mientras

Escribir (sumser)
 Fin

Capítulo 17:

Estructuras iterativas. Estructura repetir.

Enlaces patrocinados Entrenamiento
Formacion y Certificacion de instructores, cursos y talleres
www.mdc1.com.mx

Se llama Repetir a la estructura algorítmica que se ejecuta un número definido de

veces hasta que la condición se torna verdadera:

 Maestrias a Distancia Maestrias y Postgrados Reconocidos A Nivel Mundial.

Informate Aqui!
www.LSBF.es/OnlineEnlaces patrocinados

Representación pseudocodificada :

Español Inglés

Repetir Repeat
 Acciones Acciones

Hasta que <condición> until <condición>

EJEMPLO:

Calcular la suma de los cuadrados de los primeros 100 números enteros y escribir
el resultado.

Solución.

Nuevamente resolveremos el ejercicio de las dos lecciones anteriores, ahora

utilizando la estructura Repetir.¿Podrás decir cuál será ahora la diferencia? Las reglas
para construcción de esta estructura usando Repetir, nos dicen que debemos declarar
una variable contador que debe inicializarse antes del ciclo e incrementarse dentro del
ciclo. A diferencia de la estructura Mientras, la condición ahora estará colocada al final del
bucle para que primero ejecutamos la instrucción y luego preguntamos si la condición se
cumple. Esto quiere decir, que en esta estructura el bucle se realizará por lo menos una
vez. También podrás observar que la condición está al revés, porque el bucle se repite
hasta que la condición se cumpla. En el bucle Mientras, la condición se evaluaba mientras
era cierta.
Capítulo 15:

Estructuras básicas.
Enlaces patrocinados Repetro - Databras
Regime Especial Aduaneiro Repetro Databras
www.repetro.com

Durante las siguientes lecciones estaremos estudiando tres estructuras básicas

que son:

Estructura Desde/Para

Estructura Mientras
 Estructura Repetir

En esta lección estudiaremos la forma general de la estructura Desde/Para, su

uso y ejemplos.

Estructura Desde/Para:

Se usa frecuentemente cuando se conoce de antemano el número de veces que

se ejecutarán las acciones de un bucle. Esta es una de sus características.

 Correo Gmail Gratis Abre tu Cuenta en Google. 7,3 GB de Capacidad y Accesible

Desde Móviles
Mail.Google.comEnlaces patrocinados

Representación pseudocodificada:

Español Inglés

Desde var = valor inicial hasta valor final hacer For var=valor inicial to valor final do

Acciones acciones

Fin_desde end_for

A la estructura Desde/Para se le conoce como Repetitiva. Para utilizar esta

estructura en algoritmos, debemos hacer uso de contadores y algunas veces de
acumuladores, cuyos conceptos se describen a continuación:

CONTADOR:

Un contador es una variable cuyo valor se incrementa o decrementa en una

cantidad constante cada vez que se produce un determinado suceso o acción. Los
contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle;
deben realizar una operación de inicialización y posteriormente las sucesivas de
incremento o decremento del mismo. La inicialización consiste en asignarle al contador un
valor. Se situará antes y fuera del bucle.
 Representación:

<nombre del contador> ¬ nombre del contador> + <valor constante>

Si en vez de incremento es decremento se coloca un menos en lugar del más.

Ejemplo: i = i + 1

ACUMULADOR O TOTALIZADOR :

Es una variable que suma sobre sí misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre un contador
y un acumulador es que mientras el primero va aumentando de uno en uno, el
acumulador va aumentando en una cantidad variable.

Representación: <Nombre del acumulador> ¬ <nombre del acumulador> + <valor

variable>

Ejemplo:

Calcular la suma de los cuadrados de los primeros 100 enteros y escribir el

resultado. Se desea resolver el problema usando estructura Desde, Mientras y luego
Repetir.

Ejemplo 2.
 Elaborar un flujograma para encontrar la suma de los K primeros números
enteros.

En este ejemplo hemos utilizado un bucle repetir, el cual estudiaremos en otra

lección. Lo que queremos hacer notar por el momento, es cómo funcionan el contador y el
acumulador. Nota que N es el contador, el cual se inicializa en este caso, con cero, antes
de entrar al bucle. Dentro del bucle podrás notar que N se incrementa en 1.

También observa la variable suma, la cual es un acumulador que lleva la suma de

los números generados. También debe inicializarse con cero, ya que para sumar valores
debemos partir de cero, es decir, que al inicio no tenemos nada. Dentro del bucle, suma
se incrementa en un número N, pero la diferencia con el contador N, es que a suma le
sumamos N más ella misma.

EJERCICIO:

Trata de elaborar un flujograma para encontrar el cuadrado de los primeros 25

números naturales, usando la estructura Desde/Para.
 ¿Qué necesitas para resolver el problema contadores o acumuladores? Modifica
el flujograma del ejercicio anterior para que también te muestre la suma de dichos
cuadrados.

¿Qué necesitas agregar ahora?

RESUMEN

En esta lección aprendimos un poco del uso de contadores y acumuladores.

También aprendimos a elaborar flujogramas o algoritmos usando la estructura Desde.
Hay un número importante de reglas que deben seguirse cuando se utilizan instrucciones

Desde:

Los valores inicial y final de la variable de control se determinan antes de que

empiece la repetición y no pueden cambiarse durante la ejecución de la instrucción
Desde. Dentro del cuerpo del bucle Desde, los valores de las variables que especifican
los valores inicial y final pueden cambiar, pero esto no va a afectar al número de
repeticiones. La instrucción del cuerpo del bucle de una instrucción Desde puede utilizar
el valor de la variable de control, pero no debe modificar este valor. Esta estructura se
puede usar únicamente en aquellos casos en que conocemos el número de veces que se
va a realizar el ciclo.

Esta estructura hace el incremento automáticamente y se inicializa en la

instrucción desde.