Estructura repetitiva: haz que la computadora repita por ti (Mientras, Repetir, Para)

La idea de hoy en una frase

No repitas tú: haz que la computadora repita por ti. Escribes una instrucción UNA vez, le dices cuántas veces o hasta cuándo, y ella la ejecuta sin cansarse, sin distraerse y sin equivocarse. Eso es un ciclo (o bucle).

Ya piensas en ciclos (aunque no lo sabías)

Los tres ciclos y cuándo usar cada uno

Los dos ayudantes de todo ciclo

• Contador → cuenta CUÁNTAS vueltas. Sube de 1 en 1. Como el torniquete del metro. En código: contador <- contador + 1.
• Acumulador → junta VALORES (no cuenta vueltas). Como el total de la caja del súper. En código: suma <- suma + calificacion.

🔑 Mismo acumulador, distinto trabajo: si sumas sacas un promedio; si multiplicas (fact <- fact * i) sacas un factorial (5! = 1×2×3×4×5 = 120).

⚠️ Regla de oro: el acumulador empieza en 0 antes del ciclo (y el de multiplicar, en 1). Si lo dejas sin valor, sumas sobre basura y el resultado sale loco.

Mini-glosario: ciclo/bucle (repetir una instrucción varias veces) · iteración (cada vuelta del ciclo) · condición (la pregunta lógica que decide si se sigue repitiendo) · contador (cuenta vueltas) · acumulador (junta valores).

✅ Antes de seguir: ¿puedes nombrar los 3 ciclos? ¿Cuál puede dar 0 vueltas y cuál siempre da al menos 1? ¿Qué diferencia hay entre contador y acumulador?

Misión: resolver el MISMO problema (promedio de N calificaciones) con los 3 ciclos

Hazlo al mismo tiempo que el video, en PSeInt. Al final los tres deben darte EXACTAMENTE el mismo promedio.

Lo que todos comparten (los dos ayudantes)

• suma = acumulador → empieza en 0.
• i = contador → empieza en 1 (lo usan Mientras y Repetir; el Para lo lleva solo).

1) Con MIENTRAS (revisa la condición ANTES)

Proceso PromedioMientras
    Definir n, i Como Entero;
    Definir calif, suma, promedio Como Real;
    Escribir "¿Cuántas calificaciones vas a promediar?";
    Leer n;
    suma <- 0;        // el acumulador arranca en cero
    i <- 1;           // el contador arranca en uno
    Mientras i <= n Hacer
        Escribir "Escribe la calificación ", i;
        Leer calif;
        suma <- suma + calif;   // crece el acumulador
        i <- i + 1;             // ¡avanza el contador TÚ!
    FinMientras
    Si n > 0 Entonces
        promedio <- suma / n;
        Escribir "Tu promedio es: ", promedio;
    SiNo
        Escribir "No ingresaste calificaciones: no hay promedio.";
    FinSi
FinProceso

⚠️ Si olvidas i <- i + 1, i se queda en 1 para siempre → ciclo infinito.

2) Con REPETIR (revisa la condición DESPUÉS — siempre da ≥1 vuelta)

Mismo cuerpo; solo cambia el ciclo:

    Repetir
        Escribir "Escribe la calificación ", i;
        Leer calif;
        suma <- suma + calif;
        i <- i + 1;
    Hasta Que i > n

3) Con PARA (el más corto: el contador lo lleva el ciclo)

    suma <- 0;
    Para i <- 1 Hasta n Con Paso 1 Hacer
        Escribir "Escribe la calificación ", i;
        Leer calif;
        suma <- suma + calif;
    FinPara

🔎 Fíjate qué NO escribiste aquí: el i <- i + 1. El Para lo hace solo.

Corre y compara

1. Ejecuta los tres con tus calificaciones reales → mismo promedio en los tres.
2. Genera el diagrama de flujo automático y observa la flecha que regresa = la repetición.

✅ Checklist (déjalo CORRIENDO, no solo leído):

• Los 3 programas dan el mismo promedio con mis calificaciones
• Identifiqué cuál revisa la condición ANTES (Mientras) y cuál DESPUÉS (Repetir)
• Vi que el Para NO necesita i <- i + 1
• Generé el diagrama de flujo de al menos uno

Tu entregable: un programa en PSeInt con un ciclo propio y datos TUYOS

Ahora lo haces tú solo. No es examen: es usar un ciclo de verdad sobre algo tuyo. Tu programa saldrá distinto al de tus compañeros porque usa TUS datos.

