10 Ejercicios resueltos de bucles en Java

public class ContarHastaDiez {
    public static void main(String[] args) {
        System.out.println("Números del 1 al 10:");

        // Usamos un bucle for porque sabemos el inicio (1) y el fin (10).
        // i: nuestro contador, inicializado en 1.
        // i <= 10: la condición que se verifica antes de cada iteración. El bucle continúa mientras i sea menor o igual a 10.
        // i++: el incremento que se ejecuta después de cada iteración (aumenta i en 1).
        for (int i = 1; i <= 10; i++) {
            // Imprimimos el valor actual del contador en cada iteración.
            System.out.println(i);
        }
    }
}

public class SumaNaturales {
    public static void main(String[] args) {
        int n = 5; // El número hasta el cual queremos sumar.
        int suma = 0; // Variable para almacenar la suma acumulada, inicializada en 0.

        // Bucle for para iterar desde 1 hasta n.
        for (int i = 1; i <= n; i++) {
            // En cada iteración, añadimos el valor actual de 'i' a la variable 'suma'.
            suma = suma + i; // También se puede escribir como: suma += i;
        }

        // Imprimimos el resultado final después de que el bucle ha terminado.
        System.out.println("La suma de los primeros " + n + " números naturales es: " + suma); // Salida: 15
    }
}

public class TablaMultiplicar {
    public static void main(String[] args) {
        int numeroTabla = 7; // El número del cual queremos la tabla.

        System.out.println("Tabla de multiplicar del " + numeroTabla + ":");

        // Bucle for para iterar desde 1 hasta 10 (los multiplicadores).
        for (int i = 1; i <= 10; i++) {
            // Calculamos el resultado de la multiplicación en cada paso.
            int resultado = numeroTabla * i;
            // Imprimimos la línea de la tabla con formato.
            System.out.println(numeroTabla + " x " + i + " = " + resultado);
        }
    }
}

public class NumerosParesWhile {
    public static void main(String[] args) {
        int numero = 2; // Empezamos con el primer número par.

        System.out.println("Números pares hasta 20:");

        // El bucle while continúa mientras 'numero' sea menor o igual a 20.
        while (numero <= 20) {
            // Imprimimos el número par actual.
            System.out.println(numero);
            // Incrementamos 'numero' en 2 para pasar al siguiente número par.
            // Esto asegura que la condición (numero <= 20) eventualmente sea falsa.
            numero = numero + 2; // o numero += 2;
        }
    }
}

import java.util.Scanner; // Necesario para leer la entrada del usuario (aunque aquí lo simularemos)

public class AdivinaNumero {
    public static void main(String[] args) {
        int numeroSecreto = 42;
        int numeroIngresado; // No necesita valor inicial aquí
        Scanner scanner = new Scanner(System.in); // Objeto para leer entrada

        System.out.println("¡Adivina el número secreto!");

        // El bucle do-while ejecuta el bloque al menos una vez.
        do {
            // Pedimos al usuario que ingrese un número.
            System.out.print("Ingresa un número: ");
            numeroIngresado = scanner.nextInt(); // Lee el entero ingresado

            // Comprobación opcional dentro del bucle (podría dar pistas)
            if (numeroIngresado != numeroSecreto) {
                System.out.println("Intenta de nuevo...");
            }

        // La condición se comprueba después de ejecutar el bloque.
        // El bucle se repite mientras el número ingresado NO sea igual al secreto.
        } while (numeroIngresado != numeroSecreto);

        // Cuando el bucle termina, significa que el usuario adivinó.
        System.out.println("¡Felicidades! ¡Has adivinado el número secreto (" + numeroSecreto + ")!");
        scanner.close(); // Buena práctica cerrar el Scanner.
    }
}

