Pensamiento Computacional · Unidad 1 — Algoritmos y programación
Qué es un algoritmo
Un algoritmo es una receta: pasos finitos, sin ambigüedad, que a partir de ciertos datos llegan a un resultado. Programar es escribir recetas para alguien que no interpreta nada.
La explicación
La definición, y por qué cada palabra importa
Un algoritmo es una secuencia finita de pasos no ambiguos que, partiendo de unos datos de entrada, produce un resultado.
- Finita: tiene que terminar. Un procedimiento que da vueltas para siempre no es un algoritmo.
- No ambigua: cada paso significa una sola cosa. "Agregar sal a gusto" no sirve: ¿cuánta?
- Con entrada y salida: recibe datos y produce algo. Si no produce nada, no sirve de mucho.
Descomponer: el paso que la gente se saltea
Antes de escribir código, hay que partir el problema en pasos chicos. Es la parte que más cuesta y la que menos se practica, porque parece que "no es programar".
Ejemplo — servir un vaso de jugo. Un primer intento sería:
2. Servirlo en el vaso
Suena bien, pero le falta todo. ¿De dónde sale el vaso? ¿El cartón está abierto? ¿Qué pasa si no hay jugo? Una versión que una máquina podría seguir:
2. Si no hay cartón de jugo, terminar (no se puede servir)
3. Tomar el cartón
4. Cerrar la heladera
5. Agarrar un vaso y apoyarlo sobre la mesa
6. Si el cartón está cerrado, abrirlo
7. Inclinar el cartón sobre el vaso hasta que esté lleno hasta 2 cm del borde
8. Enderezar el cartón
Fijate qué apareció al detallar: una decisión (paso 2 y 6) y una condición de corte
(paso 7, "hasta que"). Esas dos cosas son if y while, que vas a ver en
la unidad 3. Los algoritmos cotidianos ya las tienen; sólo hay que reconocerlas.
Qué buscar cuando descomponés
- Qué datos necesito antes de empezar. (la entrada)
- Qué decisiones hay. Cada "si pasa tal cosa" es una bifurcación.
- Qué se repite. Si escribís el mismo paso varias veces, ahí hay un ciclo.
- Cuándo termina. Sobre todo en lo que se repite.
- Qué pasa si sale mal. Que no haya jugo es un caso válido, no un olvido.
Escribir el algoritmo para que una máquina saque plata de un cajero, para alguien que nunca usó uno.
Primero, la entrada. ¿Qué hace falta tener antes de empezar? La tarjeta y el PIN. Si falta alguno, ni tiene sentido arrancar.
2. Insertar la tarjeta
3. Ingresar el PIN
4. Si el PIN es incorrecto, volver al paso 3 (hasta 3 intentos)
5. Elegir la opción "Extracción"
6. Ingresar el monto
7. Si el monto supera el saldo, avisar y volver al paso 6
8. Retirar el dinero
9. Retirar la tarjeta
Ahora mirá qué estructuras aparecieron solas:
- El paso 1 y el 7 son decisiones →
if - El paso 4 es una repetición con corte →
while, y el corte doble (acertó, o se acabaron los intentos) evita el ciclo infinito
El control que vale la pena hacerse siempre: ¿este algoritmo termina en todos los casos? Acá sí, porque el paso 4 tiene tope de intentos. Sin ese tope, alguien que no recuerda el PIN se queda ahí para siempre — y eso deja de ser un algoritmo.
Escribir el algoritmo que decide si un año es bisiesto, sabiendo que la regla no es solo "divisible por 4": los múltiplos de 100 no son bisiestos, salvo los múltiplos de 400. Probarlo con 2000, 1900, 2024 y 2100.
Un algoritmo no es el código: es la secuencia de decisiones, escrita de forma que no quede nada librado a la interpretación. Acá la dificultad es que hay tres reglas y una pisa a la otra.
Las reglas, de la más fuerte a la más débil. Ese orden es la respuesta al ejercicio:
2. si no, y es divisible por 100 → NO es bisiesto
3. si no, y es divisible por 4 → ES bisiesto
4. si no → NO es bisiesto
Por qué en ese orden y no al revés. El año 2000 cumple las tres condiciones a la vez: es divisible por 400, por 100 y por 4. Si se pregunta primero por el 4, contesta "sí" y nunca llega a la excepción del 100; si se pregunta primero por el 100, contesta "no" y se pierde la excepción del 400. La única forma de que 2000 salga bien es preguntar de lo más específico a lo más general.
El algoritmo en código:
if anio % 400 == 0:
return True
if anio % 100 == 0:
return False
if anio % 4 == 0:
return True
return False
Las pruebas que hay que hacer, una por rama:
bisiesto(1900) → False (entra por la regla 2)
bisiesto(2024) → True (entra por la regla 3)
bisiesto(2023) → False (entra por la regla 4)
bisiesto(2100) → False (el que casi todos contestan mal)
Cuatro pruebas para cuatro caminos. Ese es el criterio para elegir los casos de prueba: uno por cada rama del algoritmo, no cuatro años cualesquiera. Probar con 2020, 2024 y 2028 es probar tres veces la misma rama.
La versión de una sola línea, que sirve de control independiente:
return (anio % 4 == 0 and anio % 100 != 0) or anio % 400 == 0
Los dos programas coinciden en los mil años entre 1500 y 2500, así que la traducción de las reglas está bien. Comparar dos implementaciones distintas del mismo algoritmo es la forma más barata de verificar que ninguna de las dos tiene un error.
Un control con un número conocido: entre 1900 y 2000 inclusive hay 25 años bisiestos. El programa cuenta 25 ✓. Si contara 26, se coló el 1900.
Dónde se pierde el punto: escribir solo "divisible por 4". Es correcto 3 de cada 4 siglos, así que el error no aparece probando con años cercanos: aparece recién en 1900 o 2100, que es justo lo que el ejercicio elige.
Dónde se cae la mayoría
- Escribir pasos que una persona entiende pero una máquina no ("poner un poco", "hasta que esté listo").
- Olvidar el caso en que algo falla o no está: la lista vacía, el archivo que no existe, el cero.
- Saltear la descomposición y largarse a escribir código. Ahí es donde después no sale.
Hasta acá la explicación. La práctica es la otra mitad: 7 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Además trae una animación que muestra la idea en movimiento.
Practicar Qué es un algoritmo →Los otros temas de la unidad 1
Algoritmos y programación