1. Introducción

Eso sí, la iteración no puede ser infinita. Las estructuras repetitivas son otra forma de estructura de control. El tratamiento de los datos por una estructura repetitiva se muestra en el siguiente gráfico. Note que un conjunto de datos es manipulado en forma reiterada un cierto número de veces:

2. Estructuras Repetitivas

Toda estructura repetitiva consta de un cláusula de control de la misma, y de un cuerpo de la estructura repetitiva, también denominada bucle de primitivas a repetir, ó bloque de primitivas a repetir. El bloque de instrucciones es una unidad que se ejecutará en forma completa si la cláusula de control lo permite. En pseudocódigo lo mostramos con su indentación correspondiente, y en JAVA entre llaves.

2.1 Estructura Repetitiva PARA

Una estructura Repetitiva PARA se utiliza cuando la cantidad de veces a repetir es finita, y estamos en presencia de una cantidad definida de repeticiones (ej 3, 100, n-veces, cantidad de alumnos-veces).

Una estructura Repetitiva PARA cuenta con una variable iteradora, que es inicializada a un valor inicial (o limite inferior), y esta variable tomará los valores desde ese limite hasta el valor del limite superior inclusive (descripto en la cláusula HASTA). La variable iteradora se incrementará la cantidad de veces que indique la cláusula PASO, una vez que finaliza el bloque de sentencias a repetir. Si al ser incrementada la variable iteradora, este valor supera el valor del limite superior, la estructura repetitiva PARA finaliza.

Si la cláusula PASO, es PASO 1, el caso más habitual, esta puede omitirse . En otras palabras, si encontramos una estructura repetitiva PARA, sin cláusula PASO, esto implica que la variable iteradora se incrementará en una unidad cada vez que finalice un bucle de la estructura repetitiva.

Observación: El limite superior debe ser superior o igual al limite inferior, en valor absoluto, de otro modo la estructura estaría mal definida. Si el limite superior es menor en valor absoluto que el limite inferior se supone que el valor de la primitiva paso es negativo, con el fin de decrementar la variable iteradora.

2.2 Estructura Repetitiva MIENTRAS

Una estructura Repetitiva MIENTRAS primero evalúa una expresión booleana, si la expresión booleana es verdadera ejecuta el bloque de sentencias a repetir. Una vez ejecutado el bloque o bucle, se vuelve a evaluar la expresión booleana y se opera en forma similar. Si la expresión booleana se evalúa a falso, se finaliza la ejecución de la estructura repetitiva.

Debido a que en la primera evaluación de la expresión booleana, puede retornar como resultado falso, esta estructura admite el caso de que se itere cero veces. A diferencia de la estructura repetitiva REPETIR HASTA que al menos ejecuta una vez el bucle.

Por ello decimos que la estructura repetitiva permite 0 o más iteraciones. Cero, en el caso que la primera evaluación de la condición booleana sea falsa.

2.3 Estructura Repetitiva REPETIR HASTA

Una estructura Repetitiva REPETIR HASTA primero ejecuta el bucle de sentencias a repetir y luego evalúa una expresión booleana. En pseudocodigo esta estructura se nota en forma distinta a la particularidad del lenguaje JAVA. En pseudocódigo decimos que la estructura repetitiva REPETIR HASTA, vuelve a ejecutar el conjunto de sentencias del bucle si la expresion booleana es falsa. Y terminará de repetir cuando esta arroje resultado verdadero. En cambio en java, es diferente, la instrucción de java repite mientras la expresion booleana sea verdadera.

2.4 ¿Cuando utilizar cada estructura repetitiva?

Existen variantes de una estructura repetitiva, pero todas ellas permiten que un conjunto de acciones se ejecuten entre 0 y n veces. La estructura Repetir MIENTRAS se puede ejecutar entre 0 y n veces, la estructura Repetir HASTA se puede ejecutar entre 1 y n veces. Utilizamos la estructura Repetir PARA cuando la cantidad de veces a repetir está determinada por un valor (es una cantidad definida de veces), esto representa un ciclo definido. Si la cantidad de veces a repetir es indefinida podemos utilizar un Repetir MIENTRAS o Repetir HASTA.

2.5 Estructuras Repetitivas en JAVA