public class Factorial {
    public static void main(String[] args) {
        int numero = 5; // Número del cual calcular el factorial.
        long factorial = 1; // Usamos long para evitar desbordamiento con números grandes. Se inicializa en 1.

        // Verificamos si el número es 0 o 1, cuyo factorial es 1.
        if (numero < 0) {
            System.out.println("El factorial no está definido para números negativos.");
        } else if (numero == 0) {
            System.out.println("El factorial de 0 es: 1");
        } else {
            // Bucle for para multiplicar desde el número hacia abajo hasta 1.
            // También podría ser for (int i = 1; i <= numero; i++) { factorial *= i; }
            for (int i = numero; i >= 1; i--) {
                factorial = factorial * i; // Acumulamos el producto. factorial *= i;
            }
            System.out.println("El factorial de " + numero + " es: " + factorial); // Salida: 120
        }
    }
}

*
**
***
****
*****

public class TrianguloAsteriscos {
    public static void main(String[] args) {
        int altura = 5; // Número de filas del triángulo.

        System.out.println("Triángulo de asteriscos:");

        // Bucle externo: controla las filas (desde 1 hasta la altura).
        for (int i = 1; i <= altura; i++) {
            // Bucle interno: controla los asteriscos en la fila actual.
            // Imprime 'i' asteriscos en la fila 'i'.
            for (int j = 1; j <= i; j++) {
                System.out.print("*"); // Usamos print para que los asteriscos queden en la misma línea.
            }
            // Después de imprimir los asteriscos de una fila, hacemos un salto de línea.
            System.out.println(); // Equivalente a System.out.print("\n");
        }
    }
}

public class SumaArray {
    public static void main(String[] args) {
        int[] numeros = {3, 7, 2, 8, 4}; // Nuestro array de ejemplo.
        int suma = 0; // Variable para acumular la suma.

        // Bucle for para recorrer el array.
        // 'i' actúa como índice, desde 0 hasta el último índice válido (numeros.length - 1).
        // numeros.length nos da la cantidad de elementos en el array.
        for (int i = 0; i < numeros.length; i++) {
            // Accedemos al elemento en la posición 'i' usando numeros[i].
            // Sumamos el elemento actual a la suma total.
            suma += numeros[i]; // suma = suma + numeros[i];
        }

        System.out.println("La suma de los elementos del array es: " + suma); // Salida: 24
    }
}

public class PrimerMultiploComun {
    public static void main(String[] args) {
        int numero = 1; // Empezamos a probar desde 1.

        // Usamos un bucle while(true) que se ejecutará indefinidamente
        // hasta que encontremos el número y usemos 'break' para salir.
        while (true) {
            // Verificamos si el número actual es divisible por 5 Y por 7.
            // El operador '%' (módulo) da el resto de una división. Si es 0, es divisible.
            if (numero % 5 == 0 && numero % 7 == 0) {
                System.out.println("El primer número divisible por 5 y 7 es: " + numero);
                break; // Salimos del bucle while una vez encontrado el número.
            }
            // Si no es el número buscado, pasamos al siguiente.
            numero++; // ¡Fundamental para evitar un bucle infinito!
        }
        // La ejecución continúa aquí después del break.
    }
}

public class InvertirCadena {
    public static void main(String[] args) {
        String original = "Hola";
        String invertida = ""; // Cadena vacía para construir la invertida.

        // Bucle for que recorre la cadena original desde el último carácter al primero.
        // Los índices de una cadena van de 0 a longitud-1.
        // Empezamos en el último índice: original.length() - 1.
        // Continuamos mientras el índice sea mayor o igual a 0.
        // Decrementamos el índice en cada paso: i--.
        for (int i = original.length() - 1; i >= 0; i--) {
            // Obtenemos el carácter en la posición 'i' usando charAt(i).
            // Concatenamos (añadimos) ese carácter al final de la cadena 'invertida'.
            invertida = invertida + original.charAt(i); // invertida += original.charAt(i);
        }

        System.out.println("Cadena original: " + original);
        System.out.println("Cadena invertida: " + invertida); // Salida: aloH
    }
}