Definición y declaración de matrices bidimensionales

Una matriz bidimensional es una estructura de datos que permite almacenar elementos en forma de tabla con filas y columnas. Es decir, cada elemento se identifica por dos índices: uno que indica la fila y otro que indica la columna.

En PseInt, para declarar una matriz bidimensional, se utiliza la palabra clave Dimension seguida del nombre de la matriz y las dimensiones correspondientes. Por ejemplo, si queremos crear una matriz llamada matrizNumeros de 3 filas y 4 columnas, lo haríamos de la siguiente manera:

Dimension matrizNumeros[3,4]

En este ejemplo, hemos declarado una matriz llamada matrizNumeros con 3 filas y 4 columnas. Cada posición en esta matriz puede ser accedida utilizando dos índices, uno para la fila y otro para la columna.

Equivalente en Python, la declaración de una matriz bidimensional se realiza mediante listas anidadas. Para crear una matriz de 3 filas y 4 columnas inicializada con ceros, escribiríamos:

matriz_numeros = [[0 for columna in range(4)] for fila in range(3)]

En PseInt, si queremos declarar una matriz bidimensional sin especificar inicialmente su tamaño, podemos utilizar variables para definir sus dimensiones. Por ejemplo:

Definir filas, columnas Como Entero
Escribir "Ingrese el número de filas:"
Leer filas
Escribir "Ingrese el número de columnas:"
Leer columnas
Dimension matrizDatos[filas,columnas]

Aquí, hemos declarado la matriz matrizDatos con dimensiones definidas por las variables filas y columnas, permitiendo así una mayor flexibilidad en nuestro programa.

El equivalente en Python para este caso sería:

filas = int(input("Ingrese el número de filas: "))
columnas = int(input("Ingrese el número de columnas: "))
matriz_datos = [[0 for columna in range(columnas)] for fila in range(filas)]

Es importante destacar que en PseInt, las matrices pueden manejar diferentes tipos de datos, no solo numéricos. Por ejemplo, podemos declarar una matriz de cadenas de texto:

Dimension matrizNombres[5,2]

En este caso, matrizNombres es una matriz de 5 filas y 2 columnas, ideal para almacenar nombres y apellidos.

En Python, podríamos declarar una matriz vacía para almacenar cadenas de la siguiente manera:

matriz_nombres = [["" for columna in range(2)] for fila in range(5)]

Al utilizar matrices bidimensionales, tenemos la capacidad de organizar datos de manera estructurada, lo cual es especialmente útil en aplicaciones como tablas de datos, matrices matemáticas y representaciones de gráficos.

Inicialización y acceso a elementos en matrices

En PseInt, una vez que hemos declarado una matriz bidimensional, podemos proceder a su inicialización y a acceder a sus elementos individuales. La inicialización consiste en asignar valores a las posiciones de la matriz, mientras que el acceso nos permite leer o modificar dichos valores.

Para inicializar una matriz, asignamos valores a cada posición utilizando sus índices de fila y columna. Por ejemplo, si tenemos una matriz llamada matrizValores de 2 filas y 3 columnas:

Dimension matrizValores[2,3]

Podemos asignar valores específicos de la siguiente manera:

matrizValores[1,1] <- 10
matrizValores[1,2] <- 20
matrizValores[1,3] <- 30
matrizValores[2,1] <- 40
matrizValores[2,2] <- 50
matrizValores[2,3] <- 60

En este ejemplo, estamos asignando valores numéricos a cada posición de la matriz matrizValores. Es importante recordar que en PseInt los índices de las matrices comienzan en 1, no en 0.

El equivalente en Python sería:

matriz_valores = [[0 for columna in range(3)] for fila in range(2)]

matriz_valores[0][0] = 10
matriz_valores[0][1] = 20
matriz_valores[0][2] = 30
matriz_valores[1][0] = 40
matriz_valores[1][1] = 50
matriz_valores[1][2] = 60

En Python, los índices comienzan en 0, por lo que matriz_valores[0][0] corresponde a la primera fila y primera columna.

