Pseudocódigo: qué es y cómo escribirlo con ejemplos claros

📝 ¿Qué es el pseudocódigo?

El pseudocódigo (también llamado pseudolenguaje) es un lenguaje de especificación de algoritmos que utiliza palabras del lenguaje natural combinadas con una estructura lógica similar a la de los lenguajes de programación. Su propósito fundamental es servir como borrador previo al código fuente, permitiendo al programador centrarse exclusivamente en la lógica y el flujo de control del programa sin preocuparse por las restricciones sintácticas de un lenguaje concreto.

La palabra «pseudocódigo» proviene del griego pseudo (falso) y del latín codex (código). Literalmente significa «código falso», lo que refleja su naturaleza: parece código de programación, pero no puede ejecutarse directamente en un computador. Es una herramienta de diseño y comunicación, no de ejecución.

Consideremos un ejemplo cotidiano. Si alguien dice «si vienes más tarde de las 5, me voy», podríamos expresarlo en pseudocódigo de la siguiente manera:

Si tu_hora_de_llegada > 5 Entonces
    me_voy ← VERDADERO
Fin Si

Este fragmento muestra la esencia del pseudocódigo: utiliza palabras comprensibles (Si, Entonces, Fin Si) con una estructura que refleja directamente la lógica del problema. Cualquier persona con un mínimo de formación técnica puede entender lo que hace, independientemente de si programa en Java, Python, C o cualquier otro lenguaje.

📜 Breve historia del pseudocódigo

El concepto de describir algoritmos con un lenguaje intermedio entre el lenguaje humano y el lenguaje máquina no es nuevo. Ya en la década de 1940, cuando los primeros computadores electrónicos como el ENIAC comenzaban a funcionar, los programadores necesitaban planificar las secuencias de instrucciones antes de codificarlas en lenguaje máquina. Los diagramas de flujo, formalizados por Herman Goldstine y John von Neumann en 1947, fueron la primera respuesta a esta necesidad.

Sin embargo, a medida que los lenguajes de programación evolucionaron en los años 50 y 60 —con FORTRAN (1957), COBOL (1959) y ALGOL (1960)—, los programadores empezaron a preferir descripciones textuales más cercanas al código. El término «pseudocódigo» se popularizó en la década de 1970, cuando la programación estructurada de Edsger Dijkstra estableció las bases de las estructuras de control que hoy usamos: secuencia, selección e iteración.

En 1974, el influyente libro The Elements of Programming Style de Brian Kernighan y P. J. Plauger promovió la idea de escribir código claro y legible, lo que reforzó el uso del pseudocódigo como herramienta pedagógica. Desde entonces, prácticamente todos los libros de texto de algoritmia y estructuras de datos —como los clásicos de Niklaus Wirth (Algorithms + Data Structures = Programs, 1976) o Cormen, Leiserson, Rivest y Stein (Introduction to Algorithms, 1990)— utilizan pseudocódigo como lenguaje de referencia.

Hoy en día, el pseudocódigo sigue siendo una herramienta fundamental tanto en la enseñanza de la programación como en el diseño profesional de algoritmos. Su vigencia demuestra que la claridad lógica trasciende cualquier lenguaje de programación concreto.

✅ Ventajas de usar pseudocódigo

El pseudocódigo ofrece beneficios significativos tanto para principiantes como para programadores experimentados. A continuación se presentan las ventajas más relevantes:

🧩 Elementos fundamentales del pseudocódigo

Todo pseudocódigo se construye a partir de un conjunto reducido de elementos básicos. Conocerlos es imprescindible para poder escribir y leer algoritmos con fluidez. Los elementos fundamentales son los siguientes:

Palabras reservadas

Son términos con un significado predefinido que estructuran el algoritmo. Aunque no existe un estándar universal, las palabras reservadas más habituales en pseudocódigo en español son:

Identificadores

Los identificadores son los nombres que el programador asigna a las variables, constantes y subprogramas. En pseudocódigo se recomienda usar nombres descriptivos que indiquen claramente su propósito. Por ejemplo, edad_alumno es preferible a x, y suma_total es más claro que st.

Comentarios

Los comentarios son anotaciones que el programador incluye para explicar partes del algoritmo. No forman parte de la lógica ejecutable y se escriben habitualmente precedidos de // o encerrados entre /* */. Su uso es fundamental para hacer el pseudocódigo comprensible a terceros.