A continuación mostramos los constructores de estructuras repetitivas en Java. Es importante reiterar que Repetir HASTA no es exactamente equivalmente a do… while en Java.

En el caso de la Estructura repetitiva PARA se implementa en java utilizando la palabra reservada for y a continuación, entre paréntesis, se especifican tres componentes, separados por punto y coma:

El valor inicial de la variable iteradora.
La condición que debe cumplir la variable iteradora. Condición que se evalúa al finalizar cada iteración del bucle.
El incremento de la variable iteradora

El bucle o cuerpo de sentencias a repetir se encierra entre llaves. Por ser este cuerpo o bucle un bloque de sentencias, si damos formato al texto en java con la combinación de teclas Alt-Shift-F (ó haciendo click en Source y luego Format), java automáticamente dejará una sangría, espaciado o indententación para resaltar que ese conjunto es el cuerpo de la estructura repetitiva.

Indentar: significa hacer espacios hacia la derecha para mover una línea de código, lo podés hacer usando la barra espaciadora o con la tecla de tabulación (es la tecla que está justo arriba de tu tecla Bloquear Mayúsculas). Indentación es un anglicismo (de la palabra inglesa indentation) de uso común en informática; no es un término reconocido por la Real Academia Española .

3. Problemas con REPETIR PARA

Se muestran en esta sección algunos ejemplos que requieren de la estructura repetitiva PARA.

3.1 Tabla de Multiplicar

Problema: Solicitar al usuario un número entre 1 y 9 y mostrar la tabla de multiplicar de dicho número:

ALGORITMO tablaDeMultiplicar() RETORNA ∅
  (* dado un número entero entre 1 y 9
     muestra la tabla de multiplicar de ese nro *)
  ENTERO numero, j
  ESCRIBIR("Ingrese un número entero entre 1 y 9: ")
  LEER(numero)
  ESCRIBIR("Tabla de Multiplicar de:"+ numero)
  SI (numero>0 AND numero<=9) ENTONCES
     PARA j<-1 HASTA 10 HACER
         ESCRIBIR(j+" * "+numero +" = " + numero*j )
     FIN PARA
  SINO
     ESCRIBIR("Número no válido")
  FIN SI
FIN ALGORITMO tablaDeMultiplicar

package ejerciciosRepetitivas;
import java.util.Scanner;
public class Tabla {
public static void main(String[] args) {
  /* este alg. dado un dia entero [1-9]
      muestra su tabla de multiplicar   */
  Scanner entrada = new Scanner(System.in);
  int numero, j;
  System.out.println("Ingrese un numero entero [1-9]: ");
  numero = entrada.nextInt();
  if (numero>0 && numero<=9) { 
    for (j=1; j<11; j++){
      System.out.println(j+" * "+numero+" = "+(numero*j));
  }
  }
}
}

Descargar Archivo Tabla.java

La traza del algoritmo suponiendo que el usuario ingresa el valor 3:

tablaDeMultiplicar:

numero	j	salida
3	1	Ingrese un número entero entre 1 y 9:
.	2	Tabla de multiplicar de: 3
.	3	1 * 3 = 3
.	4	2 * 3 = 6
.	5	3 * 3 = 9
.	6	4 * 3 = 12
.	7	5 * 3 = 15
.	8	6 * 3 = 18
.	9	7 * 3 = 21
.	10	8 * 3 = 24
.	11	9 * 3 = 27
.		10 * 3 = 30

3.2 Edad Promedio de un número determinado de alumnos

Problema: Solicitar al usuario el número determinado de alumnos y calcular la edad promedio de alumnos

ALGORITMO edadPromedio() RETORNA ∅
  (* calcula la edad promedio de un
     numero determinado de alumnos*)
  ENTERO cantAlumnos, itAl, edadAlumno
  REAL acumEdades
  acumEdades <- 0.0
  ESCRIBIR("Ingrese la cantidad de Alumnos: ")
  LEER(cantAlumnos)
  PARA itAl <- 1 HASTA cantAlumnos PASO 1 HACER 
    ESCRIBIR("Ingrese la edad del alumno"+itAl)
    LEER(edadAlumno)
    acumEdades <- acumEdades + edadAlumno
  FIN PARA
  ESCRIBIR("La edad promedio es:"+acumEdades/cantAlumnos)
