Ejemplo 6 - Utilización de “for”

Objetivo

Comprender la mecánica de funcionamiento del ciclo "for"

Enunciado

Escriba instrucciones utilizando el ciclo "for" para llevar a cabo las acciones indicadas en cada caso.

Solución

CASO 1: Imprimir números del 0 al 9

/**
       * Contador es una clase que muestra el uso de la estructura de repetición        for 
       */
       public class Contador {
        public static void main(String argv[]){
         // Ejemplo de un ciclo for controlado por un contador
         // El contador inicia con el valor 0 
         for (int contador = 0 ; contador < 10 ; contador++)
         {
          System.out.println(" " + contador);
         }
          System.exit(0);
        }
       }

La solución, consta de un ciclo for, que imprime la variable contador sobre la cual realiza las iteraciones, la condición puede variar, ya que contador, puede iniciar en 1 y terminar cuando sea igual que 9.

La salida es la siguiente:

CASO 2: Imprimir números de 2 en 2 a partir de 2 hasta llegar a 40

/**
       * Contador es una clase que muestra el uso de la estructura de repetici&oacute;n        for 
       */
       public class ContadorHasta40 {
        public static void main(String argv[]){
         // Ejemplo de un ciclo for controlado por un contador
         // El contador inicia con el valor 0 
        for (int contador = 2 ; contador <= 40 ; contador+=2)
        {
         System.out.println(" " + contador);
        }
        System.exit(0);
        }
       }

La solución, consta de un ciclo for, que imprime la variable contador sobre la cual realiza las iteraciones, la condición puede variar al igual que en el caso anterior, la solución presentada es de las más simples para este tipo de ejercicios.

La salida es la siguiente:

CASO 3: Calcular la suma de los números impares entre 1 y 100 e imprimir el resultado.

/**
       * SumadorImpares es una clase que muestra el uso de la estructura de *repetici&oacute;n        for
       * combinado con una estructura de condici&iacute;n if
       */
       public class SumadorImpares {
       public static void main(String argv[]){
       // Ejemplo de un ciclo for controlado por un contador
       // El contador inicia con el valor 0 
       int resultado = 0;
       for (int contador = 1 ; contador <=100; contador++)
       {
       if( (contador%2) != 0 ){
       resultado += contador;
       }
       }
       System.out.println("El resultado es:" + resultado);
       System.exit(0);
       }
       }

La solución, consta de un ciclo for, que imprime la variable resultado, el cual es un acumulador del resultado de la suma de los números impares. Para saber si un número es impar, se utiliza el operador módulo.

La salida es la siguiente:

CASO 4: Producir todas las posibles combinaciones formadas por tres números de 1 a 5.

/**
       * Combinador es una clase que muestra el uso de la estructura de repetici&oacute;n        for 
       */
       public class Combinador {
       public static void main(String argv[]){
       // Ejemplo de un ciclo for controlado por un contador
       // El contador inicia con el valor 0 
       int resultado = 0;
       for (int contador1 = 1; contador1 <=5; contador1++)
       {
       for(int contador2 = 1; contador2 <=5; contador2++){
       for(int contador3 = 1; contador3 <=5; contador3++){
       System.out.println(contador1 +""+ contador2 +""+ contador3);
       }
       }
       } 
       System.exit(0);
       }
       }

La solución, consta de tres ciclo for anidados, cada uno representa una de las columnas de la combinación.

La salida es la siguiente:

CASO 5: Contar en cuenta regresiva de 10 en 10, desde 500 hasta llegar a 100

/**
       * ContadorRegresivo es una clase que muestra el uso de la estructura de        repetici&oacute;n for 
       */
       public class ContadorRegresivo {
       public static void main(String argv[]){
       // Ejemplo de un ciclo for controlado por un contador
       // El contador inicia con el valor 0 
       for (int contador = 500 ; contador >= 100 ; contador-=10)
       {
       System.out.println(" " + contador);
       }
       System.exit(0);
       }
       }

La solución, consta de un ciclo for, que imprime la variable contador sobre la cual realiza las iteraciones, observe cómo en este ejemplo en lugar de incrementar la variable para que alcance la condición de parada, se decrementa.

La salida es la siguiente:

CASO 6: Observar el funcionamiento del "break" al ser invocado dentro de un ciclo

/**
       * CicloBreak es una clase que muestra el uso de la estructura de repetici&oacute;n        for 
       */
       public class CicloBreak {
       public static void main(String argv[]){
       // EJEMPLO DE LA MECANICA DEL BREAK
       int contador = 0; // inicialización.
       while (contador < 10) { // condición.
       if (contador == 5){
       break;
       }
       System.out.print(" " + contador); // bloque.
       contador++; // actualización.
       }
       }
       }

