• Categorías: CDYPC1BACH2627, Clases2627

1. Recordatorio: hasta ahora, solo secuencia

En el A.2 vimos que un algoritmo, en su forma más simple, es una secuencia: instrucciones que se ejecutan una detrás de otra, de arriba abajo, sin excepciones. También mencionamos el rombo del diagrama de flujo como símbolo de decisión, pero sin entrar en detalle.

Hoy rompemos esa linealidad. Hay dos mecanismos que alteran el orden normal de ejecución de una secuencia: uno permite elegir qué instrucciones se ejecutan, y otro permite repetir instrucciones sin volver a escribirlas. A eso se le llama estructuras de control.

2. ¿Qué es una estructura de control?

Una estructura de control es un mecanismo del algoritmo que decide, en tiempo de ejecución, qué instrucción se ejecuta a continuación, sin que tenga por qué ser simplemente “la siguiente de la lista”.

Hay tres tipos de estructuras de control, y entre las tres se puede construir cualquier algoritmo (es lo que se conoce como el teorema del programa estructurado):

Estructura	Qué hace	Símbolo en diagrama de flujo
Secuencial	Ejecuta las instrucciones una detrás de otra (ya la conoces)	Rectángulo + flecha
Selectiva	Elige entre dos o más caminos según se cumpla o no una condición	Rombo
Iterativa	Repite un bloque de instrucciones mientras se cumpla (o hasta que se cumpla) una condición	Rombo, con una flecha que vuelve hacia atrás

3. Estructuras selectivas: decidir el camino

Una estructura selectiva evalúa una condición (una expresión que da como resultado verdadero o falso) y, según el resultado, ejecuta una rama de instrucciones u otra.

a) Selectiva simple: Si... Entonces

Ejecuta un bloque de instrucciones solo si la condición es verdadera. Si es falsa, simplemente no hace nada y continúa después de la estructura.

Si nota >= 5 Entonces
    Escribir "Aprobado"
FinSi

b) Selectiva doble: Si... Entonces... SiNo

Ofrece dos caminos excluyentes: uno para cuando la condición es verdadera, otro para cuando es falsa. Siempre se ejecuta uno de los dos, nunca ninguno ni los dos.

Si nota >= 5 Entonces
    Escribir "Aprobado"
SiNo
    Escribir "Suspenso"
FinSi

c) Selectiva múltiple: Según... Hacer

Cuando hay que comparar una misma variable con varios valores posibles, anidar muchos Si se vuelve difícil de leer. PSeInt ofrece una alternativa más clara:

Según nota Hacer
    10, 9: Escribir "Sobresaliente"
    8, 7: Escribir "Notable"
    6, 5: Escribir "Aprobado"
    De Otro Modo: Escribir "Suspenso"
FinSegún

📊 Selectivas: PSeInt vs. Python

PSeInt	Python
Si cond Entonces … FinSi	if cond:
Si cond Entonces … SiNo … FinSi	if cond: … else:
Según var Hacer … FinSegún	match var: (Python 3.10+) o cadena de elif

Idea clave: una estructura selectiva no rompe la secuenciación, la ramifica. Las instrucciones dentro de cada rama siguen siendo una secuencia normal; lo que cambia es que, según la condición, una rama entera se salta.

4. Estructuras iterativas: repetir sin reescribir

Una estructura iterativa (o bucle) repite un bloque de instrucciones mientras se cumpla una condición, en lugar de escribir esas instrucciones una y otra vez.

a) Mientras... Hacer (bucle con condición al principio)

Comprueba la condición antes de cada repetición. Si la condición es falsa desde el principio, el bloque no se ejecuta ni una sola vez.

contador <- 1
Mientras contador <= 5 Hacer
    Escribir contador
    contador <- contador + 1
FinMientras

b) Repetir... Hasta Que (bucle con condición al final)

Comprueba la condición después de cada repetición. Por eso el bloque se ejecuta al menos una vez, siempre, aunque la condición sea falsa desde el principio.