FIN ALGORITMO edadPromedio

package ejerciciosRepetitivas;
import java.util.Scanner;
public class EdadPromedio {
public static void main(String[] args) {
/* calcula la edad promedio de un
     numero determinado de alumnos   */
Scanner entrada = new Scanner(System.in);
int cantAlumnos, itAl, edadAlumno;
double acumEdades; 
acumEdades = 0.0;
System.out.println("Ingrese la cantidad de Alumnos: ");
cantAlumnos = entrada.nextInt();
for (itAl=1; itAl<=cantAlumnos; itAl++){
  System.out.println("Ingrese la edad del alumno"+itAl);
  edadAlumno = entrada.nextInt();
  acumEdades = acumEdades + edadAlumno;
  }
  System.out.println("La edad promedio es:"+acumEdades/cantAlumnos);
}
}

Descargar Archivo

edadPromedio:

cantAlumnos	itAl	edadAlumno	acumEdades	salida
3	1	2	~~0,0~~	Ingrese la cantidad de alumnos:
.	2	4	~~2,0~~	Ingrese la edad del alumno 1:
.	3	6	~~6,0~~	Ingrese la edad del alumno 2:
.	4		12,0	Ingrese la edad del alumno 3:
.				La edad promedio es: 4

3.3 Obtener el valor mínimo de un número determinado de números

Problema: Solicitar al usuario una cantidad determinada de alumnos y obtener la menor edad del grupo

ALGORITMO edadPromedio() RETORNA ∅
  (* este alg. obtiene la edad del 
     menor alumno de un conj. det. de alumnos*)
  ENTERO cantAlumnos, itAl, edadAlumno, menorEdad
  menorEdad <- 120
  ESCRIBIR("Ingrese la cantidad de Alumnos: ")
  LEER(cantAlumnos)
  PARA itAl <- 1 HASTA cantAlumnos PASO 1 HACER 
    ESCRIBIR("Ingrese la edad del alumno"+itAl)
    LEER(edadAlumno)
    SI (edadAlumno < menorEdad) ENTONCES
        menorEdad <- edadAlumno
    FIN SI
  FIN PARA
  ESCRIBIR("La menor edad es:"+menorEdad)
FIN ALGORITMO edadPromedio

package ejerciciosRepetitivas;
import java.util.Scanner;
public class EdadDelMenor {
public static void main(String[] args) {
/* este alg. dado un dia entero [1-9]
  muestra su tabla de multiplicar   */
Scanner entrada = new Scanner(System.in);
int cantAlumnos, itAl, edadAlumno, menorEdad;
menorEdad = 120;
System.out.println("Ingrese la cantidad de Alumnos: ");
cantAlumnos = entrada.nextInt();
for (itAl=1; itAl<=cantAlumnos; itAl++){
  System.out.println("Ingrese la edad del alumno"+itAl);
  edadAlumno = entrada.nextInt();
    if (edadAlumno < menorEdad){
      menorEdad = edadAlumno;
  }
  }
  System.out.println("La menor edad es:"+menorEdad);
  }
}

Descargar Archivo EdadDelMenor.java

edadPromedio:

cantAlumnos	itAl	edadAlumno	menorEdad	salida
3	1	4	~~100~~	Ingrese la cantidad de alumnos:
.	2	2	4	Ingrese la edad del alumno 1:
.	3	6	2	Ingrese la edad del alumno 2:
.	4			Ingrese la edad del alumno 3:
.				La menor edad es: 2

4. Problemas REPETIR MIENTRAS

4.1 Edad Promedio de un número indeterminado de alumnos (true-false)

Problema: Supongamos que el usuario indicará la edad de un alumno y luego le consultaremos ¿desea continuar? (true/false) y el deberá contestar true o false.

ALGORITMO edadPromedioCI() RETORNA ∅
(* calcula la edad promedio de un
  numero indeterminado de Alumnos *)
 ENTERO  j, edadAlumno
 REAL acumEdades
 LÓGICO continuar
 acumEdades <- 0.0
 j <- 0
 ESCRIBIR("Desea ingresar un alumno? true/false")
 LEER(continuar)
 MIENTRAS (continuar) HACER
   j <- j + 1
   ESCRIBIR("Ingrese la edad del alumno" + j)
   LEER(edadAlumno)
   acumEdades <- acumEdades + edadAlumno
   ESCRIBIR("Desea continuar? true/false")
   LEER(continuar)
 FIN MIENTRAS
 ESCRIBIR("La edad promedio es:" + acumEdades /j) 
