🥇 Pseudocódigo: estructuras de control paso a paso

📝 Introducción: los elementos del pseudocódigo

En la Parte I de esta serie presentamos el pseudocódigo como un lenguaje de especificación de algoritmos que permite diseñar la lógica de un programa sin ceñirse a las restricciones sintácticas de un lenguaje de programación concreto. En esta segunda parte profundizaremos en los elementos fundamentales que componen cualquier pseudocódigo: variables, operadores de asignación, comparación, aritmética y lógica, bloques de sentencias y comentarios.

Dominar estos elementos es el paso previo imprescindible antes de abordar las estructuras de control (Si...Entonces, Mientras, Para) que se verán en lecciones posteriores. La filosofía es clara: primero se comprenden las piezas individuales, después se aprende a combinarlas.

💡 Recuerda: El pseudocódigo no se ejecuta en ningún ordenador. Es una herramienta de diseño pensada para que los humanos comprendan y comuniquen la lógica de un algoritmo. Una vez validado el diseño, la traducción a cualquier lenguaje real (Java, Python, C++) es prácticamente mecánica.

📦 Variables: almacenar información

Una variable es un nombre simbólico que representa un espacio de almacenamiento en la memoria del computador. Puede contener distintos tipos de datos: números enteros, números decimales, textos (cadenas de caracteres) o valores lógicos (verdadero/falso). Una vez que asignamos un tipo a una variable, esta debe mantener ese mismo tipo durante todo el algoritmo.

🔹 Reglas para nombrar variables

Regla	Ejemplo válido	Ejemplo no válido
Usar nombres descriptivos	`edad`, `precioTotal`	`x`, `a1`
Comenzar con una letra	`contador`	`3valor`
No usar espacios	`nombreCompleto`	`nombre completo`
No usar palabras reservadas	`resultado`	`Si`, `Mientras`
Usar camelCase o guiones bajos	`totalCompra`, `total_compra`	`TOTALCOMPRA`

🔹 Tipos de datos fundamentales

Tipo	Descripción	Ejemplo en pseudocódigo	Equivalente en Java
Entero	Números sin decimales	`edad := 25`	`int edad = 25;`
Real	Números con decimales	`precio := 19.99`	`double precio = 19.99;`
Carácter	Un solo carácter	`letra := 'A'`	`char letra = 'A';`
Cadena	Texto (secuencia de caracteres)	`nombre := "Ana"`	`String nombre = "Ana";`
Lógico	Verdadero o Falso	`aprobado := VERDADERO`	`boolean aprobado = true;`

➡️ El operador de asignación

La asignación es la operación que almacena un valor en una variable. En pseudocódigo utilizamos el símbolo := (dos puntos seguidos de igual) o la flecha ← para distinguirla claramente de la comparación de igualdad (=).

(* Asignación de valores a variables *)
edad := 25
nombre := "María"
precioUnitario := 9.99
cantidad := 3
precioTotal := precioUnitario * cantidad   (* precioTotal vale 29.97 *)

(* La asignación se lee de derecha a izquierda:
   "el valor 25 se almacena en la variable edad" *)

⚠️ Error frecuente: En pseudocódigo, edad := 25 es una asignación (almacena 25 en edad), mientras que edad = 25 es una comparación que pregunta «¿el valor de edad es igual a 25?». En Java esta distinción se mantiene: edad = 25 asigna y edad == 25 compara.

⚖️ Operadores de comparación

Los operadores de comparación (también llamados relacionales) comparan dos valores y producen un resultado lógico: VERDADERO o FALSO. Son la base de toda toma de decisiones en un algoritmo.

Operador	Significado	Pseudocódigo	Java	Ejemplo	Resultado
`=`	Igual a	`a = b`	`a == b`	`5 = 5`	VERDADERO
`<`	Menor que	`a < b`	`a < b`	`3 < 7`	VERDADERO
`>`	Mayor que	`a > b`	`a > b`	`3 > 7`	FALSO
`<=`	Menor o igual	`a <= b`	`a <= b`	`5 <= 5`	VERDADERO
`>=`	Mayor o igual	`a >= b`	`a >= b`	`3 >= 7`	FALSO
`<>`	Distinto de	`a <> b`	`a != b`	`3 <> 7`	VERDADERO

⚠️ Importante: Los operadores de comparación son binarios: actúan sobre exactamente dos operandos. La expresión a >= b >= c no es válida. Para comparar tres valores se deben combinar dos comparaciones: (a >= b) AND (b >= c).