contador <- 1
Repetir
    Escribir contador
    contador <- contador + 1
Hasta Que contador > 5

c) Para... Hasta... Hacer (bucle controlado por contador)

Se usa cuando sabes de antemano cuántas veces se va a repetir el bloque, porque depende de un contador con inicio, fin y (opcionalmente) paso.

Para contador <- 1 Hasta 5 Hacer
    Escribir contador
FinPara

📊 Iterativas: PSeInt vs. Python

PSeInt	Python	Se comprueba la condición…
Mientras cond Hacer … FinMientras	while cond:	Antes de cada repetición
Repetir … Hasta Que cond	(Python no tiene equivalente directo; se simula con while True: + if cond: break)	Después de cada repetición
Para i <- 1 Hasta n Hacer … FinPara	for i in range(1, n+1):	Antes de cada repetición, controlada por contador

Idea clave: la diferencia entre Mientras y Repetir...Hasta Que no es de qué hacen, sino de cuándo comprueban la condición. Esa diferencia importa mucho: si la condición puede ser falsa desde el principio, Mientras puede no ejecutarse nunca, y Repetir...Hasta Que se ejecutará siempre al menos una vez, la quieras o no.

5. Bucles finitos e infinitos

Un bucle es finito cuando existe la garantía de que, tarde o temprano, la condición dejará de cumplirse y el bucle terminará. Para eso, algo dentro del bucle tiene que acercar la condición hacia su fin en cada repetición (normalmente, una variable que cambia de valor).

Un bucle es infinito cuando su condición nunca deja de cumplirse, así que se repite para siempre.

contador <- 1
Mientras contador <= 5 Hacer
    Escribir contador
    // ¡Falta esta línea!: contador <- contador + 1
FinMientras

Este bucle nunca termina: contador siempre vale 1, la condición contador <= 5 es siempre verdadera, y el programa se queda escribiendo “1” sin parar. Este es, con diferencia, el error más común al empezar con bucles: olvidar actualizar la variable que controla la condición de parada.

No todos los bucles infinitos son un error, sin embargo. Hay programas que necesitan un bucle infinito de forma intencionada: el bucle principal de un videojuego, un servidor que escucha peticiones constantemente, o el sistema operativo de un microcontrolador. En esos casos, el bucle no termina por sí solo: se sale de él con una instrucción explícita (Romper en PSeInt, break en Python) cuando ocurre algún evento concreto (el jugador pierde, llega una petición, se pulsa un botón).

Idea clave: antes de dar por bueno un bucle, pregúntate siempre: ¿qué hace que la condición cambie? Si no encuentras una respuesta clara, es muy probable que el bucle sea infinito por error, no por diseño.

6. El mismo problema, tres formas de repetir

Problema: mostrar los números del 1 al 5.

Para (cuando sabes cuántas veces)	Mientras (condición al principio)	Repetir...Hasta Que (condición al final)
Para i <- 1 Hasta 5 Hacer Escribir i FinPara	i <- 1 Mientras i <= 5 Hacer Escribir i i <- i + 1 FinMientras	i <- 1 Repetir Escribir i i <- i + 1 Hasta Que i > 5

Los tres dan exactamente el mismo resultado. Para es la opción más clara cuando el número de repeticiones se conoce de antemano; Mientras y Repetir...Hasta Que se usan cuando la repetición depende de una condición que no sabes cuántas veces se cumplirá hasta que el programa se ejecuta (por ejemplo, repetir hasta que el usuario introduzca un valor válido).

📝 PARA TU LIBRETA (Resumen clave para copiar)

Copia en tu cuaderno estos 6 puntos:

1. Una estructura de control decide qué instrucción se ejecuta a continuación, más allá de la secuencia simple. Hay tres tipos: secuencial, selectiva e iterativa.
2. Selectiva simple (Si...Entonces): ejecuta un bloque solo si la condición es verdadera. Selectiva doble (Si...SiNo): siempre ejecuta una de las dos ramas.
3. Iterativa con condición al principio (Mientras): puede no ejecutarse nunca. Iterativa con condición al final (Repetir...Hasta Que): se ejecuta siempre al menos una vez. Iterativa por contador (Para): se usa cuando el número de repeticiones se conoce de antemano.
4. Un bucle es finito si algo dentro de él acerca la condición hacia su fin en cada repetición; es infinito si la condición nunca deja de cumplirse.
5. El error más común con bucles: olvidar actualizar la variable que controla la condición, lo que produce un bucle infinito no intencionado.
6. Los bucles infinitos intencionados existen (videojuegos, servidores) y se detienen con una instrucción explícita como Romper/break, no porque la condición cambie sola.

FICHA DE EJERCICIOS: ESTRUCTURAS SELECTIVAS E ITERATIVAS

Materia: Creación Digital y Pensamiento Computacional (1.º Bachillerato)

Saber Básico A.3: Estructuras de control selectivas e iterativas, finitas e infinitas

Nombre y Apellidos: ____________________________________________________

Curso y Grupo: 1.º Bach. ____ | Fecha: __ /__ /2026

📖 Referencia rápida (consulta si tienes dudas)

Si condición Entonces          Mientras condición Hacer
    instrucción                    instrucción
SiNo                            FinMientras
    instrucción
FinSi                           Repetir
                                    instrucción
Según variable Hacer            Hasta Que condición
    valor: instrucción
    De Otro Modo: instrucción   Para i <- inicio Hasta fin Hacer
FinSegún                            instrucción
                                 FinPara

Mientras comprueba la condición antes (puede no ejecutarse nunca) · Repetir...Hasta Que comprueba después (se ejecuta siempre al menos una vez) · Para se usa cuando el número de repeticiones se conoce de antemano.

---

🧩 BLOQUE 1: Traza de Algoritmo y Predicción de Salida (15-20 min)

1.1. Selectiva doble

Algoritmo Entradas
    Definir edad Como Entero
    Escribir "Introduce tu edad:"
    Leer edad
    Si edad >= 18 Entonces
        Escribir "Entrada permitida"
    SiNo
        Si edad >= 14 Entonces
            Escribir "Entrada con acompañante"
        SiNo
            Escribir "Entrada no permitida"
        FinSi
    FinSi
FinAlgoritmo

Indica qué muestra el algoritmo para cada edad:

• 12 años: ____________________________
• 15 años: ____________________________
• 20 años: ____________________________

Reflexión: este algoritmo tiene un Si dentro de otro Si. ¿Cómo llamarías a esta estructura? ¿Con qué otra estructura selectiva que viste en teoría podrías escribir el mismo algoritmo de forma más directa?
Respuesta: ____________________________________________________________________

1.2. Traza de un bucle Mientras

Algoritmo Potencia
    Definir base, exponente, resultado, i Como Entero
    base <- 2
    exponente <- 4
    resultado <- 1
    i <- 1
    Mientras i <= exponente Hacer
        resultado <- resultado * base
        i <- i + 1
    FinMientras
    Escribir "Resultado: ", resultado
FinAlgoritmo

Completa la traza, fila a fila:

Vuelta	i (antes)	¿i <= exponente?	resultado (después)	i (después)
1	1
2
3
4
5

Salida final: ____________________________

1.3. Para vs. Repetir...Hasta Que: ¿cuántas veces se ejecutan?

A)                                  B)
n <- 5                              n <- 5
Para i <- 1 Hasta n Hacer           Repetir
    Escribir "Hola"                     Escribir "Hola"
FinPara                                 n <- n - 1
                                     Hasta Que n = 0

• ¿Cuántas veces escribe “Hola” el algoritmo A? ______
• ¿Cuántas veces escribe “Hola” el algoritmo B? ______
• Ahora cambia el valor inicial a n <- 0 en ambos algoritmos por separado. ¿Cuántas veces escribe “Hola” cada uno ahora?
  A: ______ B: ______