La solución, consta de un ciclo while, que imprime la variable contador sobre la cual realiza las iteraciones, la condición de parada en este caso no es única, ya que dentro del ciclo, se controla con un if y un break otra condición (contador es igual a 5).

El enunciado sería el siguiente:

"while ((contador < 10)&&(contador != 5))" lo cual elimina el if que se encuentra dentro del cuerpo del while.

La salida es la siguiente:

CASO 7: Observar el funcionamiento del "continue" al ser invocado dentro de un ciclo

       /**
       * CicloContinue es una clase que muestra el uso de la estructura de repetici&oacute;n        for 
       */
       public class CicloContinue {
       public static void main(String argv[]){
       // EJEMPLO DE LA MECANICA DEL CONTINUE
       int contador = 0; // inicialización.
       while (contador < 10) { // condición.
       if (contador == 5){
       contador++; // actualización. Note lo que sucede si quita esta instrucción
       continue;
       }
       System.out.print(" " + contador); // bloque.
       contador++; // actualización.
       } 
       }
       }

La solución es básicamente, un ciclo while en el cual cuando el contador es igual a 5, no lo imprime, en el resto de los casos y mientras sea menor que 10 lo muestra en pantalla.

La salida es la siguiente:

CASO 8: Utilizar un ciclo for para calcular una aproximación del valor de PI utilizando la formula 4 - 4/3+ 4/5 - 4/7 + 4/9 etc...

import javax.swing.*;
       import java.math.*;        
/**
* Es un aplicación que despliega en pantalla el valor aproximado          de pi, en un aumento de términos, en una fórmula determinada.          
*/
public class pi {
         public static void main(String[] args) {
         //para dar el valor aproximado de pi, a través del valor que el          usuario digite, el cual determina la lomgitud de la serie a ejecutar;          la misma reponde a la formula del libro, ejer.517.
         /**
         * contador contiene el valor de n. 
         */
         int contador = 0;
         /**
         * numero contiene el n&uacute;mero de t&eacute;rminos que ha indicado          el usuario. 
         */
         int numero;
         /**
         * numeroString contiene la cantidad de n que ha indicado el usuario. 
         */ 
         String numeroString;
         /**
         * resultado es un acumulador para el valor de Pi. 
         */ 
         double resultado = 0; 
         /**
         * denominador es el valor del denominador para calcular Pi. 
         */ 
         float denominador = 0;
         /**
         * signo indica si es una suma o una resta. 
         */ 
         double signo = 0;
         
         numeroString = JOptionPane.showInputDialog("Digite n términos          para la formula de pi");
         numero = Integer.parseInt( numeroString );
         
         for(int i = 0; (i <= (numero - 1)); i++){
         //calcule el signo
         signo = Math.pow(-1,i);
         //calcule el denominador
         denominador = ((2*i)+1);
         //calcule el resultado para esta n
         resultado = resultado + (signo * (4/denominador));
         //cambio de n
         contador++;
         System.out.println("Si n =" +(Integer.toString(contador))+ "          pi es " + resultado );
         }
         System.exit (0);
         }
         }

Esta solución se basa en la serie que se utiliza para calcular Pi, de ahí el cálculo del signo, los denominadores, etc.

La salida sería la siguiente:

CASO 9: HAGA UN PROGRAMA QUE CUENTE DE 0 A 9 UTILIZANDO UN FOR Y COMPARE CON EL CÓDIGO DE UN WHILE QUE HAGA LO MISMO

/**
       * WhileVsFor es una clase que muestra el uso de las estructura de repetici&oacute;n        for y while
       * a la vez se realiza una comparaci&oacute;n entre ambas estructuras.        
       */
       public class WhileVsFor {
       public static void main(String argv[]){
       // COMPARACION ENTRE UN FOR Y UN WHILE 
       int contador = 0; // inicialización.
       /* Ciclo while, que cuenta desde 0 hasta 9 */
       System.out.println("Ciclo While");
       while (contador < 10) { // condición.
       System.out.print(" " + contador); // bloque.
       contador++; // actualización.
       }
 
       /* Ciclo For que cuenta desde 0 hasta 9 */
       System.out.println("\nCiclo For");
       for (contador = 0 ; contador < 10 ; contador++) {
       System.out.print(" " + contador);
       }
       }
       }

 

La solución consta de un ciclo while y un ciclo for, con el mismo fin, lo que se trata de evidenciar es cómo ambas estructuras difieren, en forma y contenido.

La salida es la siguiente:

 

Código Fuente