Estructuras repetitivas

¿Que es una estructura repetitiva?

Una estructura repetitiva, estructura iterativa, ciclo repetitivo o bucle en programación, se refiere
a un tipo de estructura de control la cual permite la repetición de la ejecución de una o varias
sentencias internas, de tal modo que no sea necesario escribir varias veces una misma instrucción
o un mismo procedimiento que se ejecutara en múltiples ocasiones, a diferencia de las estructuras
de control condicionales o de selección, donde el flujo de ejecución del programa simplemente se
bifurca o desvía en un sentido u otro según el resultado que se obtenga de la evaluación de una
interrogante o condición, pero en ese caso las sentencias internas solo se ejecutan una vez.

Representar en diagrama de flujo las estructuras repetitivas While y Do While

Como se utiliza la estructura repetitiva while

Si queremos hacer que una sección de nuestro programa se repita mientras se cumpla una
cierta condición, usaremos la orden “while”. Esta orden tiene dos formatos distintos, según
comprobemos la condición al principio o al final.

En el primer caso, su sintaxis es

while (condición)
   sentencia;

Es decir, la sentencia se repetirá mientras la condición sea cierta. Si la condición es falsa

ya desde un principio, la sentencia no se ejecuta nunca. Si queremos que se repita más de
una sentencia, basta agruparlas entre { y }. Como ocurria con "if", puede ser recomendable
incluir siempre las llaves, aunque sea una única sentencia, para evitar errores posteriores
difíciles de localizar.
Como se utiliza la estructura repetitiva Do – while

Este es el otro formato que puede tener la orden “while”: la condición se comprueba al
final. El punto en que comienza a repetirse se indica con la orden “do”, así:

do
sentencia;
while (condición);

Al igual que en el caso anterior, si queremos que se repitan varias órdenes (es lo habitual),
deberemos encerrarlas entre llaves. Nuevamente, puede ser recomendable incluir siempre
las llaves, como costumbre.

Como se utiliza la estructura repetitiva For

Ésta es la orden que usaremos habitualmente para crear partes del programa que se repitan
un cierto número de veces. El formato de “for” es

for (valorInicial; CondiciónRepetición; Incremento)

  Sentencia;

Que es un “Contador”

Recordemos que “contador++” es una forma abreviada de escribir “contador=contador+1”,

de modo que en este ejemplo aumentamos la variable de uno en uno.

Para que se utiliza la Sentencia break:

Esta se utiliza para termina el bucle

Podemos salir de un bucle “for” antes de tiempo con la orden “break”:

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.

import java.util.Scanner;

public class EstructuraRepetitivaWhile5 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int x,nota,conta1,conta2;
x=1;
 conta1=0;
conta2=0;
while (x<=10) {
System.out.print("Ingrese nota:");
nota=teclado.nextInt();
if (nota>=7) {
conta1=conta1 + 1;
}else {
conta2=conta2 + 1;
}
x=x + 1;
}
System.out.print("Cantidad de alumnos con notas mayores o iguales
a 7:");
System.out.println(conta1);
System.out.print("Cantidad de alumons con notas menores a 7:");
System.out.print(conta2);
}
}

2. Crear un programa calcule cuantas cifras tiene un número entero positivo (pista: se
puede hacer dividiendo varias veces entre 10).

3. Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la altura

promedio de las personas.

import java.util.Scanner;

public class EstructuraRepetitivaWhile6 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x;
float altura,suma,promedio;
System.out.print("Cuantas personas hay:");
n=teclado.nextInt();
x=1;
suma=0;
while (x<=n) {
System.out.print("Ingrese la altura:");
altura=teclado.nextFloat();
suma=suma + altura;
x=x + 1;
}
promedio=suma/n;
System.out.print("Altura promedio:");
System.out.print(promedio);
}
}
 4. 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.

import java.util.Scanner;

public class EstructuraRepetitivaWhile7 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x,conta1,conta2;
float sueldo,gastos;
System.out.print("Cuantos empleados tiene la empresa:");
n=teclado.nextInt();
x=1;
conta1=0;
conta2=0;
gastos=0;
while (x<=n) {
System.out.print("Ingrese el sueldo del empleado:");
sueldo=teclado.nextFloat();
if (sueldo<=300) {
conta1=conta1 + 1;
} else {
conta2=conta2 + 1;
}
gastos=gastos+sueldo;
x=x + 1;
}
System.out.print("Cantidad de empleados con sueldos entre 100 y
300:");
System.out.println(conta1);
System.out.print("Cantidad de empleados con sueldos mayor a
300:");
System.out.println(conta2);
System.out.print("Gastos total de la empresa en sueldos:");
System.out.println(gastos);
}
}

