Qué es un algoritmo: programación con diagramas de flujo y bloques (3.º ESO)

¿Qué es un algoritmo?

Un algoritmo es una secuencia de pasos ordenados y finitos que resuelve un problema. La palabra suena técnica, pero los usas cada día: una receta de cocina es un algoritmo, y las instrucciones para montar un mueble también. La clave es el orden: si cambias los pasos de sitio, el resultado cambia (o falla). Programar es exactamente eso — escribir los pasos para que el ordenador los ejecute uno a uno, de arriba abajo, sin equivocarse.

Por ejemplo, el algoritmo para preparar un café con leche podría ser:

1. Poner la leche a calentar.
2. Echar el café en la taza.
3. Cuando la leche esté caliente, verterla en la taza.
4. Remover y servir.

Si cambias el orden —por ejemplo, servir antes de verter la leche— el resultado ya no es el mismo café. Además, todo algoritmo cumple estas características:

• Finito: tiene un número limitado de pasos y termina.
• Ordenado: los pasos se ejecutan en una secuencia concreta.
• Preciso: cada paso está definido sin ambigüedad.
• Con entrada y salida: parte de unos datos y produce un resultado.

La forma más básica de un algoritmo es la secuencia: una instrucción detrás de otra. Para verlo y compartirlo se usa un diagrama de flujo, un dibujo donde cada tipo de paso tiene su símbolo y las flechas marcan el orden en que se recorren. Estos son los cuatro símbolos básicos:

Variables, datos y operadores

Variables y tipos de datos

Para resolver problemas, un programa necesita guardar datos. Una variable es como una caja con un nombre (una etiqueta) donde se guarda un dato para usarlo después, y su valor puede cambiar mientras el programa se ejecuta — como el marcador de un partido, que empieza en 0 y va subiendo. Guardar un valor se llama asignación: poner puntos = 0. En esta unidad se usan tres tipos de datos: números (5, 3.14), textos entre comillas («hola») y booleanos (verdadero o falso).

Operar con los datos

Con los datos se hacen operaciones. Los operadores aritméticos (+, −, ×, ÷ y el resto de una división) dan como resultado un número; los operadores de comparación (<, >, =, ≠) dan verdadero o falso y sirven para tomar decisiones. Una expresión tan corta como poner x = x + 1 encierra una idea potente: primero se calcula la parte derecha con el valor actual de x, y ese resultado se guarda de nuevo en x.

Decisiones: si… si no

Un programa útil no siempre hace lo mismo: decide. Una decisión (si… si no) hace que el programa siga un camino u otro según se cumpla o no una condición. «Si está lloviendo, coge el paraguas; si no, no lo cojas.» En el diagrama de flujo, una decisión es un rombo del que salen dos flechas: la de Sí (la condición es verdadera) y la de No. Solo se recorre una de las dos. La condición se construye con los operadores de comparación (por ejemplo nota ≥ 5), y solo puede ser verdadera o falsa.

La mejor forma de entenderlo es construyéndolo. En el Laboratorio de algoritmos montas el programa con programación por bloques (piezas que encajan, como en Scratch), y lo ves a la vez como diagrama de flujo y como código; al ejecutarlo paso a paso, se ilumina el camino que realmente se recorre. Pruébalo aquí mismo:

Bucles: repetir sin copiar y pegar

Para dibujar un cuadrado con la tortuga habría que escribir «avanzar y girar» cuatro veces; para un polígono de cien lados, cien veces. Un bucle repite un grupo de instrucciones (el cuerpo del bucle) tantas veces como haga falta. Hay dos: repetir N veces, cuando sabes cuántas de antemano (un cuadrado son cuatro vueltas), y mientras, cuando el número de vueltas depende de una condición.

Con los bucles aparecen dos herramientas imprescindibles: un contador (una variable que cuenta las vueltas, como i) y un acumulador (una variable que va guardando un total, como s). Por ejemplo, para sumar 1 + 2 + … + N se empieza con s = 0 e i = 1, y mientras i ≤ N se hace s = s + i e i = i + 1: el acumulador va creciendo 1, 3, 6, 10… Ojo con olvidar el i = i + 1: si el contador no avanza, la condición nunca se vuelve falsa y el programa se queda repitiendo para siempre (un bucle infinito).

Funciones y depuración

Cuando un programa crece, conviene organizarlo. Una función (o subprograma) es un bloque con nombre que agrupa varios pasos para poder reutilizarlos: defines «cuadrado» una vez y lo usas las veces que quieras. Es la idea de descomponer un problema grande en trozos pequeños con nombre — y si luego cambias el bloque, el cambio se aplica en todos sitios a la vez.

Y como ningún programa sale bien a la primera, hay que depurar: encontrar y corregir los errores (los bugs). La herramienta clave es ejecutar paso a paso y mirar la tabla de variables y la tortuga en cada instrucción, para ver en qué momento algo se desvía de lo esperado. Un cuadrado que sale «torcido» suele delatar un fallo pequeño —girar 80° en vez de 90°— que rompe todo el dibujo. La depuración forma parte del currículo del bloque de programación, y es una de las habilidades más valiosas de un programador. En clase, el error más habitual del alumnado no está en la idea del algoritmo, sino en un detalle mínimo —un ángulo, un signo, un contador que no avanza—: por eso este simulador deja ejecutar paso a paso, para cazarlo.

Del algoritmo al control (y a la robótica)

Con todo lo anterior ya puedes programar un sistema de control, la base de casi cualquier máquina automática. Un termostato mide la temperatura y decide encender o apagar la calefacción sin que nadie lo toque: es un algoritmo controlando una máquina. El esquema es siempre el mismo: sensor → decisión → actuador. Y cada parte se corresponde con algo que ya sabes: el sensor es un leer, la decisión es un si… si no con una condición, y el actuador es lo que se escribe o se hace.

Este es el puente hacia la unidad de Robótica, donde el sensor y el actuador serán de verdad —un sensor de luz o de distancia, un motor— y el algoritmo controlará un robot. Todo lo de esta unidad (algoritmos, variables, decisiones, bucles y funciones) es la base con la que se programan los robots: cambia la tortuga por un motor y tendrás lo mismo.

El proyecto: diseña y programa tu algoritmo

En el proyecto final crearás tu propio programa de principio a fin en el Laboratorio de algoritmos. Eliges un reto —un dibujo con la tortuga, un procesador de datos (una calculadora de notas o un conversor de unidades) o un mini-control tipo semáforo— y lo recorres por fases: analizar el problema, diseñar su diagrama de flujo, programarlo, probarlo y depurarlo, y documentarlo.

Lo importante no es solo que funcione, sino saber diseñar el algoritmo y depurarlo: cuando algo no sale, se prueba y se corrige hasta que sale. Una rúbrica de cinco dimensiones valora el funcionamiento, el diseño del algoritmo, el uso de los conceptos, la prueba y depuración, y la comunicación.

Dudas frecuentes