FIN ALGORITMO edadPromedioCI

package ejerciciosRepetitivas;
import java.util.Scanner;
public class EdadPromedioCI {
public static void main(String[] args) {
/*  calcula la edad promedio de un
  numero indeterminado de Alumnos (0 o más)  */
Scanner entrada = new Scanner(System.in);
int cantAlumnos, j, edadAlumno;
double acumEdades;
boolean continuar;
acumEdades = 0.0;
System.out.println("Desea ingresar un alumno? true/false");
continuar = entrada.nextBoolean();
j=0;
while (continuar) {
   j++;
   System.out.println("Ingrese la edad del alumno" + j);
   edadAlumno = entrada.nextInt();
   acumEdades = acumEdades + edadAlumno;
   System.out.println("Desea continuar? true/false");
   continuar = entrada.nextBoolean();
   }

System.out.println("La edad promedio es:" + acumEdades /j);
}
}

Descargar Archivo EdadPromedioCI.java

4.2 Edad Promedio de un número indeterminado de alumnos (Texto SI-NO)

Problema: Supongamos que el usuario indicará la edad de un alumno y luego le consultaremos ¿desea continuar? (SI/NO) y el deberá contestar SI o NO.

ALGORITMO EdadPromedioCI1Texto() RETORNA ∅
(* calcula la edad promedio de un
  numero indeterminado de Alumnos *)
 ENTERO cantAlumnos, j, edadAlumno
 REAL acumEdades
 TEXTO continuar
 acumEdades <- 0.0
 ESCRIBIR("Desea ingresar un alumno? SI/NO")
 LEER(continuar)
 j <- 1
 MIENTRAS (igual(continuar,"SI")) HACER
   ESCRIBIR("Ingrese la edad del alumno" + j)
   LEER(edadAlumno)
   acumEdades <- acumEdades + edadAlumno
   ESCRIBIR("Desea continuar? true/false")
   LEER(continuar)
   SI  (igual(continuar,"SI")) ENTONCES
         j<-j+1
   FIN SI
 FIN MIENTRAS
 ESCRIBIR("La edad promedio es:" + acumEdades /j) 

FIN ALGORITMO EdadPromedioCI1Texto


public class EdadPromedioCI1Texto {
public static void main(String[] args) {
/* este alg. dado un dia entero [1-9]
   muestra su tabla de multiplicar   */
Scanner entrada = new Scanner(System.in);
int cantAlumnos, j, edadAlumno;
double acumEdades;
String continuar;
acumEdades = 0.0;
System.out.println("Desea ingresar un alumno? SI/N0");
continuar = entrada.next();
j = 1;
while (continuar.equals("SI")) {
   System.out.println("Ingrese la edad del alumno" + j);
   edadAlumno = entrada.nextInt();
   acumEdades = acumEdades + edadAlumno;
   System.out.println("Desea ingresar un alumno? SI/NO");
   continuar = entrada.next();
   if (continuar.equals("SI")) 
      j++;
}
System.out.println("La edad promedio es:" + acumEdades /j);
}
}

Descargar Archivo EdadPromedioCITexto.java

Ejercicio: Modifique el pseudocódigo y JAVA de este último ejercicio para tener en cuenta que el usuario puede contestar alguna de estas alternativas: SI, Si, si, sI, NO, No, no, nO.
¿Qué sucede si no contesta ninguna de ellas?

4.3 Las joyas de la Abuela

Problema: La Sra. Medina tiene una herencia en joyas de gran valor. Pero lo que a esta señora le interesa es comprarse un departamento, por lo cual decide vender algunas de sus joyas. El joyero le paga por cada gramo de oro dependiendo de su calidad que puede ser: Calidad 1: $80 el gramo. Calidad 2: $120 el gramo. Calidad 3: $300 el gramo. La Sra. Medina elije al azar las joyas cuyos valores sumen al menos $200000 que es lo que necesita para comprarse el departamento. Realizar un algoritmo que lea los datos de cada una de las joyas hasta alcanzar una suma mayor o igual al valor requerido. El algoritmo debe mostrar el monto total que el joyero pagará a la Sra. Medina por sus joyas.