public class EstructuraRepetitivaWhile8 {

public static void main(String[] ar) {
int x,termino;
x=1;
termino=11;
while (x<=25) {
System.out.print(termino);
 System.out.print(" - ");
x=x + 1;
termino=termino +11;
}
}
}

public class EstructuraRepetitivaWhile9 {

public static void main(String[] ar) {
int mult8;
mult8=8;
while (mult8<=500) {
System.out.print(mult8);
System.out.print(" - ");
mult8=mult8 + 8;
}
}
}

5. Realizar un programa que imprima 25 términos de la serie 11 - 22 - 33 - 44, etc. (No

se ingresan valores por teclado)
6. Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 - 16 - 24,
etc.

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. import
java.util.Scanner;

public class EstructuraRepetitivaWhile10 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int valor,x,suma1,suma2;
x=1;
suma1=0;
suma2=0;
System.out.println("Primer lista");
while (x<=15) {
System.out.print("Ingrese valor:");
valor=teclado.nextInt();
suma1=suma1 + valor;
x=x + 1;
}
System.out.println("Segunda lista");
x=1;
while (x<=15) {
System.out.print("Ingrese valor:");
valor=teclado.nextInt();
 suma2=suma2 + valor;
x=x + 1;
}
if (suma1>suma2) {
System.out.print("Lista 1 mayor.");
} else {
if (suma2>suma1) {
System.out.print("Lista2 mayor.");
} else {
System.out.print("Listas iguales.");
}
}
}
}

7.

8. Crea un programa que pida al usuario su código de usuario (un número entero) y su
contraseña numérica (otro número entero), y no le permita seguir hasta que
introduzca como código 1024 y como contraseña 4567.Utilizando Do- While
9. Crear un programa que pida un número al usuario (entre 1 y 100) y muestre tantas
letras A como indique ese número, usando "break" para terminar.
10. Desarrollar un programa que permita cargar n números enteros y luego nos informe
cuántos valores fueron pares y cuántos impares.

import java.util.Scanner;

public class EstructuraRepetitivaWhile11 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int n,x,valor,pares,impares;
x=1;
pares=0;
impares=0;
System.out.print("Cuantos números ingresará:");
n=teclado.nextInt();
while (x<=n) {
System.out.print("Ingrese el valor:");
valor=teclado.nextInt();
if (valor%2==0) {
pares=pares + 1;
} else {
impares=impares + 1;
}
x=x + 1;
}
System.out.print("Cantadad de pares:");
System.out.println(pares);
System.out.print("Cantidad de impares:");
System.out.print(impares);
}
}
 11. Crear un programa que reciba un numero entero positivo N de o más cifras.
Si N es impar debe Mostrar el número invertido.
Si N par debe mostrar el número de veces que aparece el dígito "d" dado por el usuario,
también el número M que es igual al número N sin considerar los digitos "d".

Ejemplo.

Si N = 53634 (par) y d = 3

Salida
    número de veces que aparece el dígito 3 : 2
    M = 564
Si N = 15747 (impar)
Salida:
    número invertido : 74751
Respuesta

#include <iostream>
#include <math.h>
using namespace std;

void main(){
int num = 0, n, m, d, cont = 0;
double N=0;

do{
cout << "Ingrese N : "; cin >> n;
} while (n<1000);

if (n % 2 == 0){
m = n;
cout << endl << "Ingrese digito : "; cin >> d;

while (m != 0){
if (m % 10 == d){
cont++;
}
else{
N = N + (m % 10)*pow(10, num++);
}
m = m / 10;
}

cout << "Numero que aparece el digito " << d << " : " << cont;
cout << endl << "M = " << N <<endl;
 }
else{
m = n;
while (m != 0){
N = 10 * N + (m % 10);

m = m / 10;
}
cout << "Numero Invertido " << N <<endl;
}
system("pause");
}
12. Cada equipo de la liga sudamericana de fútbol tiene un cuadro de 30 jugadores, por
cada jugador se cuenta con los siguientes datos: código (entero de 3 cifras), peso y
edad.
Crear un programa que reciba los datos de los jugadores de "n" equipos(n>=10) y
nos muestre:

a)El peso promedio de los jugadores de cada equipo.

b)La edad promedio de todos los jugadores.
c)La mayor edad y el número de jugadores que lo poseen.

#include <iostream>
using namespace std;