• Reflexión: con n <- 0, uno de los dos algoritmos se comporta de forma “sorprendente”. ¿Cuál, y por qué, según lo que viste en teoría sobre cuándo se comprueba la condición?
  Respuesta: ____________________________________________________________________

---

🐛 BLOQUE 2: Depuración y Caza de Errores (15-20 min)

2.1. El bucle que no termina nunca

Algoritmo Cuenta
    Definir n Como Entero
    n <- 1
    Mientras n <= 10 Hacer
        Escribir n
    FinMientras
FinAlgoritmo

1. Ejecuta este algoritmo mentalmente. ¿Qué ocurre?
   Respuesta: ____________________________________________________________________
2. ¿Es un bucle infinito intencionado o un error? Justifica tu respuesta con lo que viste en el punto 5 de la teoría.
   Respuesta: ____________________________________________________________________
3. Corrige el algoritmo para que muestre los números del 1 al 10 y termine correctamente:

2.2. La estructura selectiva incompleta

Un compañero quiere clasificar un número como positivo, negativo o cero, pero ha escrito esto:

Algoritmo Clasificar
    Definir numero Como Entero
    Escribir "Introduce un número:"
    Leer numero
    Si numero > 0 Entonces
        Escribir "Positivo"
    FinSi
    Si numero < 0 Entonces
        Escribir "Negativo"
    FinSi
FinAlgoritmo

1. Prueba el algoritmo mentalmente con numero = 0. ¿Qué muestra por pantalla?
   Respuesta: ____________________________________________________________________
2. ¿Cuál es el problema de fondo? (pista: no es un error de sintaxis, es un caso que el algoritmo no contempla)
   Respuesta: ____________________________________________________________________
3. Reescribe el algoritmo usando una única estructura Según que resuelva los tres casos (positivo, negativo, cero):

2.3. Mientras en vez de Repetir...Hasta Que

Este algoritmo debería pedir una contraseña y repetir la petición hasta que el usuario acierte, pero algo falla la primera vez que se ejecuta:

Algoritmo Login
    Definir clave Como Cadena
    Mientras clave = "1234" Hacer
        Escribir "Introduce la contraseña:"
        Leer clave
    FinMientras
    Escribir "Acceso correcto"
FinAlgoritmo

1. Ejecuta el algoritmo mentalmente desde el principio (recuerda que clave no tiene ningún valor asignado antes del bucle). ¿Llega a pedir la contraseña alguna vez?
   Respuesta: ____________________________________________________________________
2. ¿Qué estructura iterativa de las tres que conoces encaja mejor con “repetir hasta acertar”? ¿Por qué?
   Respuesta: ____________________________________________________________________
3. Reescribe el algoritmo con la estructura correcta:

---

✍️ BLOQUE 3: Diseña tu algoritmo (20-25 min)

Problema A: Validación de entrada

“Un programa debe pedir un número del 1 al 10. Si el usuario introduce un número fuera de ese rango, el programa debe volver a pedírselo, tantas veces como haga falta, hasta que introduzca un valor válido.”

1. ¿Qué estructura iterativa encaja mejor aquí: Mientras, Repetir...Hasta Que o Para? Justifica tu elección pensando en si el bloque tiene que ejecutarse al menos una vez.
   Respuesta: ____________________________________________________________________
2. Escribe el pseudocódigo completo en PSeInt:

Algoritmo ValidarNumero

FinAlgoritmo

3. Marca con una tabla de traza qué pasaría si el usuario introduce, en este orden: 15, -3, 7.

Intento	Valor introducido	¿Válido?	¿Se repite?
1
2
3

Problema B: Contador con condición

“Un programa debe pedir un número N y contar cuántos números pares hay entre 1 y N (incluido N si es par).”

1. ¿Qué estructura iterativa encaja mejor aquí? ¿Por qué esta vez sí sabes de antemano cuántas repeticiones hacen falta?
   Respuesta: ____________________________________________________________________
2. Escribe el pseudocódigo completo, combinando la estructura iterativa elegida con una estructura selectiva dentro:

Algoritmo ContarPares

FinAlgoritmo

3. Traza tu algoritmo a mano para N = 6 y anota el valor final del contador de pares: ______

Reto extra (si terminas antes)

“Adivina el número: el programa piensa un número secreto (puedes fijarlo tú, por ejemplo el 7) y el usuario tiene que intentar acertarlo. Cada vez que falla, el programa le dice si el número secreto es mayor o menor que el que ha introducido. El programa debe llevar la cuenta de cuántos intentos ha necesitado el usuario, y terminar en cuanto acierte.”

Diseña el pseudocódigo combinando Repetir...Hasta Que (para repetir hasta acertar) con Si...SiNo anidado (para decidir si el intento es mayor, menor o correcto) y una variable contador.

Algoritmo AdivinaElNumero

FinAlgoritmo

---

🔑 SOLUCIONARIO RÁPIDO (Para el profesor/a de guardia)

• 1.1: 12 años → “Entrada no permitida”; 15 años → “Entrada con acompañante”; 20 años → “Entrada permitida”. Es una selectiva doble anidada; se podría escribir de forma más directa con un Según sobre rangos, o con una cadena de Si...SiNo Si...SiNo.
• 1.2: Vueltas 1-4 con resultado = 2, 4, 8, 16 y i pasando de 1 a 5; en la vuelta 5, i <= exponente es falso (5 <= 4) y el bucle termina. Salida final: Resultado: 16.
• 1.3: Con n <- 5: A escribe “Hola” 5 veces, B también 5 veces. Con n <- 0: A escribe “Hola” 0 veces (el Para no llega a 1 Hasta 0), pero B escribe “Hola” 1 vez, porque Repetir...Hasta Que comprueba la condición al final y siempre ejecuta el bloque al menos una vez.
• 2.1: Es un bucle infinito por error: falta n <- n + 1 dentro del Mientras, así que n nunca llega a superar 10 y la condición nunca deja de cumplirse. Corrección: añadir n <- n + 1 al final del bloque, antes de FinMientras.
• 2.2: Con numero = 0, el algoritmo no muestra nada, porque ninguna de las dos condiciones (> 0 ni < 0) es verdadera: el caso “cero” no está contemplado. Versión con Según:
  Según numero Hacer … en PSeInt el Según compara con valores concretos, no con rangos como > 0, así que lo más correcto aquí es una selectiva doble con un Si anidado: Si numero > 0 Entonces Escribir "Positivo" SiNo Si numero < 0 Entonces Escribir "Negativo" SiNo Escribir "Cero" FinSi FinSi (es un ejemplo de que Según no siempre es la mejor herramienta: para comparar rangos, los Si anidados funcionan mejor).
• 2.3: Como clave no tiene ningún valor antes del Mientras, la condición clave = "1234" es falsa desde el principio (una cadena vacía o sin definir no es igual a “1234”), así que el bucle no se ejecuta ni una sola vez y nunca llega a pedir la contraseña. La estructura correcta es Repetir...Hasta Que, porque hay que pedir la contraseña al menos una vez siempre:
  Repetir Escribir "Introduce la contraseña:" Leer clave Hasta Que clave = "1234" … Escribir "Acceso correcto"
• Problema A (PSeInt): Algoritmo ValidarNumero Definir numero Como Entero Repetir Escribir "Introduce un número del 1 al 10:" Leer numero Hasta Que numero >= 1 Y numero <= 10 Escribir "Número válido: ", numeroFinAlgoritmo Traza: 15 (no válido, se repite) → -3 (no válido, se repite) → 7 (válido, termina).
• Problema B (PSeInt): Algoritmo ContarPares Definir n, i, contador Como Entero contador <- 0 Escribir "Introduce N:" Leer n Para i <- 1 Hasta n Hacer Si i MOD 2 = 0 Entonces contador <- contador + 1 FinSi FinPara Escribir "Números pares: ", contadorFinAlgoritmo Para N = 6: contador final = 3 (los pares 2, 4 y 6).