Comprender la mecánica de funcionamiento del ciclo "for"
Escriba instrucciones utilizando el ciclo "for" para llevar a cabo las acciones indicadas en cada caso.
/** * 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:
/** * Contador es una clase que muestra el uso de la estructura de repetició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:
/** * SumadorImpares es una clase que muestra el uso de la estructura de *repetición for * combinado con una estructura de condicií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:
/** * Combinador es una clase que muestra el uso de la estructura de repetició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:
/** * ContadorRegresivo es una clase que muestra el uso de la estructura de repetició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:
/** * CicloBreak es una clase que muestra el uso de la estructura de repetició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:
/** * CicloContinue es una clase que muestra el uso de la estructura de repetició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:
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úmero de té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:
/** * WhileVsFor es una clase que muestra el uso de las estructura de repetición for y while * a la vez se realiza una comparació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.