// Algoritmo que calcula el área de un rectángulo
INICIO
    LEER base          // Se pide la base al usuario
    LEER altura        // Se pide la altura al usuario
    area ← base * altura
    ESCRIBIR "El área es: ", area
FIN

📦 Variables y tipos de datos

Una variable es un espacio de almacenamiento con un nombre simbólico que contiene un valor que puede cambiar durante la ejecución del algoritmo. Es uno de los conceptos más importantes de la programación, y el pseudocódigo permite trabajar con variables de manera intuitiva.

Declaración de variables

En pseudocódigo, las variables pueden declararse de dos formas: implícitamente (simplemente usándolas) o explícitamente (indicando su tipo). La declaración explícita es más rigurosa y más cercana a lenguajes como Java:

// Declaración implícita (se infiere el tipo)
nombre ← "Ana"
edad ← 25

// Declaración explícita (se indica el tipo)
ENTERO: contador ← 0
REAL: precio ← 19.99
CADENA: mensaje ← "Hola, mundo"
LOGICO: aprobado ← FALSO

Tipos de datos básicos

Aunque el pseudocódigo es flexible, los tipos de datos que se manejan habitualmente son los mismos que encontramos en la mayoría de lenguajes de programación:

Asignación de valores

La operación de asignación almacena un valor en una variable. En pseudocódigo se usa el símbolo ← (flecha hacia la izquierda) para distinguir la asignación de la comparación de igualdad. Esto es una convención muy extendida que evita la confusión entre = (asignación) y == (comparación) que existe en lenguajes como Java o C:

// Asignación: almacena el valor 10 en la variable x
x ← 10

// Comparación: evalúa si x es igual a 10 (devuelve VERDADERO o FALSO)
SI x = 10 ENTONCES
    ESCRIBIR "x vale diez"
FIN SI

⚙️ Operadores en pseudocódigo

Los operadores son símbolos que permiten realizar operaciones sobre los datos. En pseudocódigo se utilizan los mismos tipos de operadores que en los lenguajes de programación, con una notación que prioriza la legibilidad.

Operadores aritméticos

Operadores relacionales (de comparación)

Operadores lógicos

Precedencia de operadores

Cuando una expresión combina varios operadores, el orden de evaluación sigue la precedencia (de mayor a menor): paréntesis → potencia → multiplicación/división/módulo → suma/resta → relacionales → NO → Y → O. Ante duda, es buena práctica usar paréntesis para hacer explícito el orden deseado.

// Sin paréntesis: ¿cuál es el resultado?
resultado ← 3 + 4 * 2    // resultado = 11 (no 14)

// Con paréntesis: intención explícita
resultado ← (3 + 4) * 2  // resultado = 14

🔄 Estructuras de control

Las estructuras de control determinan el flujo de ejecución de un algoritmo. Según el teorema de Böhm-Jacopini (1966), cualquier algoritmo puede expresarse usando únicamente tres tipos de estructuras: secuencia, selección e iteración. Estas tres estructuras son la base de la programación estructurada y, por tanto, del pseudocódigo.

Estructura secuencial

Es la más simple: las instrucciones se ejecutan una tras otra, en el orden en que aparecen. No hay bifurcaciones ni repeticiones.

INICIO
    LEER radio
    area ← 3.14159 * radio ^ 2
    perimetro ← 2 * 3.14159 * radio
    ESCRIBIR "Área: ", area
    ESCRIBIR "Perímetro: ", perimetro
FIN

Estructura selectiva (condicional)

Permite ejecutar un bloque de instrucciones u otro en función de una condición. Existen tres variantes principales:

Selección simple (Si-Entonces): ejecuta un bloque solo si la condición es verdadera.

SI edad >= 18 ENTONCES
    ESCRIBIR "Es mayor de edad"
FIN SI

Selección doble (Si-Entonces-Si No): ejecuta un bloque si la condición es verdadera, y otro bloque diferente si es falsa.

SI nota >= 5 ENTONCES
    ESCRIBIR "Aprobado"
SI NO
    ESCRIBIR "Suspenso"
FIN SI

Selección múltiple (Según-Sea): equivalente al switch de Java. Evalúa una variable contra varios valores posibles.

SEGÚN dia_semana HACER
    1: ESCRIBIR "Lunes"
    2: ESCRIBIR "Martes"
    3: ESCRIBIR "Miércoles"
    4: ESCRIBIR "Jueves"
    5: ESCRIBIR "Viernes"
    6, 7: ESCRIBIR "Fin de semana"
    DE OTRO MODO: ESCRIBIR "Día no válido"
