Estructura Repetitiva For Java
Estructura Repetitiva For Java
Cualquier problema que requiera una estructura repetitiva se puede resolver empleando la
estructura while. Pero hay otra estructura repetitiva cuyo planteo es ms sencillo en
ciertas situaciones.
En general, la estructura for se usa en aquellas situaciones en las cuales CONOCEMOS
la cantidad de veces que queremos que se ejecute el bloque de instrucciones. Ejemplo:
cargar 10 nmeros, ingresar 5 notas de alumnos, etc. Conocemos de antemano la
cantidad de veces que queremos que el bloque se repita. Veremos, sin embargo, que en
el lenguaje Java la estructura for puede usarse en cualquier situacin repetitiva, porque en
ltima instancia no es otra cosa que una estructura while generalizada.
Representacin grfica:
En su forma ms tpica y bsica, esta estructura requiere una variable entera que
cumple la funcin de un CONTADOR de vueltas. En la seccin indicada como
"inicializacin contador", se suele colocar el nombre de la variable que har de
contador, asignndole a dicha variable un valor inicial. En la seccin de "condicin"
se coloca la condicin que deber ser verdadera para que el ciclo contine (en
caso de un falso, el ciclo se detendr). Y finalmente, en la seccin de "incremento
contador" se coloca una instruccin que permite modificar el valor de la variable
que hace de contador (para permitir que alguna vez la condicin sea falsa)
Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for toma
el valor indicado en la seccin de de "inicializacin contador". Inmediatamente se
verifica, en forma automtica, si la condicin es verdadera. En caso de serlo se
ejecuta el bloque de operaciones del ciclo, y al finalizar el mismo se ejecuta la
instruccin
que
se
haya
colocado
en
la
tercer
seccin.
Seguidamente, se vuelve a controlar el valor de la condicin, y as prosigue hasta
que dicha condicin entregue un falso.
Problema 1:
publicclassEstructuraRepetitivaFor1{
publicstaticvoidmain(String[]ar){
intf;
for(f=1;f<=100;f++){
System.out.print(f);
System.out.print("");
}
}
}
Problema 2:
En este caso, a la variable del for (f) slo se la requiere para que se repita el
bloque de instrucciones 10 veces.
Programa:
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor2{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intsuma,f,valor,promedio;
suma=0;
for(f=1;f<=10;f++){
System.out.print("Ingresevalor:");
valor=teclado.nextInt();
suma=suma+valor;
}
System.out.print("Lasumaes:");
System.out.println(suma);
promedio=suma/10;
System.out.print("Elpromedioes:");
System.out.print(promedio);
}
}
El problema requiere que se carguen 10 valores y se sumen los mismos.
Tener en cuenta encerrar entre llaves bloque de instrucciones a repetir dentro del
for.
El promedio se calcula fuera del for luego de haber cargado los 10 valores.
Problema 3:
Escribir un programa que lea 10 notas de alumnos y nos informe cuntos tienen
notas mayores o iguales a 7 y cuntos menores.
Para resolver este problema se requieren tres contadores:
aprobados (Cuenta la cantidad de alumnos aprobados)
reprobados (Cuenta la cantidad de reprobados)
f (es el contador del for)
Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y verificar
con una estructura condicional si el contenido de la variable nota es mayor o igual a 7
para incrementar el contador aprobados, en caso de que la condicin retorne falso
debemos incrementar la variable reprobados.
Diagrama de flujo:
Programa:
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor3{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intaprobados,reprobados,f,nota;
aprobados=0;
reprobados=0;
for(f=1;f<=10;f++){
System.out.print("Ingreselanota:");
nota=teclado.nextInt();
if(nota>=7){
aprobados=aprobados+1;
}else{
reprobados=reprobados+1;
}
}
System.out.print("Cantidadde
aprobados:");
System.out.println(aprobados);
System.out.print("Cantidadde
reprobados:");
System.out.print(reprobados);
}
}
Problema 4:
Escribir un programa que lea 10 nmeros enteros y luego muestre cuntos valores
ingresados fueron mltiplos de 3 y cuntos de 5. Debemos tener en cuenta que
hay nmeros que son mltiplos de 3 y de 5 a la vez.
Diagrama de flujo:
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor4{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intmul3,mul5,valor,f;
mul3=0;
mul5=0;
for(f=1;f<=10;f++){
System.out.print("Ingreseun
valor:");
valor=teclado.nextInt();
if(valor%3==0){
mul3=mul3+1;
}
if(valor%5==0){
mul5=mul5+1;
}
}
System.out.print("Cantidaddevalores
ingresadosmltiplosde3:");
System.out.println(mul3);
System.out.print("Cantidaddevalores
ingresadosmltiplosde5:");
System.out.print(mul5);
}
}
Problema 5:
Diagrama de flujo:
contador
cantidad.
Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene
almacenado la cantidad de valores ingresados mayores o iguales a 1000.
Programa:
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor5{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intcantidad,n,f,valor;
cantidad=0;
System.out.print("Cuantosvalores
ingresar:");
n=teclado.nextInt();
for(f=1;f<=n;f++){
System.out.print("Ingreseel
valor:");
valor=teclado.nextInt();
if(valor>=1000){
cantidad=cantidad+1;
}
}
System.out.print("Lacantidaddevalores
ingresadosmayoresoigualesa1000son:");
System.out.print(cantidad);
}
}
Problemas propuestos
Ha llegado nuevamente la parte fundamental, que es el momento donde uno
desarrolla individualmente un algoritmo para la resolucin de un problema.
1. Confeccionar un programa que lea n pares de datos, cada par de datos
corresponde a la medida de la base y la altura de un tringulo. El programa deber
informar:
a) De cada tringulo la medida de su base, su altura y su superficie.
b) La cantidad de tringulos cuya superficie es mayor a 12.
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor6{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intbase,altura,superficie,cantidad,f,n;
cantidad=0;
System.out.print("Cuantostringulosprocesar:");
n=teclado.nextInt();
for(f=1;f<=n;f++){
System.out.print("Ingreseelvalordela
base:");
base=teclado.nextInt();
System.out.print("Ingreseelvalordela
altura:");
altura=teclado.nextInt();
superficie=base*altura/2;
System.out.print("Lasuperficiees:");
System.out.println(superficie);
if(superficie>12){
cantidad=cantidad+1;
}
}
System.out.print("Lacantidaddetringuloscon
superficiesuperiora12son:");
System.out.print(cantidad);
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor7{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intf,valor,suma;
suma=0;
for(f=1;f<=10;f++){
System.out.print("Ingreseunvalor:");
valor=teclado.nextInt();
if(f>5){
suma=suma+valor;
}
}
System.out.print("Lasumadelosltimos5valores
es:");
System.out.print(suma);
}
}
publicclassEstructuraRepetitivaFor8{
publicstaticvoidmain(String[]ar){
intf;
for(f=5;f<=50;f=f+5){
System.out.print(f);
System.out.print("");
}
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor8{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intf,valor;
System.out.print("Ingreseunvalorentre1y10:");
valor=teclado.nextInt();
for(f=valor;f<=valor*12;f=f+valor){
System.out.print(f);
System.out.print("");
}
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor9{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intf,lado1,lado2,lado3,cant1,cant2,cant3,n;
cant1=0;
cant2=0;
cant3=0;
System.out.print("Ingreselacantidadde
tringulos:");
n=teclado.nextInt();
for(f=1;f<=n;f++){
System.out.print("Ingreselado1:");
lado1=teclado.nextInt();
System.out.print("Ingreselado2:");
lado2=teclado.nextInt();
System.out.print("Ingreselado3:");
lado3=teclado.nextInt();
if(lado1==lado2&&lado1==lado3){
System.out.println("Esuntringulo
equilatero.");
cant1++;
}else{
if(lado1==lado2||lado1==lado3||
lado2==lado3){
System.out.println("Esuntringulo
issceles.");
cant2++;
}else{
cant3++;
System.out.println("Esuntringulo
escaleno.");
}
}
}
System.out.print("Cantidaddetringulos
equilateros:");
System.out.println(cant1);
System.out.print("Cantidaddetringulos
issceles:");
System.out.println(cant2);
System.out.print("Cantidaddetringulos
escalenos:");
System.out.println(cant3);
if(cant1<cant2&&cant1<cant3){
System.out.print("Haymenorcantidadde
tringulosequilateros.");
}else{
if(cant2<cant3){
System.out.print("Hanmenorcantidadde
tringulosissceles");
}else{
System.out.print("Hanmenorcantidadde
tringulosescalenos");
}
}
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor10{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intn,f,x,y,cant1,cant2,cant3,cant4;
cant1=0;
cant2=0;
cant3=0;
cant4=0;
System.out.print("Cantidaddepuntos:");
n=teclado.nextInt();
for(f=1;f<=n;f++){
System.out.print("Ingresecoordenadax:");
x=teclado.nextInt();
System.out.print("Ingresecoordenaday:");
y=teclado.nextInt();
if(x>0&&y>0){
cant1++;
}else{
if(x<0&&y>0){
cant2++;
}else{
if(x<0&&y<0){
cant3++;
}else{
if(x>0&&y<0){
cant4++;
}
}
}
}
}
System.out.print("Cantidaddepuntosenelprimer
cuadrante:");
System.out.println(cant1);
System.out.print("Cantidaddepuntosenelsegundo
cuadrante:");
System.out.println(cant2);
System.out.print("Cantidaddepuntoseneltercer
cuadrante:");
System.out.println(cant3);
System.out.print("Cantidaddepuntosenelcuarto
cuadrante:");
System.out.println(cant4);
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor11{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intf,valor,negativos,positivos,mult15,sumapares;
negativos=0;
positivos=0;
mult15=0;
sumapares=0;
for(f=1;f<=10;f++){
System.out.print("Ingresevalor:");
valor=teclado.nextInt();
if(valor<0){
negativos++;
}else{
if(valor>0){
positivos++;
}
}
if(valor%15==0){
mult15++;
}
if(valor%2==0){
sumapares=sumapares+valor;
}
}
System.out.print("Cantidaddevaloresnegativos:");
System.out.println(negativos);
System.out.print("Cantidaddevalorespositivos:");
System.out.println(positivos);
System.out.print("Cantidaddevaloresmltiplosde
15:");
System.out.println(mult15);
System.out.print("Sumadelosvalorespares:");
System.out.println(sumapares);
}
}
importjava.util.Scanner;
publicclassEstructuraRepetitivaFor12{
publicstaticvoidmain(String[]ar){
Scannerteclado=newScanner(System.in);
intf,edad,suma1,suma2,suma3,pro1,pro2,pro3;
suma1=0;
suma2=0;
suma3=0;
for(f=1;f<=50;f++){
System.out.print("Ingreseedad:");
edad=teclado.nextInt();
suma1=suma1+edad;
}
pro1=suma1/50;
System.out.print("Promediodeedadesdelturno
maana:");
System.out.println(pro1);
for(f=1;f<=60;f++){
System.out.print("Ingreseedad:");
edad=teclado.nextInt();
suma2=suma2+edad;
}
pro2=suma2/60;
System.out.print("Promediodeedadesdelturno
tarde:");
System.out.println(pro2);
for(f=1;f<=110;f++){
System.out.print("Ingreseedad:");
edad=teclado.nextInt();
suma3=suma3+edad;
}
pro3=suma3/110;
System.out.print("Promediodeedadesdelturno
noche:");
System.out.println(pro3);
if(pro1<pro2&&pro1<pro3){
System.out.print("Elturnomaanatieneun
promediomenordeedades.");
}else{
if(pro2<pro3){
System.out.print("Elturnotardetieneun
promediomenordeedades.");
}else{
System.out.print("Elturnonochetieneun
promediomenordeedades.");
}
}
}
}