Declaración y asignación de arrays

En PSeInt, los arreglos unidimensionales (también llamados arrays) se declaran especificando su tamaño. Generalmente, se usan dos estilos:

1. Dimension nombre[tamaño]
2. Definir nombre Como Arreglo De Tipo[tamaño]

Importante: El índice típico en PSeInt inicia en 1 y llega hasta el tamaño declarado. Por ejemplo:

Algoritmo EjemploArregloUnidimensional
    // Declarar un arreglo de 5 enteros
    Dimension numeros[5]  // O: Definir numeros Como Arreglo De Entero[5]

    // Asignar valores en cada posición (índices 1..5)
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    // Mostrar los valores
    Para i <- 1 Hasta 5 Hacer
        Escribir "numeros[", i, "] = ", numeros[i]
    Fin Para
FinAlgoritmo

En Python, se utilizan listas; los índices comienzan en 0 y llegan hasta len(lista)-1. Un ejemplo equivalente:

numeros = [0] * 5  # Crea una lista con 5 ceros
numeros[0] = 10
numeros[1] = 20
numeros[2] = 30
numeros[3] = 40
numeros[4] = 50

Si deseas inicializar los valores de un arreglo durante su declaración, algunas versiones de PSeInt permiten usar el siguiente formato (solo para unidimensionales):

Algoritmo InicializacionDirecta
    Dimension diasSemana[7]  // Arreglo de 7 cadenas
    diasSemana[1] <- "Lunes"
    diasSemana[2] <- "Martes"
    diasSemana[3] <- "Miércoles"
    diasSemana[4] <- "Jueves"
    diasSemana[5] <- "Viernes"
    diasSemana[6] <- "Sábado"
    diasSemana[7] <- "Domingo"

    // Mostrar
    Para i <- 1 Hasta 7 Hacer
        Escribir "Día ", i, ": ", diasSemana[i]
    Fin Para
FinAlgoritmo

En Python, la inicialización sería similar:

días_semana = ["Lunes", "Martes", "Miércoles", "Jueves", "Viernes", "Sábado", "Domingo"]

En muchas configuraciones estándar de PSeInt, no es posible declarar directamente un arreglo de dos dimensiones con:

Dimension matriz[1..3, 1..3]

Intentar hacerlo suele generar errores de sintaxis, a menos que actives un “modo tradicional” o “extensión avanzada”.

Para representar datos tabulares en “2D” (filas y columnas) usando un arreglo unidimensional, empleamos indexación manual:

Algoritmo Simular2DCon1D
    Definir filas, cols, total, i, f, c Como Entero
    filas <- 3
    cols <- 3
    total <- filas * cols

    // Arreglo unidimensional con 9 elementos
    Dimension matriz[9]

    // Llenar
    Para f <- 1 Hasta filas Hacer
        Para c <- 1 Hasta cols Hacer
            i <- ((f - 1) * cols) + (c - 1) + 1
            matriz[i] <- (f * 10) + c
        Fin Para
    Fin Para

    // Mostrar
    Para f <- 1 Hasta filas Hacer
        Para c <- 1 Hasta cols Hacer
            i <- ((f - 1) * cols) + (c - 1) + 1
            Escribir "[", f, ",", c, "] = ", matriz[i]
        Fin Para
    Fin Para
FinAlgoritmo

En este caso, la posición “lógica” $(f,c)$ se convierte en un índice lineal del arreglo unidimensional.

En Python, sí se pueden usar listas de listas para simular matrices 2D nativas:

matriz = [
    [0, 0, 0],  # Fila 0
    [0, 0, 0],  # Fila 1
    [0, 0, 0]   # Fila 2
]

matriz[1][2] = 999
print(matriz[1][2])  # Accede a la segunda fila, tercera columna

Importante

• Rango de índices:
  • PSeInt estándar típicamente indexa de 1 a tamaño.
  • Python indexa de 0 a tamaño-1.
• Tipo de dato:
  • En PSeInt, si declaras un arreglo de Entero, no puedes asignar valores de tipo Cadena o Real a ese arreglo.