ALGORITMO joyas() RETORNA ∅
  (* este alg. determina el valor que
     pagará el joyero a una abuela *)
  REAL acumJoyas, valorJoya, gramosJoya
  ENTERO calidadJoya
  acumJoyas <- 0.0

  MIENTRAS (acumJoyas < 200000) HACER
    ESCRIBIR("Ingrese los datos de la joya ")
    ESCRIBIR("¿Cuál es la calidad de la joya? 1, 2 ó 3")
    LEER(calidadJoya)
    ESCRIBIR("¿Cuántos gramos pesa la joya?")
    LEER(gramosJoya)
    valorJoya <- obtenerValor(calidadJoya, gramosJoya)
    acumJoyas <- acumJoyas + valorJoya
  FIN MIENTRAS        
  ESCRIBIR("El joyero pagará :"+acumJoyas+"$")
FIN ALGORITMO joyas

MODULO obtenerValor(ENTERO calidad,REAL gramos) RETORNA REAL
  (* obtiene el valor de joyas a partir
      de su peso y calidad de oro *)
  REAL valor
  SEGÚN (calidad) HACER
      1: valor <- 80 * gramos
      2: valor <- 120 * gramos
      3: valor <- 300 * gramos
      Vo: valor <- 0
  FIN SEGÚN
  RETORNAR valor
FIN MODULO obtenerValor

package ejerciciosRepetitivas;
import java.util.Scanner;

public class Joyas {
public static void main(String[] args) {
  // este alg. determina el valor que
  // pagará el joyero a una abuela
  Scanner sc = new Scanner(System.in);
  double acumJoyas, valorJoya, gramosJoya;
  int calidadJoya;
  acumJoyas = 0.0;

  while (acumJoyas < 200000) {
    System.out.println("Ingrese los datos de la joya ");
    System.out.println("¿Cuál es la calidad de la joya? 1, 2 ó 3");
    calidadJoya = sc.nextInt();
    System.out.println("¿Cuántos gramos pesa la joya?");
    gramosJoya = sc.nextDouble();
    valorJoya = obtenerValor(calidadJoya, gramosJoya);
    acumJoyas = acumJoyas + valorJoya;
    }        
  System.out.println("El joyero pagará :"+acumJoyas+"$");
}

public static double obtenerValor(int calidad, double gramos){
  /* obtiene el valor de joyas a partir
      de su peso y calidad de oro */
  double valor;
  switch (calidad) {
      case 1: valor = 80 * gramos; break;
      case 2: valor = 120 * gramos; break;
      case 3: valor = 300 * gramos; break;
      default: valor = 0; break;
  }
  return valor;
  }
}

Descargar Archivo Joyas.java

4.4 Determinar si un número es primo

ALGORITMO primo() RETORNA ∅
  (* Determina si un numero es par *)
  ENTERO numero
  ESCRIBIR("Ingrese un número entero: ")
  LEER(numero)
  SI (numero > 1) ENTONCES
    SI (esPrimo(numero)) ENTONCES 
      ESCRIBIR("El número es primo")
    SINO
      ESCRIBIR("El número no es primo")
    FIN SI
  FIN SI
FIN ALGORITMO primo

MÓDULO esPrimo(ENTERO numero) RETORNA LÓGICO
(* determina si un numero es primo
  numero: el numero a analizar
  retorna true si es primo, false en caso contrario*)
  ENTERO num
  LOGICO resultado
  num <- numero - 1
  resultado <- VERDADERO
  MIENTRAS (num != 1 AND num != 0 AND 
            !esDivisible(numero, num)) HACER
      num <- num - 1       
  FIN MIENTRAS
  SI (num != 1) ENTONCES
      resultado <- FALSO
  FIN SI
  RETORNAR resultado
FIN MÓDULO esPrimo

MÓDULO esDivisible(ENTERO num1, num2) RETORNA LÓGICO
  (* determina si un numero es divisible por otro
  num1 y num2: los números a analizar
  retorna VERDADERO si son divisibles 
  y FALSO en caso contrario*)
  RETORNAR ((num1 MOD num2)==0)