FIN SEGÚN

Estructura repetitiva (iterativa)

Permite ejecutar un bloque de instrucciones varias veces. Las tres variantes principales son:

Bucle Mientras: repite mientras una condición sea verdadera. La condición se evalúa antes de cada iteración, por lo que puede no ejecutarse nunca si la condición es falsa desde el inicio.

// Cuenta del 1 al 10
contador ← 1
MIENTRAS contador <= 10 HACER
    ESCRIBIR contador
    contador ← contador + 1
FIN MIENTRAS

Bucle Repetir-Hasta: similar al Mientras, pero la condición se evalúa después de cada iteración. Esto garantiza que el bloque se ejecuta al menos una vez. Equivale al do-while de Java.

// Pedir un número positivo (se repite hasta que el usuario lo introduzca)
REPETIR
    ESCRIBIR "Introduce un número positivo: "
    LEER numero
HASTA QUE numero > 0

Bucle Para: itera un número determinado de veces. Es ideal cuando se conoce de antemano cuántas repeticiones son necesarias. Equivale al for de Java.

// Tabla de multiplicar del 7
PARA i ← 1 HASTA 10 HACER
    resultado ← 7 * i
    ESCRIBIR "7 x ", i, " = ", resultado
FIN PARA

🏗️ Bloques de sentencias y anidamiento

Un bloque de sentencias es un grupo de instrucciones que se tratan como una unidad. En pseudocódigo, los bloques se delimitan mediante las palabras reservadas de apertura y cierre de cada estructura (SI...FIN SI, MIENTRAS...FIN MIENTRAS, PARA...FIN PARA).

El anidamiento consiste en colocar una estructura de control dentro de otra. Es una técnica fundamental que permite resolver problemas complejos combinando decisiones y repeticiones. La clave para que el anidamiento sea legible es la indentación (sangrado) consistente.

// Clasificar 20 números introducidos por el usuario
positivos ← 0
negativos ← 0
ceros ← 0

PARA i ← 1 HASTA 20 HACER
    ESCRIBIR "Introduce el número ", i, ": "
    LEER numero

    SI numero > 0 ENTONCES
        positivos ← positivos + 1
    SI NO
        SI numero < 0 ENTONCES
            negativos ← negativos + 1
        SI NO
            ceros ← ceros + 1
        FIN SI
    FIN SI
FIN PARA

ESCRIBIR "Positivos: ", positivos
ESCRIBIR "Negativos: ", negativos
ESCRIBIR "Ceros: ", ceros

Normas de estilo para la indentación

La indentación no es un capricho estético: es una herramienta de supervivencia para el programador. Un código bien indentado se lee en segundos; un código sin indentar puede requerir minutos u horas para comprender. Las normas mínimas que todo programador debería seguir son:

Cada vez que se abre un bloque (SI, MIENTRAS, PARA), el contenido interior se desplaza un nivel a la derecha (habitualmente 4 espacios o 1 tabulador). La palabra de cierre (FIN SI, FIN MIENTRAS, FIN PARA) se alinea con la de apertura. En estructuras anidadas, cada nivel añade un nuevo desplazamiento.

🎯 Ejemplo integrador: sistema de calificaciones

A continuación se presenta un ejemplo completo que integra todos los elementos vistos: variables, operadores, las tres estructuras de control, anidamiento, entrada/salida y comentarios. El algoritmo lee las notas de un grupo de alumnos, calcula el promedio y clasifica cada nota según una escala.

// =============================================
// ALGORITMO: Sistema de Calificaciones
// Autor: Ciberaula
// Descripción: Lee notas de N alumnos, clasifica
//              cada una y calcula estadísticas.
// =============================================