Parte A — Elige UN problema (solo uno)

1. Tu promedio: pide tus calificaciones reales de este semestre y saca el promedio (acumulador que suma).
2. La tabla de TU número de lista: si tu número de lista es 14, imprime la tabla del 14, del 14×1 al 14×10 (ciclo Para: en cada vuelta calculas e imprimes 14×i).
3. Factorial: calcula el factorial de un número del 1 al 10 (acumulador que multiplica; empieza en 1, no en 0).

Parte B — Constrúyelo con la regla del ciclo

• Usa cualquiera de los tres ciclos (Para, Mientras o Repetir), el que mejor le quede a tu problema.
• Debe llevar un contador o un acumulador (di cuál en un comentario).
• Inicializa bien: acumulador que suma → en 0; acumulador que multiplica → en 1.

Parte C — La transformación final (la parte que solo tú puedes hacer)

Dentro del pseudocódigo, en la primera línea, escribe un comentario con TUS datos reales:

// Programa de: <Tu Nombre y Apellido> | Lista: <tu número de lista> | Fecha: <fecha de hoy>

• Si elegiste el problema 1, usa tus calificaciones reales. Si elegiste el 2, usa tu número de lista como el número de la tabla.
• Ejecuta el programa y toma una captura de pantalla de la salida (debe mostrar tus datos) y del diagrama de flujo que PSeInt genera solo.
• En una línea, responde: ¿qué ciclo elegiste y por qué ese y no otro? (con tus palabras).

Entrega — nombre, archivos y correo

1. Guarda el pseudocódigo como: Nombre_Apellido_Grupo_Ciclos.psc (usa TUS datos; ejemplo solo de FORMA, NO lo copies: Ana_Lopez_1IV5_Ciclos.psc).

2. Exporta el diagrama de flujo (PNG) que PSeInt genera.

3. Pega en tu documento: el pseudocódigo + las dos capturas (salida y diagrama) + tu línea de “qué ciclo elegí y por qué”.

4. Súbelo a tu carpeta de Drive y compártelo con el correo asignado a tu grupo:

   ---

✅ Checklist final:

• Un ciclo funcionando en PSeInt (corre sin ciclo infinito)
• Lleva contador o acumulador, bien inicializado (0 si suma, 1 si multiplica)
• Comentario de la línea 1 con mi nombre, número de lista y fecha de hoy
• Mis datos reales (calificaciones / número de lista) dentro del programa
• Capturas de la salida y del diagrama de flujo
• Línea “qué ciclo elegí y por qué” con mis palabras
• Archivo Nombre_Apellido_Grupo_Ciclos.psc compartido al correo del grupo

📬 Correo de entrega de mi grupo: ________________________
Usa el correo asignado a tu grupo. Tu profesor te lo da en clase — anótalo aquí.

El cierre: de programador a juez que verifica

Ya construiste tu ciclo. Ahora la IA te ayuda a entenderlo… y TÚ la verificas corriendo el programa.

🤖 Mini-truco de IA de la semana (nivel: evaluar)

La regla del curso: pídele ayuda con tu trabajo, no que te haga el trabajo. Hoy la IA explica y tú juzgas con la fuente real (PSeInt).

1. Prompt sugerido (pega tu pseudocódigo y pregunta):

   “Sin reescribir mi programa, dime paso a paso qué va a mostrar este ciclo y si se detiene o no.”

2. Verifica contra la fuente real: ejecuta tu programa en PSeInt y compara con lo que dijo la IA.

3. Tu veredicto (agrégalo al final de tu entregable del Bloque 3):

• ✅ Qué SÍ pedirle: que te EXPLIQUE tu error, que “corra” tu lógica en palabras, que te diga por qué un ciclo no termina.
• ❌ Qué NO: que te escriba el programa; que le creas sin ejecutar. La IA a veces afirma con total seguridad que un ciclo se detiene cuando en PSeInt se queda infinito — por eso verificas.

💡 Por qué TÚ decides: PSeInt corre el programa de verdad; la IA solo opina sobre él. Tú tienes la fuente real (el botón de ejecutar). El juez eres tú.

Cierra anotando el correo asignado a tu grupo en la línea de abajo.

📬 Correo de entrega de mi grupo: ________________________
Usa el correo asignado a tu grupo. Tu profesor te lo da en clase — anótalo aquí.