FIN MÓDULO esPrimo

package convertirtemp;
import java.util.Scanner;

public class Primo {
public static boolean esPrimo(int numero) {
/* determina si un numero es primo
  numero: el numero a analizar
  retorna true si es primo, false en caso contrario*/
  int num;
  num = numero - 1;
  boolean resultado = true;
  while (num > 1 && 
          !esDivisible(numero, num)) {
      num = num - 1;       
  }
  if (num > 1) {
      resultado = false;
  }
  return resultado;
}
public static boolean esDivisible(int num1,int num2){
  /* determina si un numero es divisible por otro
  num1 y num2: los números a analizar
  retorna true si son divisibles y false en caso contrario*/
  return ((num1 % num2) == 0);
}
public static void main(String[] args) {
  /* Determina si un numero es par */
  Scanner entrada = new Scanner(System.in);
  int numero;
  System.out.println("Ingrese un número entero: ");
  numero = entrada.nextInt();
  if (numero > 0){
    if (esPrimo(numero)) 
      System.out.println("El número es primo");
    else
      System.out.println("El número no es primo");
  }
}}

Descargar Archivo Primo.java

5. Problemas REPETIR HASTA

5.1 Edad Promedio de un número indeterminado de alumnos (1 o más)

Problema:

ALGORITMO edadPromedioCI() RETORNA ∅
(* calcula la edad promedio de un
  numero indeterminado de 1 ó mas alumnos *)
 ENTERO cantAlumnos, j, edadAlumno
 REAL acumEdades
 TEXTO continuar
 acumEdades <- 0.0
 j <- 1
 REPETIR
   ESCRIBIR("Ingrese la edad del alumno" + j)
   LEER(edadAlumno)
   acumEdades <- acumEdades + edadAlumno
   ESCRIBIR("Desea ingresar un alumno? SI/N0")
   LEER(continuar)
   SI ( igual(continuar,"SI") ) ENTONCES 
      j<- j + 1
   FIN SI
 HASTA ( igual(continuar,"NO") )
 ESCRIBIR("La edad promedio es:" + acumEdades /j);
FIN ALGORITMO edadPromedioCI

package ejerciciosRepetitivas;
import java.util.Scanner;
public class EdadPromedioCI1TextoRM {
public static void main(String[] args) {
/* calcula la edad promedio de un
  numero indeterminado de 1 ó mas alumnos */
Scanner entrada = new Scanner(System.in);
int cantAlumnos, j, edadAlumno;
double acumEdades;
String continuar;
acumEdades = 0.0;
j= 1;
do  {
  System.out.println("Ingrese la edad del alumno" + j);
  edadAlumno = entrada.nextInt();
  acumEdades = acumEdades + edadAlumno;
  System.out.println("Desea ingresar un alumno? SI/N0");
  continuar = entrada.next();
  if ( continuar.equals("SI")) 
      j++;
  } while (continuar.equals("SI"));

System.out.println("La edad promedio es:" + acumEdades /j);
}
}

Descargar Archivo EdadPromedioCITextoRM.java

5.2 Obtener la cantidad de números pares ingresados por el usuarios hasta que el usuario ingrese un cero.

Problema: Solicitar al usuario números enteros, hasta que el mismo ingrese el numero cero. Determine cuántos de los números ingresados son números pares.

ALGORITMO determinarPares() RETORNA ∅
(* solicita al usuario numeros enteros hasta que
  que se ingrese un cero, finalmente 
  muestra la cantidad de numeros pares.
  El usuario ingresará al menos un
  numero distinto de cero*)
  ENTERO numero, cantPares
  LÓGICO resultado
  cantPares <- 0
  ESCRIBIR("Ingrese un número entero \n"
     + "Para finalizar ingrese un cero")
  LEER(numero)
  REPETIR 
    SI (esPar(numero)) ENTONCES
        cantPares <- cantPares + 1
    FIN SI
    ESCRIBIR("Ingrese otro número entero. "
        + "Para finalizar ingrese un cero");
    LEER(numero)
  HASTA (numero = 0)
  (* incrementamos una vez mas porque 
  el ultimo número no verificado es cero, 
  que sabemos que es par *)
  cantPares <- cantPares +1
  ESCRIBIR("La cantidad de numero pares es: " 
       + cantPares)