Para acceder a un elemento específico de la matriz en PseInt, utilizamos los índices de fila y columna. Por ejemplo, para mostrar en pantalla el valor ubicado en la segunda fila y tercera columna:

Escribir "El valor es: ", matrizValores[2,3]

En Python, accederíamos al mismo elemento de la siguiente forma:

print("El valor es:", matriz_valores[1][2])

Nuevamente, recordando que los índices en Python comienzan en 0.

Si queremos inicializar la matriz mediante bucles, podemos utilizar bucles anidados para recorrer todas las posiciones:

Para i <- 1 Hasta 2 Hacer
    Para j <- 1 Hasta 3 Hacer
        matrizValores[i,j] <- i * j
    FinPara
FinPara

En este ejemplo, estamos asignando a cada posición de la matriz el producto de sus índices de fila (i) y columna (j). Usando bucles anidados, podemos recorrer toda la matriz de forma eficiente.

El código equivalente en Python sería:

for i in range(2):
    for j in range(3):
        matriz_valores[i][j] = (i + 1) * (j + 1)

Notar que en Python sumamos 1 a los índices i y j al realizar la multiplicación, para mantener la misma lógica que en PseInt.

Para mostrar todos los elementos de la matriz en pantalla, también utilizamos bucles anidados:

Para i <- 1 Hasta 2 Hacer
    Para j <- 1 Hasta 3 Hacer
        Escribir "Elemento [", i, ",", j, "] = ", matrizValores[i,j]
    FinPara
FinPara

En Python:

for i in range(2):
    for j in range(3):
        print("Elemento [", i + 1, ",", j + 1, "] =", matriz_valores[i][j])

En este caso, incrementamos los índices i y j al imprimir para reflejar la numeración iniciada en 1 de PseInt.

La modificación de elementos se realiza accediendo a la posición deseada y asignando un nuevo valor. Por ejemplo, si queremos cambiar el valor de la posición [2,2] en PseInt:

matrizValores[2,2] <- 99

En Python:

matriz_valores[1][1] = 99

Es crucial entender cómo funcionan los índices en cada lenguaje para evitar errores al acceder o modificar elementos. En PseInt, los índices comienzan en 1, mientras que en Python comienzan en 0.

Al utilizar matrices para almacenar datos, el acceso y modificación adecuados de sus elementos nos permiten realizar operaciones más complejas, como algoritmos de búsqueda o procesamiento de información en estructuras bidimensionales. La comprensión de la inicialización y el acceso a elementos es fundamental para manipular matrices de manera eficiente.

Iteración sobre matrices anidadas

La iteración es una herramienta fundamental al trabajar con matrices bidimensionales, ya que permite recorrer y manipular cada uno de sus elementos de forma sistemática. Utilizando bucles anidados, podemos aplicar operaciones a todos los elementos de una matriz o a subconjuntos específicos.

Para iterar sobre una matriz en PseInt, empleamos un bucle externo que recorre las filas y un bucle interno que recorre las columnas. Por ejemplo, si deseamos sumar todos los elementos de una matriz llamada matrizNumeros de dimensión [m,n], el código sería:

// Supongamos que m y n están definidos como el número de filas y columnas
// y "matrizNumeros" es una matriz [1..m, 1..n].

Definir m, n Como Entero
Definir i, j Como Entero
Definir suma Como Entero
suma <- 0

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        suma <- suma + matrizNumeros[i,j]
    Fin Para
Fin Para

Escribir "La suma de los elementos es: ", suma

En este ejemplo, estamos utilizando dos variables de control, i para las filas y j para las columnas. El bucle interior recorre todas las columnas para una fila dada, mientras que el bucle exterior avanza a la siguiente fila.

El equivalente en Python sería:

suma = 0
for i in range(m):
    for j in range(n):
        suma += matriz_numeros[i][j]
print("La suma de los elementos es:", suma)

Al iterar sobre matrices, es importante tener en cuenta el orden de los bucles. Si necesitamos recorrer las columnas antes que las filas, simplemente invertimos los bucles:

Para j <- 1 Hasta n Hacer
    Para i <- 1 Hasta m Hacer
        // Procesar matrizNumeros[i,j]
    Fin Para
Fin Para

Este enfoque puede ser útil en ciertas aplicaciones donde las operaciones se realizan por columnas en lugar de por filas.

Supongamos que queremos encontrar el elemento máximo en una matriz. Podemos implementar el siguiente algoritmo:

// Asumimos que matrizNumeros[1..m, 1..n] está declarada y m, n definidos.

Definir maximo Como Real
maximo <- matrizNumeros[1,1]

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        Si matrizNumeros[i,j] > maximo Entonces
            maximo <- matrizNumeros[i,j]
        Fin Si
    Fin Para
Fin Para

Escribir "El elemento máximo es: ", maximo

En este caso, hemos inicializado la variable maximo con el primer elemento de la matriz y luego, durante la iteración, actualizamos su valor si encontramos un elemento mayor.

El código equivalente en Python sería:

maximo = matriz_numeros[0][0]
for i in range(m):
    for j in range(n):
        if matriz_numeros[i][j] > maximo:
            maximo = matriz_numeros[i][j]
print("El elemento máximo es:", maximo)

Además de iterar completamente sobre una matriz, podemos realizar iteraciones parciales o condicionadas. Por ejemplo, si deseamos contabilizar cuántos elementos cumplen una cierta condición, como ser números pares:

Definir contador Como Entero
contador <- 0

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        Si (matrizNumeros[i,j] mod 2) = 0 Entonces
            contador <- contador + 1
        Fin Si
    Fin Para
Fin Para

Escribir "Hay ", contador, " números pares en la matriz."

Aquí, utilizamos el operador Mod para determinar si un número es par y un contador para llevar la cuenta.

En Python:

contador = 0
for i in range(m):
    for j in range(n):
        if matriz_numeros[i][j] % 2 == 0:
            contador += 1
print("Hay", contador, "números pares en la matriz.")

La iteración sobre matrices también permite realizar operaciones más complejas, como la transposición de la matriz. La transposición consiste en convertir las filas en columnas y viceversa.

En PseInt, podemos crear una nueva matriz matrizTranspuesta para almacenar el resultado:

// Supongamos que m, n están declarados, y matrizNumeros[1..m, 1..n] contiene datos.
// Para la matriz transpuesta se declaran dimensiones [1..n, 1..m].

Dimension matrizTranspuesta[1..n, 1..m]

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        matrizTranspuesta[j,i] <- matrizNumeros[i,j]
    Fin Para
Fin Para

Ahora, matrizTranspuesta tendrá las dimensiones invertidas y los elementos intercambiados.

En Python:

matriz_transpuesta = [[0 for i in range(m)] for j in range(n)]
for i in range(m):
    for j in range(n):
        matriz_transpuesta[j][i] = matriz_numeros[i][j]

Cuando trabajamos con matrices cuadradas (donde m = n), podemos iterar sobre los elementos de la diagonal principal o secundaria:

• Diagonal principal:

Para i <- 1 Hasta n Hacer
    Escribir "Elemento diagonal [", i, ",", i, "]: ", matrizNumeros[i,i]
Fin Para

• Diagonal secundaria:

Para i <- 1 Hasta n Hacer
    Escribir "Diagonal secundaria [", i, ",", (n - i + 1), "]: ", matrizNumeros[i, (n - i + 1)]
Fin Para

Estos ejemplos muestran cómo podemos acceder específicamente a elementos en posiciones particulares sin recorrer toda la matriz.

En Python, accederíamos a la diagonal principal:

for i in range(n):
    print("Elemento diagonal [", i + 1, ",", i + 1, "]:", matriz_numeros[i][i])

Y a la diagonal secundaria:

for i in range(n):
    print("Elemento diagonal secundaria [", i + 1, ",", n - i, "]:", matriz_numeros[i][n - i - 1])

La iteración sobre matrices anidadas es esencial para operaciones como:

• Suma de filas o columnas:

Para i <- 1 Hasta m Hacer
    Definir sumaFila Como Entero
    sumaFila <- 0
    Para j <- 1 Hasta n Hacer
        sumaFila <- sumaFila + matrizNumeros[i,j]
    Fin Para
    Escribir "La suma de la fila ", i, " es: ", sumaFila
Fin Para

En Python:

for i in range(m):
    suma_fila = 0
    for j in range(n):
        suma_fila += matriz_numeros[i][j]
    print("La suma de la fila", i + 1, "es:", suma_fila)

• Conteo de elementos que cumplen una condición:

Definir contadorNegativos Como Entero
contadorNegativos <- 0

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        Si matrizNumeros[i,j] < 0 Entonces
            contadorNegativos <- contadorNegativos + 1
        Fin Si
    Fin Para
Fin Para

Escribir "Cantidad de números negativos: ", contadorNegativos

En Python:

contador_negativos = 0
for i in range(m):
    for j in range(n):
        if matriz_numeros[i][j] < 0:
            contador_negativos += 1
print("Cantidad de números negativos:", contador_negativos)

Para optimizar las iteraciones, es importante minimizar las operaciones dentro de los bucles y, si es posible, reducir la complejidad del algoritmo. Al trabajar con matrices de gran tamaño, la eficiencia en la iteración puede tener un impacto significativo en el rendimiento del programa.

Finalmente, es crucial asegurarse de que los índices utilizados durante la iteración se encuentran dentro de los límites de la matriz para evitar errores de ejecución. En PseInt, si intentamos acceder a una posición fuera del rango definido, el programa puede generar un error.

La comprensión y el dominio de la iteración sobre matrices anidadas permiten manipular y procesar datos de manera efectiva, lo que es fundamental en áreas como análisis de datos, gráficos computacionales y operaciones matemáticas avanzadas.

Algoritmos básicos aplicados a matrices (búsqueda, ordenación)

En el tratamiento de matrices, es común la necesidad de realizar algoritmos de búsqueda para localizar elementos específicos o aplicar algoritmos de ordenación para organizar los datos de manera más eficiente. Estos algoritmos son fundamentales en aplicaciones como procesamiento de imágenes, análisis de datos y cálculos científicos.

Búsqueda en matrices:

Para buscar un elemento en una matriz bidimensional, podemos utilizar una búsqueda lineal, recorriendo todos los elementos hasta encontrar el valor deseado. Esto implica emplear bucles anidados para acceder a cada posición de la matriz.

Por ejemplo, supongamos que queremos determinar si un número dado se encuentra en una matriz. En PseInt, el algoritmo sería:

Definir numeroBuscado Como Entero
Definir encontrado Como Logico
encontrado <- Falso

Escribir "Ingrese el número a buscar:"
Leer numeroBuscado

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        Si matriz[i,j] = numeroBuscado Entonces
            encontrado <- Verdadero
            Escribir "Número encontrado en la posición [", i, ",", j, "]."

        Fin Si
    Fin Para

    Si encontrado Entonces

    Fin Si
Fin Para

Si no(encontrado) Entonces
    Escribir "Número no encontrado en la matriz."
Fin Si

En este ejemplo, utilizamos la variable encontrado para indicar si el número ha sido localizado, y empleamos el comando Romper para salir de los bucles una vez cumplida la condición.

El código equivalente en Python sería:

numero_buscado = int(input("Ingrese el número a buscar: "))
encontrado = False

for i in range(m):
    for j in range(n):
        if matriz[i][j] == numero_buscado:
            encontrado = True
            print(f"Número encontrado en la posición [{i + 1}, {j + 1}].")
            break
    if encontrado:
        break

if not encontrado:
    print("Número no encontrado en la matriz.")

También es posible buscar elementos que cumplan una condición específica. Por ejemplo, encontrar todos los números pares en una matriz:

Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        Si (matriz[i,j] mod 2) = 0 Entonces
            Escribir "Número par encontrado en [", i, ",", j, "]: ", matriz[i,j]
        Fin Si
    Fin Para
Fin Para

En Python:

for i in range(m):
    for j in range(n):
        if matriz[i][j] % 2 == 0:
            print(f"Número par encontrado en [{i + 1}, {j + 1}]: {matriz[i][j]}")

Ordenación de matrices:

La ordenación de matrices puede ser un proceso más complejo, ya que implica organizar los elementos de acuerdo a un criterio específico. Una opción es ordenar las filas o columnas individualmente, o convertir la matriz en una estructura unidimensional para su ordenación completa.

Ordenación de filas:

Para ordenar cada fila de la matriz, podemos aplicar un algoritmo de ordenación como el ordenamiento burbuja a cada fila de forma independiente.

En PseInt, ordenar cada fila utilizando el ordenamiento burbuja sería:

Para i <- 1 Hasta m Hacer
    Para k <- 1 Hasta n - 1 Hacer
        Para j <- 1 Hasta (n - k) Hacer
            Si matriz[i,j] > matriz[i,j+1] Entonces
                auxiliar <- matriz[i,j]
                matriz[i,j] <- matriz[i,j+1]
                matriz[i,j+1] <- auxiliar
            Fin Si
        Fin Para
    Fin Para
Fin Para

En este código, aplicamos el algoritmo de burbuja para ordenar cada fila de la matriz. La variable auxiliar se utiliza para intercambiar los valores.

El equivalente en Python:

for i in range(m):
    for k in range(n - 1):
        for j in range(n - k - 1):
            if matriz[i][j] > matriz[i][j + 1]:
                matriz[i][j], matriz[i][j + 1] = matriz[i][j + 1], matriz[i][j]

Ordenación completa de la matriz:

Si deseamos ordenar todos los elementos de la matriz como si fueran una única lista, podemos:

1. Convertir la matriz en un vector unidimensional.
2. Aplicar un algoritmo de ordenación al vector.
3. Reconstruir la matriz con los valores ordenados.

En PseInt, el proceso sería:

Dimension vector[1..(m*n)]
k <- 1

// 1) Convertir la matriz en un vector
Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        vector[k] <- matriz[i,j]
        k <- k + 1
    Fin Para
Fin Para

// 2) Ordenar el vector (burbuja)
Para i <- 1 Hasta (m*n) - 1 Hacer
    Para j <- 1 Hasta (m*n) - i Hacer
        Si vector[j] > vector[j+1] Entonces
            auxiliar <- vector[j]
            vector[j] <- vector[j+1]
            vector[j+1] <- auxiliar
        Fin Si
    Fin Para
Fin Para

// 3) Reconstruir la matriz con los valores ordenados
k <- 1
Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        matriz[i,j] <- vector[k]
        k <- k + 1
    Fin Para
Fin Para

En este ejemplo, primero almacenamos todos los elementos de la matriz en un vector unidimensional, luego aplicamos el algoritmo de ordenación y finalmente rellenamos la matriz con los valores ordenados.

El código equivalente en Python:

vector = []

# Convertir la matriz en un vector
for i in range(m):
    for j in range(n):
        vector.append(matriz[i][j])

# Ordenar el vector
for i in range(len(vector) - 1):
    for j in range(len(vector) - i - 1):
        if vector[j] > vector[j + 1]:
            vector[j], vector[j + 1] = vector[j + 1], vector[j]

# Reconstruir la matriz con los valores ordenados
k = 0
for i in range(m):
    for j in range(n):
        matriz[i][j] = vector[k]
        k += 1

Búsqueda binaria en matrices ordenadas:

Si la matriz está ordenada, podemos implementar una búsqueda binaria para localizar elementos de manera más eficiente. Sin embargo, la búsqueda binaria estándar se aplica a arrays unidimensionales, por lo que en matrices bidimensionales necesitamos adaptar el método.

Una opción es tratar la matriz como una estructura lineal utilizando una fórmula para convertir las coordenadas bidimensionales a un índice unidimensional:

k = (i - 1) * n + j

Donde n es el número de columnas. En PseInt, podríamos implementar la búsqueda binaria así:

Dimension vector[1..(m*n)]
k <- 1