INICIO
    // --- Declaración de variables ---
    ENTERO: num_alumnos, aprobados, suspensos, notables, sobresalientes
    REAL: nota, suma_total, promedio, nota_maxima, nota_minima

    // --- Inicialización ---
    suma_total ← 0
    aprobados ← 0
    suspensos ← 0
    notables ← 0
    sobresalientes ← 0
    nota_maxima ← 0
    nota_minima ← 10

    // --- Entrada: número de alumnos ---
    REPETIR
        ESCRIBIR "¿Cuántos alumnos hay? (mínimo 1): "
        LEER num_alumnos
    HASTA QUE num_alumnos >= 1

    // --- Procesamiento: lectura y clasificación ---
    PARA i ← 1 HASTA num_alumnos HACER
        // Validar que la nota esté entre 0 y 10
        REPETIR
            ESCRIBIR "Nota del alumno ", i, " (0-10): "
            LEER nota
        HASTA QUE nota >= 0 Y nota <= 10

        // Acumular para el promedio
        suma_total ← suma_total + nota

        // Actualizar máximo y mínimo
        SI nota > nota_maxima ENTONCES
            nota_maxima ← nota
        FIN SI
        SI nota < nota_minima ENTONCES
            nota_minima ← nota
        FIN SI

        // Clasificar la nota
        SEGÚN HACER
            nota < 5:
                ESCRIBIR "  → Suspenso"
                suspensos ← suspensos + 1
            nota < 7:
                ESCRIBIR "  → Aprobado"
                aprobados ← aprobados + 1
            nota < 9:
                ESCRIBIR "  → Notable"
                notables ← notables + 1
            nota >= 9:
                ESCRIBIR "  → Sobresaliente"
                sobresalientes ← sobresalientes + 1
        FIN SEGÚN
    FIN PARA

    // --- Salida: estadísticas ---
    promedio ← suma_total / num_alumnos

    ESCRIBIR "========================================="
    ESCRIBIR "         RESUMEN DE CALIFICACIONES"
    ESCRIBIR "========================================="
    ESCRIBIR "Total alumnos:     ", num_alumnos
    ESCRIBIR "Promedio:          ", promedio
    ESCRIBIR "Nota más alta:     ", nota_maxima
    ESCRIBIR "Nota más baja:     ", nota_minima
    ESCRIBIR "-----------------------------------------"
    ESCRIBIR "Sobresalientes:    ", sobresalientes
    ESCRIBIR "Notables:          ", notables
    ESCRIBIR "Aprobados:         ", aprobados
    ESCRIBIR "Suspensos:         ", suspensos
FIN

Este algoritmo demuestra cómo un problema real de cierta complejidad puede resolverse combinando de forma ordenada las estructuras básicas. Obsérvese cómo el bucle REPETIR-HASTA se usa para validación de entrada, el bucle PARA para iterar sobre los alumnos, y la estructura SEGÚN anidada dentro del PARA para clasificar cada nota.

Traducción a Java

Para ilustrar la relación directa entre pseudocódigo y código real, a continuación se muestra cómo se traduciría la parte central del algoritmo a Java:

import java.util.Scanner;

public class SistemaCalificaciones {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int numAlumnos, aprobados = 0, suspensos = 0;
        int notables = 0, sobresalientes = 0;
        double nota, sumaTotal = 0, notaMax = 0, notaMin = 10;

        // Validar número de alumnos
        do {
            System.out.print("¿Cuántos alumnos hay? (mínimo 1): ");
            numAlumnos = sc.nextInt();
        } while (numAlumnos < 1);

        // Lectura y clasificación
        for (int i = 1; i <= numAlumnos; i++) {
            do {
                System.out.print("Nota del alumno " + i + " (0-10): ");
                nota = sc.nextDouble();
            } while (nota < 0 || nota > 10);

            sumaTotal += nota;
            if (nota > notaMax) notaMax = nota;
            if (nota < notaMin) notaMin = nota;

            if (nota < 5) {
                System.out.println("  → Suspenso");
                suspensos++;
            } else if (nota < 7) {
                System.out.println("  → Aprobado");
                aprobados++;
            } else if (nota < 9) {
                System.out.println("  → Notable");
                notables++;
            } else {
                System.out.println("  → Sobresaliente");
                sobresalientes++;
            }
        }

        // Estadísticas
        double promedio = sumaTotal / numAlumnos;
        System.out.println("=========================================");
        System.out.println("     RESUMEN DE CALIFICACIONES");
        System.out.println("=========================================");
        System.out.println("Total alumnos:     " + numAlumnos);
        System.out.printf("Promedio:          %.2f%n", promedio);
        System.out.println("Nota más alta:     " + notaMax);
        System.out.println("Nota más baja:     " + notaMin);
        System.out.println("Sobresalientes:    " + sobresalientes);
        System.out.println("Notables:          " + notables);
        System.out.println("Aprobados:         " + aprobados);
        System.out.println("Suspensos:         " + suspensos);

