Arreglos en pseudocódigo

Qué es un arreglo

Si un programa necesita las calificaciones de 30 alumnos, crear 30 variables (c1, c2, …, c30) es impráctico. Un arreglo (también llamado vector) es una sola variable con muchas casillas numeradas. Cada casilla guarda un valor y se identifica por su posición o índice.

calif[3] se lee «calif en la posición 3» y vale 6. En PSeInt y en Jaguar las posiciones empiezan en 1. En lenguajes como Python, C o Java empiezan en 0: tenlo en cuenta cuando pases tu algoritmo a uno de ellos.

Crear un arreglo con Dimension

Antes de usar un arreglo hay que decir cuántas casillas tiene, con Dimension. Después, cada casilla se usa como una variable normal:

Algoritmo primer_arreglo
    Dimension dias[3]
    dias[1] <- "lunes"
    dias[2] <- "martes"
    dias[3] <- "miércoles"
    Escribir "El segundo día es ", dias[2]
FinAlgoritmo

Si usas una posición que no existe, como dias[4], Jaguar se detiene con el mensaje «La posición 4 está fuera del arreglo 'dias'» y te recuerda que las posiciones válidas van de 1 a 3.

Llenar y recorrer con Para

Lo que hace útiles a los arreglos es combinarlos con un ciclo Para. La variable del ciclo sirve de posición, así que con tres líneas lees o muestras todas las casillas:

Algoritmo promedio_grupo
    Dimension calif[5]
    suma <- 0
    Para i <- 1 Hasta 5 Hacer
        Escribir "Calificación ", i, ":"
        Leer calif[i]
        suma <- suma + calif[i]
    FinPara
    promedio <- suma / 5
    Escribir "Promedio: ", promedio
    Escribir "Arriba del promedio:"
    Para i <- 1 Hasta 5 Hacer
        Si calif[i] > promedio Entonces
            Escribir calif[i]
        FinSi
    FinPara
FinAlgoritmo

Este ejemplo muestra por qué se necesita el arreglo: para saber qué calificaciones están arriba del promedio, primero hay que conocerlas todas. Sin arreglo, al leer la quinta ya habrías perdido las anteriores.

Para solo leer los valores, sin necesitar la posición, también existe Para Cada:

Algoritmo para_cada
    Dimension precios[3]
    precios[1] <- 15
    precios[2] <- 22
    precios[3] <- 8
    total <- 0
    Para Cada p de precios Hacer
        total <- total + p
    FinPara
    Escribir "Total: ", total
FinAlgoritmo

Ejemplo: encontrar el mayor

Un ejercicio clásico: encontrar el valor más alto. La idea es suponer que el primero es el mayor y compararlo con cada uno de los demás. Si aparece uno más grande, se vuelve el nuevo mayor:

Algoritmo mayor_del_arreglo
    Dimension temp[5]
    Para i <- 1 Hasta 5 Hacer
        Leer temp[i]
    FinPara
    mayor <- temp[1]
    Para i <- 2 Hasta 5 Hacer
        Si temp[i] > mayor Entonces
            mayor <- temp[i]
        FinSi
    FinPara
    Escribir "La más alta: ", mayor
FinAlgoritmo

¿Por qué empezar con temp[1] y no con 0? Porque si todas las temperaturas fueran negativas, 0 sería «el mayor» sin estar en el arreglo. Empezar con un valor del propio arreglo funciona siempre. Para el menor, es igual pero con <.

Ejemplo: buscar un valor

Para saber si un valor está en el arreglo, se recorre casilla por casilla. Una variable lógica recuerda si ya se encontró:

Algoritmo buscar
    Dimension nombres[4]
    nombres[1] <- "Ana"
    nombres[2] <- "Luis"
    nombres[3] <- "Sofía"
    nombres[4] <- "Mateo"
    Leer buscado
    encontrado <- Falso
    Para i <- 1 Hasta 4 Hacer
        Si nombres[i] = buscado Entonces
            Escribir "Está en la posición ", i
            encontrado <- Verdadero
        FinSi
    FinPara
    Si NO encontrado Entonces
        Escribir "No está en la lista"
    FinSi
FinAlgoritmo

A esto se le llama búsqueda lineal o secuencial. Es la más sencilla y funciona aunque el arreglo no esté ordenado.

Matrices: arreglos de dos dimensiones

Un arreglo también puede tener filas y columnas, como una tabla. Se crea con dos tamaños, Dimension m[filas, columnas], y se recorre con un Para dentro de otro:

Algoritmo tablas_de_multiplicar
    Dimension m[3, 4]
    Para f <- 1 Hasta 3 Hacer
        Para c <- 1 Hasta 4 Hacer
            m[f, c] <- f * c
        FinPara
    FinPara
    Para f <- 1 Hasta 3 Hacer
        Escribir m[f, 1], " ", m[f, 2], " ", m[f, 3], " ", m[f, 4]
    FinPara
FinAlgoritmo

El ciclo de afuera recorre las filas y el de adentro las columnas de cada fila. Por cada vuelta del Para externo, el interno da todas las suyas.

Errores comunes

• Usar el arreglo sin Dimension. Primero se crea y luego se usa.
• Empezar en 0. En PSeInt flexible y en Jaguar, la primera posición es 1. Para i <- 0 Hasta 5 sobre un arreglo de 5 se sale de los límites.
• Dimensionar dos veces el mismo arreglo. Jaguar avisa: «El arreglo 'calif' ya fue dimensionado».
• Escribir el arreglo completo con Escribir calif. Hay que mostrar casilla por casilla, con un ciclo.
• Confundir la posición con el valor. En calif[3], el 3 es la posición; el valor es lo que hay guardado ahí.

Preguntas frecuentes