🔢 Operadores aritméticos

Los operadores aritméticos realizan cálculos matemáticos sobre valores numéricos. A diferencia de los operadores de comparación, los aritméticos pueden encadenarse con más de dos operandos.

Operador	Significado	Pseudocódigo	Java	Ejemplo	Resultado
`+`	Suma	`a + b`	`a + b`	`5 + 3`	8
`-`	Resta	`a - b`	`a - b`	`10 - 4`	6
`*`	Multiplicación	`a * b`	`a * b`	`6 * 7`	42
`/`	División	`a / b`	`a / b`	`15 / 4`	3.75
`MOD`	Módulo (resto)	`a MOD b`	`a % b`	`15 MOD 4`	3

🔹 Precedencia de operadores aritméticos

Al igual que en matemáticas, la multiplicación y la división se evalúan antes que la suma y la resta. Los paréntesis siempre fuerzan la evaluación prioritaria:

(* Sin paréntesis: se evalúa * antes que + *)
resultado := 2 + 3 * 4          (* resultado = 2 + 12 = 14 *)

(* Con paréntesis: se fuerza la suma primero *)
resultado := (2 + 3) * 4        (* resultado = 5 * 4 = 20 *)

(* Expresión compuesta válida con 3+ operandos *)
total := precio * cantidad + impuesto - descuento

✅ Buena práctica: Aunque los operadores aritméticos permiten operar con más de dos operandos (a + b + c es perfectamente válido), se recomienda usar paréntesis en expresiones complejas para evitar ambigüedades y mejorar la legibilidad.

🧠 Operadores lógicos

Los operadores lógicos permiten combinar expresiones booleanas (verdadero/falso) para formar condiciones más complejas. Son imprescindibles para construir las estructuras de decisión que veremos en próximos capítulos.

Operador	Significado	Pseudocódigo	Java	Descripción
`NOT`	Negación	`NOT condicion`	`!condicion`	Invierte el valor lógico
`AND`	Conjunción	`a AND b`	`a && b`	Verdadero solo si ambos son verdaderos
`OR`	Disyunción	`a OR b`	`a \|\| b`	Verdadero si al menos uno es verdadero

(* Ejemplo: ¿puede una persona votar? *)
edad := 18
tieneDNI := VERDADERO

puedeVotar := (edad >= 18) AND tieneDNI
(* puedeVotar = VERDADERO AND VERDADERO = VERDADERO *)

(* Ejemplo: acceso al sistema *)
esAdmin := FALSO
tienePermiso := VERDADERO

accesoPermitido := esAdmin OR tienePermiso
(* accesoPermitido = FALSO OR VERDADERO = VERDADERO *)

(* Ejemplo: negación *)
esMenor := NOT (edad >= 18)
(* esMenor = NOT VERDADERO = FALSO *)

Para profundizar en los operadores lógicos, sus tablas de verdad y su precedencia, consulta el artículo Lógica proposicional aplicada a la programación.

📐 Bloques de sentencias e indentación

Un bloque de sentencias es un conjunto de instrucciones agrupadas que se ejecutan como una unidad. En pseudocódigo se delimitan con las palabras INICIO y FIN:

INICIO
    sentencia_1
    sentencia_2
    sentencia_3
FIN

La indentación (sangría o tabulación) es el desplazamiento horizontal de las sentencias dentro de un bloque. Aunque el algoritmo funcionaría igual sin ella, la indentación es una convención de estilo fundamental que mejora drásticamente la legibilidad del código:

INICIO
    leer(edad)
    Si edad >= 18 Entonces
        INICIO
            escribir("Eres mayor de edad")
            Si edad >= 65 Entonces
                INICIO
                    escribir("Tienes acceso a tarifa senior")
                FIN
            FinSi
        FIN
    Sino
        INICIO
            escribir("Eres menor de edad")
        FIN
    FinSi
FIN

✅ Consejo profesional: Todo buen programador sigue normas de estilo rigurosas. Un programa funciona igual con o sin indentación, pero un código bien estructurado se entiende en segundos, mientras que un código desordenado puede requerir horas de análisis. La indentación no es una «manía»: es una herramienta profesional imprescindible.

🔹 Equivalencia de bloques en Java

En Java, los bloques INICIO / FIN del pseudocódigo se convierten en llaves { }:

Pseudocódigo	Java
`INICIO`	`{`
`FIN`	`}`
Indentación con 4 espacios	Indentación con 4 espacios (misma convención)