        sc.close();
    }
}

Obsérvese la correspondencia directa: REPETIR-HASTA → do-while, PARA → for, SEGÚN → if-else if, LEER → Scanner.nextXxx(), ESCRIBIR → System.out.println(). Esta es la gran ventaja del pseudocódigo: facilita la transición al código real.

¿Cuántos alumnos hay? (mínimo 1): 3
Nota del alumno 1 (0-10): 8.5
  → Notable
Nota del alumno 2 (0-10): 4.0
  → Suspenso
Nota del alumno 3 (0-10): 9.5
  → Sobresaliente
=========================================
     RESUMEN DE CALIFICACIONES
=========================================
Total alumnos:     3
Promedio:          7.33
Nota más alta:     9.5
Nota más baja:     4.0
Sobresalientes:    1
Notables:          1
Aprobados:         0
Suspensos:         1

❌ Errores frecuentes al escribir pseudocódigo

Incluso al trabajar con pseudocódigo, donde la sintaxis es flexible, los principiantes cometen errores que afectan la corrección y legibilidad del algoritmo. Estos son los más habituales:

Error 1: No inicializar variables acumuladoras

PARA i ← 1 HASTA 10 HACER
    suma ← suma + i      // ¿Cuánto vale suma al principio?
FIN PARA

suma ← 0              // Inicialización ANTES del bucle
PARA i ← 1 HASTA 10 HACER
    suma ← suma + i
FIN PARA

Si no se inicializa suma a 0, su valor inicial es indefinido y el resultado del algoritmo es impredecible.

Error 2: Bucle infinito por falta de actualización

contador ← 1
MIENTRAS contador <= 10 HACER
    ESCRIBIR contador
    // ¡Falta incrementar contador! → bucle infinito
FIN MIENTRAS

contador ← 1
MIENTRAS contador <= 10 HACER
    ESCRIBIR contador
    contador ← contador + 1   // Actualizar la variable de control
FIN MIENTRAS

Un bucle MIENTRAS debe modificar alguna variable que afecte a la condición; de lo contrario, la condición siempre será verdadera y el programa nunca terminará.

Error 3: Confundir asignación con comparación

SI x ← 5 ENTONCES       // Esto es una ASIGNACIÓN, no una comparación
    ESCRIBIR "x vale 5"
FIN SI

SI x = 5 ENTONCES        // Esto es una COMPARACIÓN
    ESCRIBIR "x vale 5"
FIN SI

En pseudocódigo, ← es asignación y = es comparación. Confundirlos es un error lógico que produce resultados inesperados y que se arrastra frecuentemente al código real.

Error 4: Indentación inconsistente

Un pseudocódigo sin indentación o con indentación irregular es difícil de leer y propenso a errores lógicos, especialmente cuando hay estructuras anidadas. La indentación no es opcional: es una herramienta esencial que todo programador profesional utiliza de forma consistente.

✏️ Ejercicios prácticos

a ← 5
b ← 3
c ← a + b
a ← c * 2
b ← a - c
ESCRIBIR a, b, c

INICIO
    LEER a, b, c

    mayor ← a      // Asumir que a es el mayor

    SI b > mayor ENTONCES
        mayor ← b
    FIN SI

    SI c > mayor ENTONCES
        mayor ← c
    FIN SI

    ESCRIBIR "El mayor es: ", mayor
FIN

INICIO
    // Validar entrada
    REPETIR
        ESCRIBIR "Introduce un número entero positivo: "
        LEER n
    HASTA QUE n >= 0

    // Calcular factorial
    factorial ← 1
    PARA i ← 2 HASTA n HACER
        factorial ← factorial * i
    FIN PARA

    ESCRIBIR n, "! = ", factorial
FIN

long factorial = 1;
for (int i = 2; i <= n; i++) {
    factorial *= i;
}
System.out.println(n + "! = " + factorial);

INICIO
    ESCRIBIR "Introduce N: "
    LEER n

    PARA num ← 2 HASTA n HACER
        es_primo ← VERDADERO

        PARA div ← 2 HASTA num - 1 HACER
            SI num MOD div = 0 ENTONCES
                es_primo ← FALSO
            FIN SI
        FIN PARA

        SI es_primo = VERDADERO ENTONCES
            ESCRIBIR num, " es primo"
        FIN SI
    FIN PARA
FIN