FIN ALGORITMO determinarPares

MODULO esPar(ENTERO num) RETORNA LOGICO
  (* determina si un numero es par o no
     num: entero recibido como parametro
     retorna verdadero si num es par, 
            falso en caso contrario*)
  RETORNAR ((num MOD 2) == 0)
FIN MODULO esPar

package ejerciciosRepetitivas;
import java.util.Scanner;

public class CantidadPares {
public static void main(String[] args) {
/* solicita al usuario numeros enteros hasta que
  que se ingrese un cero, finalmente 
  muestra la cantidad de numeros pares.
  El usuario ingresará al menos un
  numero distinto de cero*/
  Scanner entrada = new Scanner(System.in);
  int numero, cantPares;
  boolean resultado;
  cantPares = 0;
  System.out.println("Ingrese un número entero \n"
     + "Para finalizar ingrese un cero");
  numero = entrada.nextInt();
  do {
      if (esPar(numero)) {
          cantPares = cantPares + 1;
      }
      System.out.println("Ingrese otro número entero. "
                  + "Para finalizar ingrese un cero");
      numero = entrada.nextInt();
  } while (numero != 0);
  /* incrementamos una vez mas porque el ultimo número
  no verificado es cero, que sabemos que es par */
  cantPares = cantPares +1;
  System.out.println("La cantidad de numero pares es: "
          + cantPares);}

public static boolean esPar(int num) {
  /* determina si un numero es par o no
     num: entero recibido como parametro
     retorna verdadero si num es par, 
            falso en caso contrario*/
  return ((num % 2) == 0);
  }
}

Descargar Archivo CantidadPares.java

6. Pirámides

Problema: Supongamos que deseamos mostrar por pantalla una pirámide como la siguiente:
1
1 2
1 2 3
1 2 3 4

donde la cantidad de filas la determina el usuario. Construya una solución en el cual la pirámide se construye en un módulo.


ALGORITMO Ejpiramide() RETORNA ∅
(* solicita al usuario la cant de filas 
   de una pirámide y luego muestra la misma*)
   ENTERO niveles
   ESCRIBIR("Ingrese la cantidad de filas")
   LEER(niveles)
   piramide(niveles);
FIN ALGORITMO Ejpiramide

MODULO piramide(ENTERO n) RETORNA ∅
  (* construye una piramide 
     num: cantidad de filas de la piramide*)
     ENTERO fila, col;
     PARA fila = 1 HASTA n PASO 1 HACER
        PARA col = 1 HASTA fila PASO 1 HACER
           ESCRIBIR(col + " ") (* sin salto *)
        FIN PARA
        ESCRIBIR(" ") (* con salto de linea *)
     FIN PARA        
FIN MODULO piramide

import java.util.Scanner;

public class JavaApplication36 {

public static void piramide(int n) {
  //  construye una piramide 
  //  num: cantidad de filas de la piramide
  int fila, col;
  for (fila = 1; fila <= n; fila++) {
      for (col = 1; col <= fila; col++) {
         System.out.print(col + " ");
      }
      System.out.println(" ");
     }
  }

public static void main(String[] args) {
  // Solicita al usuario la cant de filas 
  // de una pirámide y luego muestra la misma
  Scanner s = new Scanner(System.in);
  int niveles;
  System.out.println("ingrese la cantidad 
                     de filas");
  niveles = s.nextInt();
  piramide(niveles);
}

Ejercicio: Introduzca cambios al código anterior de tal forma que el algoritmo muestra una pirámide solo si la cantidad de filas es inferior a 10, y en caso contrario muestre un mensaje de error.

Ejercicio: Imagina más pirámides y para cada una de ellas, detalla el pseudocódigo y luego implementa en JAVA.

7. Videos Youtube

Video 2 sobre Estructura Repetitiva MIENTRAS y REPETIR HASTA (clase del Lunes 07 de Junio):
Video 2 sobre Estructura Repetitiva PARA y MIENTRAS (clase del Lunes 31 de Mayo):

Apunte: Estructura de Control Repetitiva

RPA- Dr.Luis Reynoso

01 abril, 2023