• Errores fuera de rango:
  • Si tratas de acceder a numeros[6] en un arreglo de tamaño 5, PSeInt lanza un error.
• Matrices 2D “nativas”:
  • Sólo disponibles en algunos modos de PSeInt (tradicional/avanzado). De lo contrario, usar la técnica de indexación manual mostrada.

Acceso y modificación de elementos

Los arrays son estructuras que permiten almacenar múltiples valores en una sola variable, accediendo a cada elemento mediante un índice. En PseInt, para acceder a un elemento específico del array, se utiliza la siguiente sintaxis:

variable <- miArray[indice]

Es fundamental recordar que en PseInt los índices comienzan en 1, a diferencia de otros lenguajes como Python, donde los índices empiezan en 0. Por ejemplo, para acceder al primer elemento de un array en PseInt:

primerValor <- miArray[1]

En Python, accederíamos al primer elemento así:

primer_valor = mi_array[0]

Para modificar un elemento del array, simplemente asignamos un nuevo valor a la posición deseada. Si deseamos cambiar el tercer elemento del array en PseInt:

miArray[3] <- nuevoValor

En Python, la asignación correspondiente sería:

mi_array[2] = nuevo_valor

Es importante asegurarse de que el índice utilizado está dentro del rango válido del array. Acceder o modificar una posición fuera de los límites en PseInt provocará un error en tiempo de ejecución. Por ello, es buena práctica verificar los límites antes de realizar cualquier operación:

Si indice >= 1 Y indice <= tamaño Entonces
    miArray[indice] <- valor
Sino
    Escribir "Error: Índice fuera de rango."
FinSi

En Python, la verificación sería:

if 0 <= indice < tamaño:
    mi_array[indice] = valor
else:
    print("Error: Índice fuera de rango.")

Podemos utilizar variables como índices para acceder dinámicamente a los elementos. Por ejemplo, incrementando cada elemento del array en PseInt:

Para i <- 1 Hasta tamaño Hacer
    miArray[i] <- miArray[i] + 1
Fin Para

Y en Python:

for i in range(tamaño):
    mi_array[i] = mi_array[i] + 1

Si deseamos intercambiar los valores de dos elementos en PseInt, podemos hacerlo utilizando una variable temporal:

Definir temp Como Entero
temp <- miArray[1]
miArray[1] <- miArray[2]
miArray[2] <- temp

En Python, es posible intercambiar valores sin necesidad de una variable temporal:

mi_array[0], mi_array[1] = mi_array[1], mi_array[0]

Al trabajar con arrays multidimensionales, el acceso y modificación requieren utilizar múltiples índices. Por ejemplo, asignando un valor en una matriz en PseInt:

matriz[2,3] <- valor

En Python, si utilizamos listas de listas:

matriz[1][2] = valor

Es crucial manejar correctamente los índices para evitar errores y garantizar que estamos accediendo al elemento deseado. En arrays multidimensionales, los índices representan la posición en cada dimensión, por lo que debemos prestar atención al orden y rango de cada uno.

Cuando necesitamos inicializar o modificar masivamente los elementos de un array, los bucles son herramientas eficientes. Por ejemplo, para establecer todos los elementos de un array a cero en PseInt:

Para i <- 1 Hasta tamaño Hacer
    miArray[i] <- 0
Fin Para

El equivalente en Python sería:

for i in range(tamaño):
    mi_array[i] = 0

También podemos solicitar datos al usuario para llenar un array en tiempo de ejecución:

Para i <- 1 Hasta tamaño Hacer
    Escribir "Ingrese el valor para la posición ", i, ":"
    Leer miArray[i]
Fin Para

En Python:

for i in range(tamaño):
    mi_array[i] = int(input(f"Ingrese el valor para la posición {i + 1}: "))

La capacidad de acceder y modificar elementos es esencial para procesar y manipular datos almacenados en arrays. Una comprensión sólida de cómo funcionan los índices y cómo interactuar con ellos nos permite implementar algoritmos más eficientes y efectivos en nuestras aplicaciones.