💬 Comentarios en pseudocódigo

Los comentarios son anotaciones que el programador incluye en el código para documentar y explicar la lógica. Los comentarios no se ejecutan: el computador los ignora por completo. En pseudocódigo los escribimos entre paréntesis y asteriscos:

(* Este es un comentario: no se ejecuta *)
edad := 25   (* Asignar la edad del usuario *)

(* Los comentarios son útiles para:
   - Explicar la lógica de secciones complejas
   - Documentar el propósito de las variables
   - Facilitar el trabajo en equipo
   - "Desactivar" temporalmente instrucciones para depurar *)

(* precio := precio * 1.21 *)  (* Línea "comentada" para pruebas *)

Lenguaje	Comentario de una línea	Comentario de varias líneas
Pseudocódigo	`(* texto *)`	`(* texto multilínea *)`
Java	`// texto`	`/* texto multilínea */`
Python	`# texto`	`""" texto """`

💡 Dato curioso: Windows 98 tenía aproximadamente 18 millones de líneas de código, desarrolladas por equipos de cientos de programadores. Sin comentarios adecuados, entender el trabajo de otro programador sería prácticamente imposible. Los comentarios son el «pegamento» que mantiene unido el trabajo en equipo.

🏗️ Primer programa completo en pseudocódigo

Reunamos todos los elementos aprendidos en un programa completo que calcula el precio final de una compra aplicando descuentos e impuestos:

ALGORITMO CalculadoraPrecio
(* Calcula el precio final de una compra con descuento e IVA *)

INICIO
    (* --- Variables --- *)
    precioUnitario := 0
    cantidad := 0
    esSocio := FALSO
    porcentajeDescuento := 0
    IVA := 0.21

    (* --- Entrada de datos --- *)
    escribir("Introduce el precio unitario:")
    leer(precioUnitario)
    escribir("Introduce la cantidad:")
    leer(cantidad)
    escribir("¿Es socio del club? (VERDADERO/FALSO):")
    leer(esSocio)

    (* --- Cálculo del subtotal --- *)
    subtotal := precioUnitario * cantidad

    (* --- Aplicar descuento si es socio Y compra más de 100 --- *)
    Si (esSocio = VERDADERO) AND (subtotal > 100) Entonces
        INICIO
            porcentajeDescuento := 10
            descuento := subtotal * porcentajeDescuento / 100
            subtotal := subtotal - descuento
            escribir("Descuento socio aplicado: ", descuento)
        FIN
    FinSi

    (* --- Aplicar IVA --- *)
    impuesto := subtotal * IVA
    precioFinal := subtotal + impuesto

    (* --- Salida --- *)
    escribir("Subtotal: ", subtotal)
    escribir("IVA (21%): ", impuesto)
    escribir("PRECIO FINAL: ", precioFinal)
FIN

☕ De pseudocódigo a Java: traducción directa

El siguiente ejemplo muestra cómo el pseudocódigo anterior se traduce de forma casi mecánica a Java. Obsérvese la correspondencia directa entre cada elemento:

import java.util.Scanner;

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

        // --- Variables ---
        double precioUnitario;
        int cantidad;
        boolean esSocio;
        int porcentajeDescuento = 0;
        double IVA = 0.21;

        // --- Entrada de datos ---
        System.out.println("Introduce el precio unitario:");
        precioUnitario = teclado.nextDouble();
        System.out.println("Introduce la cantidad:");
        cantidad = teclado.nextInt();
        System.out.println("¿Es socio? (true/false):");
        esSocio = teclado.nextBoolean();

        // --- Cálculo del subtotal ---
        double subtotal = precioUnitario * cantidad;

        // --- Descuento si es socio Y compra > 100 ---
        if (esSocio && subtotal > 100) {
            porcentajeDescuento = 10;
            double descuento = subtotal * porcentajeDescuento / 100;
            subtotal = subtotal - descuento;
            System.out.println("Descuento socio: " + descuento);
        }

        // --- Aplicar IVA ---
        double impuesto = subtotal * IVA;
        double precioFinal = subtotal + impuesto;

        // --- Salida ---
        System.out.println("Subtotal: " + subtotal);
        System.out.println("IVA (21%): " + impuesto);
        System.out.printf("PRECIO FINAL: %.2f€%n", precioFinal);

        teclado.close();
    }
}