void main(){
int n = 2, m = 2, i, j, contMax = 0, cod;
float sumaEdad = 0, sumaPeso, peso, edad,max = 0;

for (i = 1; i <= n; i++){

sumaPeso = 0;
for (j = 1; j <= m; j++){
cout << "Codigo : "; cin >> cod;
cout << "Peso : "; cin >> peso;
cout << "Edad : "; cin >> edad;
sumaPeso += peso;

if (max<edad){
contMax = 1;
max = edad;
}
else if (max == edad){
contMax++;
}
sumaEdad += edad;
}
 cout << "Edad Promedio de este equipo : " << (sumaPeso / m) << endl;
}

cout << "Edad Promedio Total : " << (sumaEdad / (m*n)) << endl;
cout << "Mayor Edad : " << max << " y numero de veces que se repite : " << contMax;

system("pause");
}
13. Diseñe un programa que permita validar los datos de usuario (entero de 3 dígitos) y
clave(3 caracteres) para su ingreso al sistema de procesamiento de notas (los datos
validos para el usuario es 100 y para la clave es UNI).
Si el usuario comete más de 3 errores durante la entrada de sus datos, el sistema
envía el mensaje "supero el número de oportunidades, Vuelva otro día" y luego
finaliza.

Si el usuario logra ingresar al sistema, éste le solicita que ingrese el número de

alumnos "n".
Luego, por cada alumno debe ingresar las notas finales de los cursos que ha llevado
en el ciclo 2020-1 (el ingreso de las notas del alumno termina cuando se ingresa el
valor -1)

El sistema debe calcular y mostrar por cada alumno, la nota promedio que ha
obtenido en el ciclo 2020-1 y finalmente el número de aprobados según dicho
promedio.

#include <iostream>
#include <conio.h>
#include <stdio.h>
#include <string>

using namespace std;

void main(){
int usuario, cont = 0, n, contAprobados = 0, contNota, i;
float sumaNotas, nota;
char clave[30];

do{
cont++;
cout << "Usuario : "; cin >> usuario;
cout << "Clave : "; cin>>clave;
cout << "contador en : " << cont << endl;

} while ((usuario != 100 || strcmp(clave, "UNI") != 0) && cont<3);

 if (cont == 3){
cout << cont << "Chao mano";
}
else{
cout << "Ingrese numero de alumnos : "; cin >> n;

for (i = 1; i <= n; i++){

contNota = 0;
sumaNotas = 0;
cout << endl << "NOTAS DE UN NUEVO ALUMNO : ";
do{
cout << endl << "Ingrese nota : "; cin >> nota;
contNota++;
sumaNotas += nota;
} while (nota != -1);

cout << "Promedio del alumno : ";

cout << ((sumaNotas + 1) / (contNota - 1));
cout << endl << endl;

if ((sumaNotas + 1) / (contNota - 1) >= 10){

contAprobados++;
}
}

cout << endl << endl;

cout << "La cantidad de aprobados es : " << contAprobados;
}

system("pause");
}

14. Realizar un programa que permita ingresar el peso (en kilogramos) de piezas. El
proceso termina cuando ingresamos el valor 0. Se debe informar:
a) Cuántas piezas tienen un peso entre 9.8 Kg. y 10.2 Kg.?, cuántas con más de 10.2
Kg.? y cuántas con menos de 9.8 Kg.?
b) La cantidad total de piezas procesadas.

Diagrama de flujo:
Programa:

import java.util.Scanner;

public class EstructuraRepetitivaDoWhile3 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int cant1,cant2,cant3,suma;
float peso;
cant1=0;
cant2=0;
cant3=0;
do {
 System.out.print("Ingrese el peso de la pieza (0 pera
finalizar):");
peso=teclado.nextFloat();
if (peso>10.2) {
cant1++;
} else {
if (peso>=9.8) {
cant2++;
} else {
if (peso>0) {
cant3++;
}
}
}
} while(peso!=0);
suma=cant1+cant2+cant3;
System.out.print("Piezas aptas:");
System.out.println(cant2);
System.out.print("Piezas con un peso superior a 10.2:");
System.out.println(cant1);
System.out.print("Piezas con un peso inferior a 9.8:");
System.out.println(cant3);
}
}

15. Realizar un programa que acumule (sume) valores ingresados por teclado hasta
ingresar el 9999 (no sumar dicho valor, indica que ha finalizado la carga). Imprimir
el valor acumulado e informar si dicho valor es cero, mayor a cero o menor a cero.

import java.util.Scanner;