A continuación se presenta un ejemplo completo en PSeInt donde se declara un arreglo (array) llamado miArray con un tamaño específico antes de utilizarlo en las operaciones de acceso y modificación:

Algoritmo EjemploCompleto
    Definir tamaño, i Como Entero
    
    // Especificamos el tamaño del arreglo
    tamaño <- 5
    
    // Declaramos el arreglo unidimensional "miArray" de tipo Entero y con 5 posiciones
    Dimension miArray[tamaño]
    
    // Asignamos valores iniciales a cada posición
    Para i <- 1 Hasta tamaño Hacer
        miArray[i] <- i * 10   // Por ejemplo, 10, 20, 30, 40, 50
    Fin Para
    
    // Mostramos los valores iniciales
    Escribir "Valores iniciales del arreglo:"
    Para i <- 1 Hasta tamaño Hacer
        Escribir "miArray[", i, "] = ", miArray[i]
    Fin Para
    
    // Incrementamos cada elemento en 5 unidades
    Para i <- 1 Hasta tamaño Hacer
        miArray[i] <- miArray[i] + 5
    Fin Para
    
    // Mostramos los valores después del incremento
    Escribir "Valores después de incrementar:"
    Para i <- 1 Hasta tamaño Hacer
        Escribir "miArray[", i, "] = ", miArray[i]
    Fin Para
FinAlgoritmo

Recorrido de arrays con bucles

El recorrido de arrays es una operación fundamental que permite procesar cada elemento de un array de forma sistemática. En PseInt, los bucles como Para y Mientras son herramientas esenciales para iterar a través de los elementos de un array.

Para recorrer un array utilizando un bucle Para, se sigue la siguiente estructura en PseInt:

Para i <- 1 Hasta tamaño Hacer
    // Operaciones con miArray[i]
Fin Para

Por ejemplo, supongamos que tenemos un array de números y deseamos mostrar cada uno de sus elementos:

Algoritmo MostrarArray
    // Declaración de un array de 5 enteros (modo 1D)
    Dimension numeros[5]

    // Asignación de valores
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    // Recorrido con Para
    Para i <- 1 Hasta 5 Hacer
        Escribir "El elemento en la posición ", i, " es: ", numeros[i]
    Fin Para
FinAlgoritmo

En Python, el código equivalente utilizando un bucle for sería:

números = [10, 20, 30, 40, 50]

for i in range(5):
    print(f"El elemento en la posición {i + 1} es: {números[i]}")

Es importante notar que en Python, la función range(5) genera una secuencia de 0 a 4, por lo que se añade 1 al índice para corresponder con la numeración de PseInt.

Alternativamente, en PseInt podemos utilizar un bucle Mientras si no conocemos el tamaño del array o queremos más flexibilidad:

i <- 1
Mientras i <= 5 Hacer
    Escribir "El elemento en la posición ", i, " es: ", numeros[i]
    i <- i + 1
Fin Mientras

El equivalente en Python sería:

i = 0
while i < 5:
    print(f"El elemento en la posición {i + 1} es: {números[i]}")
    i += 1

Cuando necesitamos procesar los elementos de un array, como calcular la suma total o encontrar el valor máximo, los bucles son indispensables. Por ejemplo, para calcular la suma de todos los elementos en PseInt:

suma <- 0
Para i <- 1 Hasta 5 Hacer
    suma <- suma + numeros[i]
Fin Para
Escribir "La suma de los elementos es: ", suma

En Python, el código sería:

suma = 0
for i in range(5):
    suma += números[i]
print(f"La suma de los elementos es: {suma}")

Si queremos recorrer un array y condicionar ciertas operaciones, podemos utilizar estructuras condicionales dentro del bucle. Por ejemplo, mostrar solo los números pares:

Para i <- 1 Hasta 5 Hacer
    Si numeros[i] mod 2 = 0 Entonces
        Escribir "El número ", numeros[i], " es par."
    Fin Si
Fin Para

En Python:

for i in range(5):
    if números[i] % 2 == 0:
        print(f"El número {números[i]} es par.")