Pseudocódigo	Java
`variable := valor`	`tipo variable = valor;`
`leer(variable)`	`variable = teclado.nextTipo();`
`escribir("texto")`	`System.out.println("texto");`
`Si condicion Entonces`	`if (condicion) {`
`INICIO / FIN`	`{ / }`
`AND / OR / NOT`	`&& / \|\| / !`
`(* comentario *)`	`// comentario`

✏️ Ejercicios resueltos

📝 Ejercicio 1 — Intercambiar el valor de dos variables

Escribe un pseudocódigo que intercambie los valores de dos variables a y b. Por ejemplo, si a = 5 y b = 10, después del intercambio a = 10 y b = 5. Pista: necesitarás una variable auxiliar.

Ver solución

ALGORITMO Intercambio
INICIO
    a := 5
    b := 10
    escribir("Antes: a=", a, " b=", b)

    (* Intercambio con variable auxiliar *)
    auxiliar := a      (* auxiliar = 5 *)
    a := b             (* a = 10 *)
    b := auxiliar      (* b = 5 *)

    escribir("Después: a=", a, " b=", b)
FIN

(* Salida: Antes: a=5 b=10
           Después: a=10 b=5 *)

Sin la variable auxiliar, al hacer a := b se perdería el valor original de a. Este patrón de intercambio es uno de los más básicos e importantes en programación.

📝 Ejercicio 2 — Calcular el área y perímetro de un rectángulo

Escribe un pseudocódigo que lea la base y la altura de un rectángulo, calcule su área y perímetro, y muestre los resultados. Tradúcelo también a Java.

Ver solución

ALGORITMO Rectangulo
INICIO
    escribir("Introduce la base:")
    leer(base)
    escribir("Introduce la altura:")
    leer(altura)

    area := base * altura
    perimetro := 2 * (base + altura)

    escribir("Área: ", area)
    escribir("Perímetro: ", perimetro)
FIN

import java.util.Scanner;

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

        System.out.println("Introduce la base:");
        double base = sc.nextDouble();
        System.out.println("Introduce la altura:");
        double altura = sc.nextDouble();

        double area = base * altura;
        double perimetro = 2 * (base + altura);

        System.out.println("Área: " + area);
        System.out.println("Perímetro: " + perimetro);
        sc.close();
    }
}

📝 Ejercicio 3 — Determinar si un número es par o impar

Escribe un pseudocódigo que lea un número entero y determine si es par o impar. Recuerda: un número es par si el resto de dividirlo entre 2 es cero (numero MOD 2 = 0).

Ver solución

ALGORITMO ParImpar
INICIO
    escribir("Introduce un número entero:")
    leer(numero)

    Si (numero MOD 2 = 0) Entonces
        INICIO
            escribir(numero, " es PAR")
        FIN
    Sino
        INICIO
            escribir(numero, " es IMPAR")
        FIN
    FinSi
FIN

import java.util.Scanner;

public class ParImpar {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Introduce un número entero:");
        int numero = sc.nextInt();

        if (numero % 2 == 0) {
            System.out.println(numero + " es PAR");
        } else {
            System.out.println(numero + " es IMPAR");
        }
        sc.close();
    }
}

📝 Ejercicio 4 — Determinar el mayor de tres números

Escribe un pseudocódigo que lea tres números enteros y determine cuál es el mayor de los tres. Utiliza operadores de comparación y lógicos para resolver el problema.

Ver solución

ALGORITMO MayorDeTres
INICIO
    escribir("Introduce tres números:")
    leer(a)
    leer(b)
    leer(c)

    Si (a >= b) AND (a >= c) Entonces
        INICIO
            escribir("El mayor es: ", a)
        FIN
    Sino Si (b >= a) AND (b >= c) Entonces
        INICIO
            escribir("El mayor es: ", b)
        FIN
    Sino
        INICIO
            escribir("El mayor es: ", c)
        FIN
    FinSi
FIN

❓ Preguntas frecuentes sobre Pseudocódigo: variables, operadores y bloques de sentencias (Parte II)

Las dudas más comunes respondidas de forma clara y directa.

Las variables en pseudocódigo son nombres simbólicos que representan espacios de almacenamiento para datos. Sirven para guardar valores (números, textos, booleanos) que el algoritmo necesita manipular durante su ejecución. El contenido de una variable puede cambiar mediante operaciones de asignación, y su nombre debe ser descriptivo para facilitar la lectura del algoritmo.