// Convertir la matriz en un vector
Para i <- 1 Hasta m Hacer
    Para j <- 1 Hasta n Hacer
        vector[k] <- matriz[i,j]
        k <- k + 1
    Fin Para
Fin Para

// Suponemos que vector ya está ordenado
Definir inicio, fin, medio Como Entero
Definir numeroBuscado Como Entero
Definir encontrado Como Logico
encontrado <- Falso

Escribir "Ingrese el número a buscar:"
Leer numeroBuscado

inicio <- 1
fin <- m * n

Mientras inicio <= fin Hacer
    medio <- Trunc((inicio + fin) / 2)
    Si vector[medio] = numeroBuscado Entonces
        encontrado <- Verdadero
        Escribir "Número encontrado en la posición lineal: ", medio
        // Convertir índice lineal a (i, j)
        i <- Trunc((medio - 1) / n) + 1
        j <- ((medio - 1) mod n) + 1
        Escribir "Ubicado en la posición [", i, ",", j, "]."

    Sino
        Si vector[medio] < numeroBuscado Entonces
            inicio <- medio + 1
        Sino
            fin <- medio - 1
        Fin Si
    Fin Si
Fin Mientras

Si no(encontrado) Entonces
    Escribir "Número no encontrado en la matriz."
Fin Si

En Python, la implementación sería:

vector = []

# Convertir la matriz en un vector
for i in range(m):
    for j in range(n):
        vector.append(matriz[i][j])

# Implementar búsqueda binaria
inicio = 0
fin = len(vector) - 1
encontrado = False

numero_buscado = int(input("Ingrese el número a buscar: "))

while inicio <= fin:
    medio = (inicio + fin) // 2
    if vector[medio] == numero_buscado:
        encontrado = True
        print("Número encontrado en la posición lineal:", medio + 1)
        # Convertir a índices bidimensionales
        i = medio // n
        j = medio % n
        print(f"Ubicado en la posición [{i + 1}, {j + 1}] de la matriz.")
        break
    elif vector[medio] < numero_buscado:
        inicio = medio + 1
    else:
        fin = medio - 1

if not encontrado:
    print("Número no encontrado en la matriz.")

Ordenación de columnas:

Similar a la ordenación de filas, podemos ordenar las columnas de una matriz. Esto implica iterar sobre las filas para cada columna y aplicar un algoritmo de ordenación como el ordenamiento por inserción.

En PseInt, ordenar las columnas de la matriz:

Para j <- 1 Hasta n Hacer
    Para i <- 2 Hasta m Hacer
        clave <- matriz[i,j]
        k <- i - 1
        Mientras k >= 1 y matriz[k,j] > clave Hacer
            matriz[k+1,j] <- matriz[k,j]
            k <- k - 1
        Fin Mientras
        matriz[k+1,j] <- clave
    Fin Para
Fin Para

En este código, utilizamos el algoritmo de ordenamiento por inserción para ordenar cada columna. La variable clave almacena el valor que se va a posicionar correctamente en la columna.

El equivalente en Python:

for j in range(n):
    for i in range(1, m):
        clave = matriz[i][j]
        k = i - 1
        while k >= 0 and matriz[k][j] > clave:
            matriz[k + 1][j] = matriz[k][j]
            k -= 1
        matriz[k + 1][j] = clave

Aplicaciones prácticas:

• Ordenar datos tabulares: En una matriz que representa una tabla, podemos ordenar las filas o columnas según ciertos criterios, lo cual es fundamental en operaciones de minería de datos y análisis estadístico.
• Optimización de búsquedas: Al ordenar una matriz, las búsquedas posteriores pueden ser más eficientes, especialmente al utilizar algoritmos como la búsqueda binaria.
• Procesamiento de imágenes: Las matrices representan píxeles en imágenes digitales, y aplicar algoritmos de búsqueda y ordenación es esencial en filtros y transformaciones de imágenes.

La aplicación de algoritmos básicos en matrices permite manipular y analizar grandes conjuntos de datos de manera eficiente. La combinación de búsquedas y ordenaciones es una habilidad clave en la resolución de problemas complejos en programación.