Si deseamos buscar un elemento específico en un array, podemos utilizar un bucle para recorrerlo y comparar cada valor:

buscar <- 30
encontrado <- Falso
Para i <- 1 Hasta 5 Hacer
    Si numeros[i] = buscar Entonces
        Escribir "Valor encontrado en la posición ", i
        encontrado <- Verdadero

    Fin Si
Fin Para

Si encontrado = Falso Entonces
    Escribir "Valor no encontrado."
Fin Si

En Python:

buscar = 30
encontrado = False
for i in range(5):
    if números[i] == buscar:
        print(f"Valor encontrado en la posición {i + 1}")
        encontrado = True
        break
if not encontrado:
    print("Valor no encontrado.")

El uso de bucles para recorrer arrays es una práctica esencial que permite implementar algoritmos de búsqueda, ordenación y muchos otros. Comprender cómo iterar eficientemente sobre los elementos de un array es clave para desarrollar programas robustos y eficientes.

En resumen, los bucles son herramientas fundamentales para manipular arrays en PseInt y Python. Dominar su uso te permitirá procesar y analizar grandes cantidades de datos de manera efectiva.

Aplicaciones comunes y manipulación de arrays

Los arrays son una herramienta fundamental en programación que permite manejar conjuntos de datos de manera eficiente. Una de las aplicaciones comunes es el almacenamiento y manipulación de colecciones de datos, como listas de números, cadenas o registros.

Una manipulación habitual de arrays es el cálculo de valores estadísticos. Por ejemplo, calcular la suma, el promedio, el máximo y el mínimo de los elementos almacenados. En PseInt, esto se puede lograr mediante un bucle que recorre el array y acumula los valores.

Por ejemplo, para calcular la suma y el promedio de un array de números:

Algoritmo SumaYPromedio
    Definir numeros Como Real
    Dimension numeros[5]  // Arreglo unidimensional de 5 reales

    // Asignación de valores
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    // Calcular suma y promedio
    Definir suma, promedio Como Real
    suma <- 0
    Para i <- 1 Hasta 5 Hacer
        suma <- suma + numeros[i]
    Fin Para
    promedio <- suma / 5

    // Mostrar resultados
    Escribir "La suma es: ", suma
    Escribir "El promedio es: ", promedio
FinAlgoritmo

En Python, el código equivalente sería:

números = [10, 20, 30, 40, 50]
suma = 0
for i in range(5):
    suma += números[i]
promedio = suma / 5
print("La suma es:", suma)
print("El promedio es:", promedio)

Otra tarea común es la búsqueda de un elemento dentro del array. Esto implica recorrer el array y comparar cada elemento con el valor buscado hasta encontrar una coincidencia.

Por ejemplo, buscando un número específico en PseInt:

Algoritmo BuscarElemento
    Dimension numeros[5]
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50
    
    Definir buscar, encontrado Como Entero
    buscar <- 30
    encontrado <- 0
    
    Para i <- 1 Hasta 5 Hacer
        Si numeros[i] = buscar Entonces
            Escribir "Número encontrado en la posición: ", i
            encontrado <- 1
        Fin Si
    Fin Para
    
    Si encontrado = 0 Entonces
        Escribir "Número no encontrado en el array."
    Fin Si
FinAlgoritmo

Y en Python:

números = [10, 20, 30, 40, 50]
buscar = 30
encontrado = False

for i in range(5):
    if números[i] == buscar:
        print("Número encontrado en la posición:", i + 1)
        encontrado = True
        break

if not encontrado:
    print("Número no encontrado en el array.")

Los arrays también permiten realizar ordenamientos de los datos. Un método sencillo es el ordenamiento de burbuja, donde se comparan pares de elementos adyacentes y se intercambian si están en el orden incorrecto.

Implementación del ordenamiento de burbuja en PseInt:

Algoritmo Burbuja
    Dimension numeros[5]
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    Definir temp Como Entero

    Para i <- 1 Hasta 5 - 1 Hacer
        Para j <- 1 Hasta 5 - i Hacer
            Si numeros[j] > numeros[j + 1] Entonces
                temp <- numeros[j]
                numeros[j] <- numeros[j + 1]
                numeros[j + 1] <- temp
            Fin Si
        Fin Para
    Fin Para

    Escribir "Array ordenado:"
    Para i <- 1 Hasta 5 Hacer
        Escribir numeros[i]
    Fin Para
FinAlgoritmo

Y su equivalente en Python:

números = [10, 20, 30, 40, 50]
for i in range(4):
    for j in range(5 - i - 1):
        if números[j] > números[j + 1]:
            números[j], números[j + 1] = números[j + 1], números[j]

print("Array ordenado:")
for num in números:
    print(num)

Otra operación frecuente es la inversión de arrays, donde se reorganizan los elementos en orden inverso. En PseInt:

Algoritmo InvertirArreglo
    Dimension numeros[5]
    numeros[1] <- 10
    numeros[2] <- 20
    numeros[3] <- 30
    numeros[4] <- 40
    numeros[5] <- 50

    Definir temp Como Entero

    // Intercambiamos posiciones simétricas
    Para i <- 1 Hasta 2 Hacer
        temp <- numeros[i]
        numeros[i] <- numeros[6 - i]
        numeros[6 - i] <- temp
    Fin Para

    Escribir "Array invertido:"
    Para i <- 1 Hasta 5 Hacer
        Escribir numeros[i]
    Fin Para
FinAlgoritmo

En Python, podemos utilizar métodos más directos:

números = [10, 20, 30, 40, 50]
números.reverse()
print("Array invertido:")
for num in números:
    print(num)

En el caso de arrays de cadenas de caracteres, podemos realizar manipulaciones como la concatenación o la búsqueda de subcadenas. Por ejemplo, almacenando nombres y buscando uno específico:

Algoritmo BuscarNombre
    Definir nombres Como Cadena
    Dimension nombres[3]
    
    nombres[1] <- "Ana"
    nombres[2] <- "Luis"
    nombres[3] <- "María"
    
    Definir buscar Como Cadena
    Definir encontrado Como Entero
    buscar <- "Luis"
    encontrado <- 0
    
    Para i <- 1 Hasta 3 Hacer
        Si nombres[i] = buscar Entonces
            Escribir "Nombre encontrado en la posición: ", i
            encontrado <- 1
        Fin Si
    Fin Para
    
    Si encontrado = 0 Entonces
        Escribir "Nombre no encontrado."
    Fin Si
FinAlgoritmo

Python:

nombres = ["Ana", "Luis", "María"]
buscar = "Luis"

if buscar in nombres:
    posicion = nombres.index(buscar) + 1
    print("Nombre encontrado en la posición:", posicion)
else:
    print("Nombre no encontrado.")

La manipulación de arrays permite también filtrar datos. Por ejemplo, crear un nuevo array con los números pares de un array original.

En PseInt:

Algoritmo FiltrarPares
    Dimension numeros[5]
    numeros[1] <- 10
    numeros[2] <- 15
    numeros[3] <- 20
    numeros[4] <- 25
    numeros[5] <- 30

    Dimension pares[5]
    Definir contador Como Entero
    contador <- 1

    Para i <- 1 Hasta 5 Hacer
        Si (numeros[i] mod 2) = 0 Entonces
            pares[contador] <- numeros[i]
            contador <- contador + 1
        Fin Si
    Fin Para

    Escribir "Números pares:"
    Para i <- 1 Hasta contador - 1 Hacer
        Escribir pares[i]
    Fin Para
FinAlgoritmo

En Python:

números = [10, 15, 20, 25, 30]
pares = []

for num in números:
    if num % 2 == 0:
        pares.append(num)

print("Números pares:")
for num in pares:
    print(num)

Finalmente, los arrays son esenciales para implementar estructuras de datos más complejas, como pilas, colas y listas enlazadas. Mediante el correcto uso y manipulación de arrays, es posible desarrollar algoritmos eficientes para resolver problemas diversos en programación.