El operador de asignación (:= o ←) almacena un valor en una variable, modificando su contenido. El operador de comparación (=, <, >, <=, >=) compara dos valores y produce un resultado lógico (verdadero o falso) sin modificar ninguna variable. En pseudocódigo se usa := para asignar y = para comparar, lo que evita la confusión habitual en lenguajes como C o Java donde = es asignación y == es comparación.

Sí, los operadores de comparación son estrictamente binarios: operan sobre exactamente dos operandos. La expresión a >= b >= c no es válida en pseudocódigo. Para comparar tres valores se deben combinar dos comparaciones con operadores lógicos: (a >= b) AND (b >= c).

Un bloque de sentencias es un conjunto de instrucciones agrupadas que se ejecutan como una unidad, delimitadas por las palabras INICIO y FIN. La indentación (sangría) es el desplazamiento horizontal de las sentencias dentro de un bloque. Aunque no afecta a la ejecución del algoritmo, es una convención de estilo fundamental que mejora enormemente la legibilidad del código.

Los comentarios sirven para documentar y explicar partes del algoritmo. No se ejecutan, por lo que no afectan al funcionamiento del programa. Son útiles para aclarar el propósito de secciones complejas, facilitar el trabajo en equipo y recordar la lógica cuando se revisa el código tiempo después. En pseudocódigo se escriben entre (* comentario *).

La traducción es casi directa: cada instrucción del pseudocódigo tiene un equivalente en el lenguaje destino. Las variables se declaran con su tipo (int, String, boolean), el operador := se convierte en =, los bloques INICIO/FIN se convierten en llaves {}, las estructuras de control mantienen la misma lógica y los comentarios se escriben con // o /* */. La ventaja de diseñar primero en pseudocódigo es que la traducción se convierte en un proceso mecánico.

💬 Foro de discusión

¿Tienes dudas sobre Pseudocódigo: variables, operadores y bloques de sentencias (Parte II)? Comparte tu pregunta con la comunidad.

¿Tienes cuenta? o comenta como invitado ↓

Todavía no hay mensajes. ¡Sé el primero en participar!

Pseudocódigo: variables, operadores y bloques de sentencias (Parte II)

📝 Introducción: los elementos del pseudocódigo

📦 Variables: almacenar información

🔹 Reglas para nombrar variables

🔹 Tipos de datos fundamentales

➡️ El operador de asignación

⚖️ Operadores de comparación

🔢 Operadores aritméticos

🔹 Precedencia de operadores aritméticos

🧠 Operadores lógicos

📐 Bloques de sentencias e indentación

🔹 Equivalencia de bloques en Java

💬 Comentarios en pseudocódigo

🏗️ Primer programa completo en pseudocódigo

☕ De pseudocódigo a Java: traducción directa

✏️ Ejercicios resueltos

📝 Ejercicio 1 — Intercambiar el valor de dos variables

📝 Ejercicio 2 — Calcular el área y perímetro de un rectángulo

📝 Ejercicio 3 — Determinar si un número es par o impar

📝 Ejercicio 4 — Determinar el mayor de tres números

❓ Preguntas frecuentes sobre Pseudocódigo: variables, operadores y bloques de sentencias (Parte II)

💬 Foro de discusión

🔑 Recuperar contraseña

Crear cuenta

¿Cómo valorarías tu experiencia aprendiendo en esta sección?

¡Gracias por tu valoración!

📝 Introducción: los elementos del pseudocódigo

📦 Variables: almacenar información

🔹 Reglas para nombrar variables

🔹 Tipos de datos fundamentales

➡️ El operador de asignación

⚖️ Operadores de comparación

🔢 Operadores aritméticos

🔹 Precedencia de operadores aritméticos

🧠 Operadores lógicos

📐 Bloques de sentencias e indentación

🔹 Equivalencia de bloques en Java

💬 Comentarios en pseudocódigo

🏗️ Primer programa completo en pseudocódigo

☕ De pseudocódigo a Java: traducción directa

✏️ Ejercicios resueltos

📝 Ejercicio 1 — Intercambiar el valor de dos variables

📝 Ejercicio 2 — Calcular el área y perímetro de un rectángulo

📝 Ejercicio 3 — Determinar si un número es par o impar

📝 Ejercicio 4 — Determinar el mayor de tres números

❓ Preguntas frecuentes sobre Pseudocódigo: variables, operadores y bloques de sentencias (Parte II)

💬 Foro de discusión

Iniciar sesión

🔑 Recuperar contraseña

Crear cuenta