public class EstructuraRepetitivaDoWhile4 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int suma,valor;
suma=0;
do {
System.out.print("Ingrese un valor:");
valor=teclado.nextInt();
if (valor!=9999) {
suma=suma+valor;
}
}while (valor!=9999);
System.out.print("El valor acumulado es ");
System.out.println(suma);
if (suma==0) {
System.out.println("El valor acumulado es cero.");
} else {
if (suma>0) {
System.out.println("El valor acumulado es positivo.");
} else {
System.out.println("El valor acumulado es negativo");
}
}
}
}
 16. En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada
cuenta corriente se conoce: número de cuenta y saldo actual. El ingreso de datos
debe finalizar al ingresar un valor negativo en el número de cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas corrientes e
informe:
a)De cada cuenta: número de cuenta y estado de la cuenta según su saldo, sabiendo
que:

Estado de la cuenta 'Acreedor' si el saldo es >0.

'Deudor' si el saldo es <0.
'Nulo' si el saldo es =0.

b) La suma total de los saldos acreedores.

import java.util.Scanner;

public class EstructuraRepetitivaDoWhile5 {

public static void main(String[] ar) {
Scanner teclado=new Scanner(System.in);
int cuenta;
float saldo,suma;
suma=0;
do {
System.out.print("Ingrese número de cuenta:");
cuenta=teclado.nextInt();
if (cuenta>=0) {
System.out.print("Ingrese saldo:");
saldo=teclado.nextFloat();
if (saldo>0) {
System.out.println("Saldo Acreedor.");
suma=suma+saldo;
} else {
if (saldo<0) {
System.out.println("Saldo Deudor.");
} else {
System.out.println("Saldo Nulo.");
}
}
}
} while(cuenta>=0);
System.out.print("Total de saldos Acreedores:");
System.out.print(suma);
}
}

17. Simular el comportamiento de un reloj digital, imprimiendo la hora, minutos y

segundos de un día desde las 0:00:00 horas hasta las 23:59:59 horas
 #include
#include
#include

void main()
{
int h=0,m=0,s=0;

gotoxy(1,1); cout<<" : : ";

while(true)
{
s++;
Sleep(250);
gotoxy(1,1); cout<
gotoxy(4,1); cout<<" ";
gotoxy(4,1); cout<
gotoxy(7,1); cout<<" ";
gotoxy(7,1); cout<
if (s==59)
{
s=-1; m++;
}
if (m==59)
{
m=-1; h++;
}
if (h==24)
break;
}
}

Ejercicios resueltos:

> ¿Qué escribiría en pantalla este fragmento de código?

for (i=1; i<4; i++) printf("%d", i);

Respuesta: los números del 1 al 3 (se empieza en 1 y se repite mientras sea menor que 4).

> ¿Qué escribiría en pantalla este fragmento de código?

for (i=1; i>4; i++) printf("%d", i);

Respuesta: no escribiría nada, porque la condición es falsa desde el principio.

> ¿Qué escribiría en pantalla este fragmento de código?

for (i=1; i<=4; i++); printf("%d", i);

Respuesta: escribe un 5, porque hay un punto y coma después del “for”, de modo que repite
cuatro veces una orden vacía, y cuando termina, “i” ya tiene el valor 5.

> ¿Qué escribiría en pantalla este fragmento de código?

for (i=1; i<4; ) printf("%d", i);

Respuesta: escribe “1” continuamente, porque no aumentamos el valor de “i”, luego nunca
se llegará a cumplir la condición de salida.

> ¿Qué escribiría en pantalla este fragmento de código?

for (i=1; ; i++) printf("%d", i);

Respuesta: escribe números continuamente, comenzando en uno y aumentando una unidad

en cada pasada, pero si terminar nunca.

> ¿Qué escribiría en pantalla este fragmento de código?

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

if ( i == 2 ) continue ; printf( "%d " , i); }

Respuesta: escribe los números del 0 al 4, excepto el 2.

> ¿Qué escribiría en pantalla este fragmento de código?

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

if ( i == 2 ) break ; printf( "%d " , i); }

Respuesta: escribe los números 0 y 1 (interruumpe en el 2).

> ¿Qué escribiría en pantalla este fragmento de código?

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

if ( i == 10 ) continue ; printf( "%d " , i); }

Respuesta: escribe los números del 0 al 4, porque la condición del “continue” nunca se
llega a dar.

> ¿Qué escribiría en pantalla este fragmento de código?

for ( i= 0 ; i<= 4 ; i++)

if ( i == 2 ) continue ; printf( "%d " , i);
Respuesta: escribe 5, porque no hay llaves tras el “for”, luego sólo se repite la orden “if”.

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);
}
}