Bucles en C — ejercicios para dominar for, while y do…while
Los bucles en C ejercicios con solución cierran este bloque. Ya viste la teoría y practicaste con programas reales. Ahora toca resolver por tu cuenta con gedit y gcc en Fedora. Cuatro ejercicios en tres niveles con especial atención al error más silencioso de los bucles, el punto y coma después del for o while que crea un bucle vacío sin que el compilador avise.
No olvides pegar tu código en pythontutor.com para llevar tu aprendizaje al siguiente nivel.
Tabla de Contenidos
Bucles en C ejercicios — Nivel Básico
Ejercicio 1 — Conversor de números a palabras
Escribe un programa que pida un número entre 1 y 10 y lo convierta a su palabra en español. Usa un switch dentro de un do...while que repita hasta que el usuario introduzca 0 para salir.
La salida debe ser:
=== CONVERSOR NÚMERO A PALABRA === Introduce un número (1-10, 0 para salir): 5 5 → cinco Introduce un número (1-10, 0 para salir): 3 3 → tres Introduce un número (1-10, 0 para salir): 15 Error: introduce un número entre 0 y 10 Introduce un número (1-10, 0 para salir): 0 Hasta luego
💡 Pista — el error del punto y coma:
/* MAL — bucle vacío infinito */
while (numero != 0);
{
/* este bloque nunca se ejecuta */
}
/* BIEN */
while (numero != 0) {
/* cuerpo del bucle */
}
El ; después del while hace que el bucle sea vacío — si numero no es 0 el programa se queda colgado para siempre. Compila sin error y sin warning. Es el bug más difícil de ver en bucles.
Ejercicio 2 — Juego de piedra papel tijera con reintentos
Escribe el juego de piedra papel tijera donde el jugador elige su opción con números (1=piedra, 2=papel, 3=tijera) y la máquina siempre elige 2 (papel). El jugador puede jugar tantas rondas como quiera.
La salida debe ser:
=== PIEDRA PAPEL TIJERA === 1. Piedra 2. Papel 3. Tijera 0. Salir Ronda 1 Tu elección: 1 Tú: Piedra | Máquina: Papel → Pierde la máquina gana Ronda 2 Tu elección: 2 Tú: Papel | Máquina: Papel → Empate Ronda 3 Tu elección: 0 --- Resultado final --- Rondas jugadas: 2 Victorias: 0 | Derrotas: 1 | Empates: 1
💡 Pistas:
- Usa
whilecon una variablejugando = 1como flag de control - Para la elección de la máquina usa simplemente
maquina = 2— sinrand()que aún no hemos visto - El resultado de cada ronda lo determinas con
if/else ifcomparandojugadorymaquina - El error del punto y coma es especialmente peligroso aquí —
while (jugando);bloquea el programa desde el primer momento
Bucles en C ejercicios — Nivel Intermedio
Ejercicio 3 — Calculadora de números primos hasta n
Escribe un programa que pida un número n y muestre todos los números primos desde 2 hasta n. Un número es primo si solo es divisible entre 1 y él mismo.
La salida con n=30 debe ser:
Hasta qué número buscar primos (2-1000): 30 Primos hasta 30: 2 3 5 7 11 13 17 19 23 29 Total de primos encontrados: 10
💡 Pistas:
- Necesitas dos bucles anidados — el externo recorre los números de 2 a n, el interno comprueba si cada número es primo dividiendo entre todos los números de 2 hasta él mismo
- Un número
xes primo si ningún número entre 2 yx-1lo divide exactamente — usax % i == 0para comprobar - Usa una variable
es_primo = 1al principio de cada número y ponla a 0 si encuentras un divisor — luegobreakpara salir del bucle interno - El error del punto y coma en el bucle interno
for (i = 2; i < x; i++);hace que nunca encuentres divisores y todos los números parezcan primos
Bucles en C ejercicios — Desafío Final
Ejercicio 4 — Calculadora interactiva completa
Combina todo lo aprendido en este bloque, bucles, condicionales y tipos. Escribe una calculadora interactiva que:
- Muestre un menú con operaciones (suma, resta, multiplicación, división, módulo, potencia, salir)
- Pida dos números con validación, el segundo no puede ser 0 para división y módulo
- Muestre el resultado
- Pregunte si quiere hacer otra operación
- Muestre un resumen al salir con cuántas operaciones hizo y cuál fue el resultado más grande
=== CALCULADORA INTERACTIVA === 1. Suma 2. Resta 3. Multiplicar 4. Dividir 5. Módulo 6. Potencia 0. Salir Operación: 1 Número A: 15 Número B: 7 15.00 + 7.00 = 22.00 ¿Otra operación? (s/n): s Operación: 4 Número A: 10 Número B: 0 Error: no se puede dividir entre cero Número B: 3 10.00 / 3.00 = 3.3333 ¿Otra operación? (s/n): n --- Resumen --- Operaciones realizadas: 2 Mayor resultado obtenido: 22.00
💡 Pistas:
- Usa
do...whilepara el bucle principal — siempre haces al menos una operación - Para la validación de B en división y módulo usa otro
do...whileanidado - Guarda el mayor resultado con
if (resultado > mayor) mayor = resultado - Para la potencia usa un
for— multiplicabasepor sí mismaexponenteveces - El error del punto y coma en el
do...whileprincipaldo;haría que el programa terminase inmediatamente sin ejecutar nada
Soluciones Comentadas
Solución Ejercicio 1:
#include <stdio.h>
int main() {
int numero;
printf("=== CONVERSOR NÚMERO A PALABRA ===\n");
do {
printf("Introduce un número (1-10, 0 para salir): ");
scanf("%d", &numero);
if (numero == 0) {
printf("Hasta luego\n");
} else if (numero < 0 || numero > 10) {
printf("Error: introduce un número entre 0 y 10\n");
} else {
printf("%d → ", numero);
switch (numero) {
case 1: printf("uno\n"); break;
case 2: printf("dos\n"); break;
case 3: printf("tres\n"); break;
case 4: printf("cuatro\n"); break;
case 5: printf("cinco\n"); break;
case 6: printf("seis\n"); break;
case 7: printf("siete\n"); break;
case 8: printf("ocho\n"); break;
case 9: printf("nueve\n"); break;
case 10: printf("diez\n"); break;
}
printf("\n");
}
} while (numero != 0);
return 0;
}
Solución Ejercicio 2:
#include <stdio.h>
int main() {
int jugador, maquina = 2;
int jugando = 1;
int ronda = 0;
int victorias = 0, derrotas = 0, empates = 0;
printf("=== PIEDRA PAPEL TIJERA ===\n");
printf("1. Piedra 2. Papel 3. Tijera 0. Salir\n\n");
while (jugando) {
ronda++;
printf("Ronda %d\n", ronda);
/* Pedir jugada válida */
do {
printf("Tu elección: ");
scanf("%d", &jugador);
if (jugador < 0 || jugador > 3) {
printf("Error: elige entre 0 y 3\n");
}
} while (jugador < 0 || jugador > 3);
if (jugador == 0) {
jugando = 0;
ronda--; /* no cuenta como ronda */
break;
}
/* Mostrar jugadas */
printf("Tú: ");
switch (jugador) {
case 1: printf("Piedra"); break;
case 2: printf("Papel"); break;
case 3: printf("Tijera"); break;
}
printf(" | Máquina: Papel\n");
/* Determinar resultado */
if (jugador == maquina) {
printf("→ Empate\n");
empates++;
} else if ((jugador == 1 && maquina == 3) ||
(jugador == 2 && maquina == 1) ||
(jugador == 3 && maquina == 2)) {
printf("→ ¡Ganaste!\n");
victorias++;
} else {
printf("→ Pierde — la máquina gana\n");
derrotas++;
}
printf("\n");
}
printf("--- Resultado final ---\n");
printf("Rondas jugadas: %d\n", ronda);
printf("Victorias: %d | Derrotas: %d | Empates: %d\n",
victorias, derrotas, empates);
return 0;
}
Solución Ejercicio 3:
#include <stdio.h>
int main() {
int n, x, i, es_primo, total = 0;
do {
printf("Hasta qué número buscar primos (2-1000): ");
scanf("%d", &n);
if (n < 2 || n > 1000) {
printf("Error: introduce un número entre 2 y 1000\n");
}
} while (n < 2 || n > 1000);
printf("\nPrimos hasta %d:\n", n);
for (x = 2; x <= n; x++) {
es_primo = 1;
for (i = 2; i < x; i++) {
if (x % i == 0) {
es_primo = 0;
break; /* sale del bucle interno */
}
}
if (es_primo) {
printf("%d ", x);
total++;
}
}
printf("\n\nTotal de primos encontrados: %d\n", total);
return 0;
}
Solución Ejercicio 4:
#include <stdio.h>
int main() {
int opcion;
float a, b, resultado, mayor = 0;
char continuar;
int operaciones = 0;
int primera = 1;
printf("=== CALCULADORA INTERACTIVA ===\n");
do {
printf("1. Suma 2. Resta\n");
printf("3. Multiplicar 4. Dividir\n");
printf("5. Módulo 6. Potencia\n");
printf("0. Salir\n\n");
do {
printf("Operación: ");
scanf("%d", &opcion);
if (opcion < 0 || opcion > 6) {
printf("Error: elige entre 0 y 6\n");
}
} while (opcion < 0 || opcion > 6);
if (opcion == 0) break;
printf("Número A: ");
scanf("%f", &a);
/* Validar B para división y módulo */
do {
printf("Número B: ");
scanf("%f", &b);
if ((opcion == 4 || opcion == 5) && b == 0) {
printf("Error: no se puede dividir entre cero\n");
}
} while ((opcion == 4 || opcion == 5) && b == 0);
/* Calcular */
switch (opcion) {
case 1:
resultado = a + b;
printf("%.2f + %.2f = %.2f\n\n", a, b, resultado);
break;
case 2:
resultado = a - b;
printf("%.2f - %.2f = %.2f\n\n", a, b, resultado);
break;
case 3:
resultado = a * b;
printf("%.2f * %.2f = %.2f\n\n", a, b, resultado);
break;
case 4:
resultado = a / b;
printf("%.2f / %.2f = %.4f\n\n", a, b, resultado);
break;
case 5:
resultado = (int)a % (int)b;
printf("%d %% %d = %.0f\n\n", (int)a, (int)b, resultado);
break;
case 6: {
resultado = 1;
int exp = (int)b;
int j;
for (j = 0; j < exp; j++) {
resultado *= a;
}
printf("%.2f ^ %d = %.2f\n\n", a, exp, resultado);
break;
}
}
operaciones++;
/* Actualizar mayor resultado */
if (primera || resultado > mayor) {
mayor = resultado;
primera = 0;
}
printf("¿Otra operación? (s/n): ");
scanf(" %c", &continuar);
printf("\n");
} while (continuar == 's');
printf("--- Resumen ---\n");
printf("Operaciones realizadas: %d\n", operaciones);
if (operaciones > 0) {
printf("Mayor resultado obtenido: %.2f\n", mayor);
}
return 0;
}
Chuletario — Bucles en C
/* ============================================
CHULETARIO — Bucles en C
Sergio Learns · sergiolearns.com
============================================ */
/* FOR — número conocido de iteraciones */
int i;
for (i = 0; i < n; i++) {
/* cuerpo */
}
/* Equivalentes a range() de Python */
for (i = 0; i < n; i++) /* range(n) */
for (i = 1; i <= n; i++) /* range(1, n+1) */
for (i = 0; i < n; i += 2) /* range(0, n, 2) */
for (i = n; i > 0; i--) /* range(n, 0, -1) */
/* WHILE — condición variable */
while (condicion) {
/* cuerpo */
/* actualizar variable — no olvides esto */
}
/* DO...WHILE — al menos una ejecución */
do {
/* cuerpo */
} while (condicion); /* ; obligatorio al final */
/* PATRÓN validación con do...while */
do {
printf("Introduce dato: ");
scanf("...", &dato);
} while (/* dato no válido */);
/* PATRÓN serie acumulativa con for */
acumulado = valor_inicial; /* inicializa siempre */
for (i = 1; i <= n; i++) {
acumulado += i; /* o *= o cualquier operación */
}
/* PATRÓN flag de control con while */
int encontrado = 0;
while (!encontrado) {
/* lógica */
if (condicion_salida) {
encontrado = 1;
}
}
/* BREAK — salir del bucle inmediatamente */
for (i = 0; i < n; i++) {
if (condicion) break; /* sale del bucle */
}
/* CONTINUE — saltar al siguiente ciclo */
for (i = 0; i < n; i++) {
if (condicion) continue; /* salta el resto del cuerpo */
}
/* BUCLES ANIDADOS */
int i, j;
for (i = 0; i < filas; i++) {
for (j = 0; j < columnas; j++) {
/* break aquí solo sale del bucle interno */
}
}
/* BUCLE INFINITO */
while (1) { ... } /* Ctrl+C para cancelar */
for (;;) { ... }
/* ERRORES TÍPICOS */
/* 1. Punto y coma después del for — bucle vacío */
for (i = 0; i < n; i++); /* bucle vacío — ; es el cuerpo */
{ printf("%d\n", i); } /* se ejecuta una vez al final */
/* 2. Punto y coma después del while — bucle infinito */
while (condicion); /* bucle vacío infinito */
{ /* nunca se ejecuta */ }
/* 3. No inicializar acumulador */
long suma; /* valor basura */
suma = 0; /* siempre inicializa antes del bucle */
/* 4. No actualizar variable en while */
int x = 0;
while (x < 5) {
printf("%d\n", x);
/* falta x++ → bucle infinito */
}
/* 5. Condición imposible en do...while */
} while (x < 0 && x > 10); /* imposible — usa || */
} while (x < 0 || x > 10); /* correcto */
/* FOR VS WHILE VS DO...WHILE */
/* for → iteraciones conocidas, rangos numéricos */
/* while → condición variable, número desconocido */
/* do...while → al menos una ejecución, validación */
Loops in C — exercises to master for, while and do…while
Basic Level
Exercise 1 — Number to word converter
Ask for a number between 1 and 10 and convert it to its English word. Use switch inside a do...while that repeats until the user enters 0 to quit.
💡 Hint — the semicolon mistake:
/* WRONG — infinite empty loop */
while (number != 0);
{ /* never executes */ }
/* RIGHT */
while (number != 0) {
/* loop body */
}
Exercise 2 — Rock paper scissors with retries
Player chooses with numbers (1=rock, 2=paper, 3=scissors), machine always picks 2 (paper). Player can play as many rounds as they want. Show final score.
💡 Hints: Use while with playing = 1 flag. Semicolon after while (playing); blocks the program immediately, one of the hardest bugs to spot.
Intermediate Level
Exercise 3 — Prime numbers calculator
Ask for n and show all primes from 2 to n. Two nested loops, outer iterates numbers, inner checks divisibility.
💡 Hints: Use is_prime = 1 flag, set to 0 when divisor found, then break. Semicolon after inner for (i=2; i<x; i++); means divisors are never found and all numbers appear prime.
Final Challenge
Exercise 4 — Complete interactive calculator
Menu with 6 operations plus exit. Validate both inputs. Track operation count and highest result. Show summary on exit.
💡 Hints: do...while for main loop. Nested do...while for B validation on division. if (result > highest) highest = result. For power use for loop multiplying base by itself.
(Solutions same as Spanish version above)
Cheat sheet — Loops in C
/* ============================================
CHEAT SHEET — Loops in C
Sergio Learns · sergiolearns.com
============================================ */
/* FOR */
int i;
for (i = 0; i < n; i++) { ... }
/* range() equivalents */
for (i = 0; i < n; i++) /* range(n) */
for (i = 1; i <= n; i++) /* range(1, n+1) */
for (i = 0; i < n; i += 2) /* range(0, n, 2) */
for (i = n; i > 0; i--) /* range(n, 0, -1) */
/* WHILE */
while (condition) {
/* body */
/* update variable */
}
/* DO...WHILE */
do {
/* body */
} while (condition); /* ; mandatory */
/* VALIDATION PATTERN */
do {
scanf("...", &data);
} while (/* invalid */);
/* ACCUMULATOR PATTERN */
total = 0; /* always initialise */
for (i = 1; i <= n; i++) {
total += i;
}
/* FLAG PATTERN */
int found = 0;
while (!found) {
if (exit_condition) found = 1;
}
/* BREAK / CONTINUE */
if (cond) break; /* exit loop */
if (cond) continue; /* skip to next iteration */
/* COMMON MISTAKES */
for (i = 0; i < n; i++); /* empty loop — ; after for */
while (condition); /* infinite empty loop */
/* Always initialise accumulators before loop */
/* Always update variable in while */
/* Use || not && in do...while validation */
/* WHEN TO USE EACH */
/* for → known iterations, numeric ranges */
/* while → unknown iterations, variable condition */
/* do...while → at least one execution, input validation */
