Ejercicios de matrices

Ejercicios para trabajar con arreglos bidimensionales (matrices), tanto estáticas como dinámicas.

1: Operaciones Básicas¶

1.1: Mostrar Matriz¶

Descripción¶

Escribir una función que reciba una matriz (un arreglo 2D), sus dimensiones (filas y columnas), y la imprima en la consola de una forma clara y ordenada, fila por fila.

Una matriz 2x3: 
[[1, 2, 3], [4, 5, 6]]

Matriz (2x3):
[ 1, 2, 3 ]
[ 4, 5, 6 ]

PROCEDIMIENTO mostrar_matriz(matriz, filas, columnas)
INICIO
    PARA f DESDE 0 HASTA filas-1 HACER
        ESCRIBIR "[ " SIN SALTO DE LÍNEA
        PARA c DESDE 0 HASTA columnas-1 HACER
            ESCRIBIR matriz[f][c]
            SI c < columnas-1 ENTONCES
                ESCRIBIR ", " SIN SALTO DE LÍNEA
            FIN SI
        FIN PARA
        ESCRIBIR " ]" CON SALTO DE LÍNEA
    FIN PARA
FIN PROCEDIMIENTO

1.2: Multiplicación por un escalar¶

Descripción¶

Implementar una función que multiplique cada elemento de una matriz por un número escalar dado. La operación modifica la matriz original (in-place).

Matriz: [[1, 2], [3, 4]]
Escalar: 5

Matriz modificada: [[5, 10], [15, 20]]

PROCEDIMIENTO multiplicar_por_escalar(REF matriz, filas, columnas, escalar)
INICIO
    PARA f DESDE 0 HASTA filas-1 HACER
        PARA c DESDE 0 HASTA columnas-1 HACER
            matriz[f][c] = matriz[f][c] * escalar
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

2: Aritmética Matricial¶

2.1: Suma de matrices¶

Descripción¶

Implementar una función que sume dos matrices, A y B, y almacene el resultado en una tercera matriz, C. La suma de matrices solo es posible si ambas tienen las mismas dimensiones.

Matriz A: [[1, 2], [3, 4]]
Matriz B: [[5, 6], [7, 8]]

Matriz C: [[6, 8], [10, 12]]
```text

PROCEDIMIENTO sumar_matrices(A, B, REF C, filas, columnas)
INICIO
    PARA f DESDE 0 HASTA filas-1 HACER
        PARA c DESDE 0 HASTA columnas-1 HACER
            C[f][c] = A[f][c] + B[f][c]
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

2.2: Multiplicación de matrices¶

Descripción¶

Implementar la multiplicación de dos matrices, A (de $m \times n$) y B (de $n \times p$), cuyo resultado es una nueva matriz C (de $m \times p$).

Matriz A (2x3): [[1, 2, 3], [4, 5, 6]]
Matriz B (3x2): [[7, 8], [9, 10], [11, 12]]

Matriz C (2x2): [[58, 64], [139, 154]]

PROCEDIMIENTO multiplicar_matrices(A, m, n, B, p, REF C)
INICIO
    // Asumiendo que n == p
    PARA i DESDE 0 HASTA m-1 HACER
        PARA j DESDE 0 HASTA p-1 HACER
            suma = 0
            PARA k DESDE 0 HASTA n-1 HACER
                suma = suma + A[i][k] * B[k][j]
            FIN PARA
            C[i][j] = suma
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

3: Manipulación¶

3.1: Transposición¶

Descripción¶

Calcular la transpuesta $A^T$ de una matriz $A$. La transposición se obtiene intercambiando las filas por las columnas.

Matriz A (2x3): `[[1, 2, 3], [4, 5, 6]]`

[ 1, 4 ]
[ 2, 5 ]
[ 3, 6 ]

PROCEDIMIENTO transponer_matriz(A, filas, columnas, REF A_T)
INICIO
    PARA i DESDE 0 HASTA filas-1 HACER
        PARA j DESDE 0 HASTA columnas-1 HACER
            A_T[j][i] = A[i][j]
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

3.2: Suma de diagonales¶

Descripción¶

Para una matriz cuadrada, calcular la suma de los elementos de sus dos diagonales: la principal y la secundaria.

[ 1, 2, 3 ]
[ 4, 5, 6 ]
[ 7, 8, 9 ]

Suma Diagonal Principal: `1 + 5 + 9 = 15`
Suma Diagonal Secundaria: `3 + 5 + 7 = 15`

PROCEDIMIENTO sumar_diagonales(matriz, n, REF suma_princ, REF suma_sec)
INICIO
    suma_princ = 0
    suma_sec = 0
    PARA i DESDE 0 HASTA n-1 HACER
        suma_princ = suma_princ + matriz[i][i]
        suma_sec = suma_sec + matriz[i][n-1-i]
    FIN PARA
FIN PROCEDIMIENTO

4: Generación¶

4.1: Matriz Identidad¶

Descripción¶

Generar una matriz identidad de tamaño n x n. La matriz identidad es una matriz cuadrada con unos en la diagonal principal y ceros en todas las demás posiciones.

Tamaño n = 3

[ 1, 0, 0 ]
[ 0, 1, 0 ]
[ 0, 0, 1 ]

PROCEDIMIENTO generar_identidad(REF matriz, n)
INICIO
    PARA i DESDE 0 HASTA n-1 HACER
        PARA j DESDE 0 HASTA n-1 HACER
            SI i == j ENTONCES
                matriz[i][j] = 1
            SINO
                matriz[i][j] = 0
            FIN SI
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

5: Ejercicios Adicionales de Matrices¶

5.1: Matriz Simétrica¶

Descripción¶

Escribir una función que verifique si una matriz cuadrada es simétrica. Una matriz es simétrica si es igual a su propia transpuesta, lo que significa que el elemento en la fila i, columna j es igual al elemento en la fila j, columna i.

[ 1, 7, 3 ]
[ 7, 4, 5 ]
[ 3, 5, 6 ]

La matriz es simétrica.

FUNCION es_simetrica(matriz, n)
INICIO
    PARA i DESDE 0 HASTA n-1 HACER
        PARA j DESDE i+1 HASTA n-1 HACER
            SI matriz[i][j] != matriz[j][i] ENTONCES
                RETORNAR FALSO
            FIN SI
        FIN PARA
    FIN PARA
    RETORNAR VERDADERO
FIN FUNCION

5.2: Suma por Filas y Columnas¶

Descripción¶

Crear un programa que, dada una matriz, calcule dos arreglos: uno que contenga la suma de los elementos de cada fila y otro que contenga la suma de los elementos de cada columna.

[ 1, 2, 3 ]
[ 4, 5, 6 ]

Suma de filas: [6, 15]
Suma de columnas: [5, 7, 9]

PROCEDIMIENTO sumar_filas_y_columnas(matriz, filas, cols, REF sumas_filas, REF sumas_cols)
INICIO
    // Inicializar arreglos de suma en 0
    PARA i DESDE 0 HASTA filas-1 HACER
        sumas_filas[i] = 0
    FIN PARA
    PARA j DESDE 0 HASTA cols-1 HACER
        sumas_cols[j] = 0
    FIN PARA

    // Calcular ambas sumas en una sola pasada
    PARA i DESDE 0 HASTA filas-1 HACER
        PARA j DESDE 0 HASTA cols-1 HACER
            sumas_filas[i] = sumas_filas[i] + matriz[i][j]
            sumas_cols[j] = sumas_cols[j] + matriz[i][j]
        FIN PARA
    FIN PARA
FIN PROCEDIMIENTO

5.3: Elemento “Silla”¶

Descripción¶

Encontrar un “punto de silla” en una matriz. Un punto de silla es un elemento que es simultáneamente el valor mínimo en su fila y el valor máximo en su columna.

[ 1, 2, 3 ]
[ 4, 5, 6 ]
[ 7, 8, 9 ]

Punto de silla encontrado en (2, 0) con valor 7.

PROCEDIMIENTO encontrar_punto_silla(matriz, filas, cols)
INICIO
    PARA i DESDE 0 HASTA filas-1 HACER
        // Encontrar el mínimo en la fila i
        min_fila = matriz[i][0]
        min_col_idx = 0
        PARA j DESDE 1 HASTA cols-1 HACER
            SI matriz[i][j] < min_fila ENTONCES
                min_fila = matriz[i][j]
                min_col_idx = j
            FIN SI
        FIN PARA

        // Verificar si es el máximo en su columna
        es_max_columna = VERDADERO
        PARA k DESDE 0 HASTA filas-1 HACER
            SI matriz[k][min_col_idx] > min_fila ENTONCES
                es_max_columna = FALSO
                SALIR DEL LAZO // break
            FIN SI
        FIN PARA

        SI es_max_columna ENTONCES
            ESCRIBIR "Punto de silla en (", i, ", ", min_col_idx, ") con valor ", min_fila
            RETORNAR
        FIN SI
    FIN PARA
    ESCRIBIR "No se encontraron puntos de silla."
FIN PROCEDIMIENTO

6: Ejercicios de Matrices Dinámicas¶

6.1: Crear y Llenar Matriz Dinámica¶

Descripción¶

Escribir una función que solicite al usuario las dimensiones (filas y columnas) y luego los elementos de una matriz, para finalmente imprimirla.

PROCEDIMIENTO crear_y_llenar_matriz_dinamica()
INICIO
    ESCRIBIR "Ingrese el número de filas: " SIN SALTO DE LÍNEA
    LEER filas
    ESCRIBIR "Ingrese el número de columnas: " SIN SALTO DE LÍNEA
    LEER columnas

    // Crear una matriz de 'filas' x 'columnas'
    CREAR matriz[filas][columnas]

    ESCRIBIR "Ingrese los elementos de la matriz:"
    PARA i DESDE 0 HASTA filas-1 HACER
        PARA j DESDE 0 HASTA columnas-1 HACER
            ESCRIBIR "Elemento [", i, "][ ", j, "]: " SIN SALTO DE LÍNEA
            LEER matriz[i][j]
        FIN PARA
    FIN PARA

    // Asumiendo que la función mostrar_matriz está definida
    mostrar_matriz(matriz, filas, columnas)
FIN PROCEDIMIENTO

6: Más Algoritmos con Matrices¶

7.1: Reflejar Matriz¶

Implementar dos funciones: una que refleje una matriz horizontalmente (la primera fila se intercambia con la última, la segunda con la penúltima, etc.) y otra que la refleje verticalmente (la primera columna con la última, etc.).

7.2: Intercambiar Filas o Columnas¶

Crear funciones intercambiar_filas(mat, f1, f2) e intercambiar_columnas(mat, c1, c2) que modifiquen la matriz intercambiando los elementos de las filas o columnas especificadas.

7.3: Búsqueda de Submatriz¶

Escribir una función que determine si una matriz pequeña B (de k x l) se encuentra dentro de una matriz más grande A (de m x n). La función debe devolver las coordenadas de la esquina superior izquierda de la primera ocurrencia, o (-1, -1) si no se encuentra.

7.4: Determinante de Matriz 3x3¶

Calcular el determinante de una matriz 3x3 utilizando la Regla de Sarrus.

7.5: Suavizado de Matriz (Filtro de Caja)¶

Implementar un filtro de “suavizado” o “blur”. Para cada elemento de la matriz, su nuevo valor será el promedio de sus 8 vecinos y él mismo. Los elementos en los bordes requerirán un manejo especial.

7.6: Detección de Bordes (Operador de Sobel)¶

Aplicar un operador de Sobel simple para la detección de bordes. Esto implica “convolucionar” la matriz con un kernel (otra matriz pequeña, ej. 3x3) para resaltar las diferencias de intensidad, como los bordes.

7.7: Matriz de Permutación¶

Verificar si una matriz cuadrada es una matriz de permutación. Esta es una matriz binaria (solo 0s y 1s) que tiene exactamente un 1 en cada fila y en cada columna.

7.8: Producto de Hadamard¶

Implementar el producto de Hadamard (o producto elemento a elemento) de dos matrices A y B de las mismas dimensiones. La matriz resultante C se define como $c_{ij} = a_{ij} \cdot b_{ij}$.

7.9: Rellenar con Triángulo de Pascal¶

Escribir una función que llene una matriz N x N con los valores del Triángulo de Pascal. El elemento (i, j) debe ser $\binom{i}{j}$.

7.10: Matriz Antisimétrica¶

Verificar si una matriz cuadrada es antisimétrica. Una matriz A es antisimétrica si su transpuesta es igual a su negativa, es decir, $A^T = -A$. Esto implica que $a_{ij} = -a_{ji}$ y que todos los elementos de la diagonal principal deben ser cero.

8: Operaciones Avanzadas con Matrices¶

8.1: Norma de Matriz¶

Implementar funciones que calculen diferentes normas de una matriz.

double norma_frobenius(double** matriz, int filas, int cols);
double norma_maxima(double** matriz, int filas, int cols);
double norma_uno(double** matriz, int filas, int cols);

Norma de Frobenius: $||A||_F = \sqrt{\sum_{i,j} a_{ij}^2}$

Norma máxima: $||A||_{\infty} = \max_i \sum_j |a_{ij}|$ (máxima suma de fila)

Norma uno: $||A||_1 = \max_j \sum_i |a_{ij}|$ (máxima suma de columna)

8.2: Traza de Matriz¶

Calcular la traza de una matriz cuadrada (suma de elementos de la diagonal principal).

double traza(double** matriz, int n);

8.3: Rango de Matriz¶

Implementar un algoritmo para calcular el rango de una matriz usando eliminación gaussiana.

int calcular_rango(double** matriz, int filas, int cols);

Estrategia: Reducir la matriz a forma escalonada y contar filas no nulas.

8.4: Matriz de Cofactores¶

Calcular la matriz de cofactores para una matriz cuadrada.

double** matriz_cofactores(double** matriz, int n);

El cofactor $C_{ij}$ se calcula como: $C_{ij} = (-1)^{i+j} M_{ij}$ donde $M_{ij}$ es el menor de la matriz (determinante de la submatriz obtenida eliminando fila $i$ y columna $j$).

8.5: Matriz Inversa¶

Implementar el cálculo de la inversa de una matriz usando el método de Gauss-Jordan.

double** matriz_inversa(double** matriz, int n, bool* invertible);

Algoritmo:

1. Crear matriz aumentada $[A | I]$

2. Aplicar eliminación Gauss-Jordan

3. Si se obtiene $[I | A^{-1}]$, retornar $A^{-1}$

4. Si no es posible, la matriz no es invertible

8.6: Potencia de Matriz¶

Calcular $A^n$ para una matriz cuadrada $A$ y un exponente entero $n$.

double** potencia_matriz(double** matriz, int tam, int exponente);

Optimización: Usar exponenciación rápida para $O(\log n)$ multiplicaciones.

8.7: Descomposición LU¶

Implementar la descomposición LU de una matriz: $A = LU$ donde $L$ es triangular inferior y $U$ es triangular superior.

bool descomposicion_lu(double** A, int n, double** L, double** U);

Aplicación: Resolver sistemas de ecuaciones lineales eficientemente.

8.8: Valores Propios (Power Method)¶

Implementar el método de la potencia para calcular el valor propio dominante de una matriz.

double valor_propio_dominante(double** matriz, int n, double tolerancia);

Algoritmo:

1. Comenzar con vector aleatorio $v$

2. Iterar: $v_{k+1} = \frac{Av_k}{||Av_k||}$

3. El valor propio es $\lambda = v^T A v$

8.9: Matriz de Rotación¶

Implementar funciones para crear y aplicar matrices de rotación 2D y 3D.

double** matriz_rotacion_2d(double angulo);
double** matriz_rotacion_3d_x(double angulo);
double** matriz_rotacion_3d_y(double angulo);
double** matriz_rotacion_3d_z(double angulo);

Matriz de rotación 2D:

8.10: Matriz de Proyección¶

Crear matriz de proyección ortogonal sobre un vector.

double** matriz_proyeccion(double* vector, int n);

Fórmula: $P = \frac{vv^T}{v^Tv}$

9: Algoritmos de Procesamiento de Imágenes¶

Considerar una matriz como una imagen en escala de grises donde cada elemento representa la intensidad de un píxel.

9.1: Umbralización (Thresholding)¶

Convertir una imagen en escala de grises a binaria (solo 0 y 255) usando un umbral.

void umbralizar(int** imagen, int filas, int cols, int umbral);

Algoritmo: Si pixel >= umbral, asignar 255, sino asignar 0.

9.2: Histograma de Imagen¶

Calcular el histograma de una imagen (frecuencia de cada nivel de intensidad).

void calcular_histograma(int** imagen, int filas, int cols, int* histograma);

El histograma tiene 256 posiciones (0-255) que cuentan la frecuencia de cada intensidad.

9.3: Ecualización de Histograma¶

Mejorar el contraste de una imagen mediante ecualización de histograma.

void ecualizar_histograma(int** imagen, int filas, int cols);

Algoritmo:

1. Calcular histograma

2. Calcular función de distribución acumulativa (CDF)

3. Normalizar CDF y aplicar transformación a cada píxel

9.4: Filtro Gaussiano¶

Implementar un filtro gaussiano para suavizado de imagen.

void filtro_gaussiano(double** imagen, int filas, int cols, double sigma);

Kernel gaussiano 3x3:

9.5: Detección de Bordes (Laplaciano)¶

Aplicar el operador Laplaciano para detectar bordes.

void detectar_bordes_laplaciano(int** imagen, int filas, int cols, int** resultado);

Kernel Laplaciano:

10: Matrices Especiales¶

10.1: Matriz de Vandermonde¶

Generar una matriz de Vandermonde a partir de un vector.

double** matriz_vandermonde(double* x, int n, int m);

Definición: $V_{ij} = x_i^{j-1}$

Ejemplo con $x = [1, 2, 3]$ y $m = 4$:

10.2: Matriz de Hilbert¶

Generar una matriz de Hilbert de orden $n$.

double** matriz_hilbert(int n);

Definición: $H_{ij} = \frac{1}{i+j-1}$

Nota: Las matrices de Hilbert son notoriamente mal condicionadas para inversión.

10.3: Matriz de Toeplitz¶

Verificar si una matriz es de Toeplitz (cada diagonal descendente de izquierda a derecha tiene valores constantes).

bool es_toeplitz(int** matriz, int filas, int cols);

Propiedad: $a_{i,j} = a_{i+1,j+1}$

10.4: Matriz Circulante¶

Generar una matriz circulante a partir de su primera fila.

int** matriz_circulante(int* primera_fila, int n);

Ejemplo con primera fila $[1, 2, 3, 4]$:

10.5: Matriz de Hankel¶

Generar una matriz de Hankel (opuesta a Toeplitz: diagonales de arriba-derecha a abajo-izquierda son constantes).

double** matriz_hankel(double* c, double* r, int n);

11: Resolución de Sistemas de Ecuaciones¶

11.1: Sustitución Hacia Adelante¶

Resolver un sistema triangular inferior $Lx = b$.

double* sustitucion_adelante(double** L, double* b, int n);

Algoritmo: Resolver de arriba hacia abajo.

11.2: Sustitución Hacia Atrás¶

Resolver un sistema triangular superior $Ux = b$.

double* sustitucion_atras(double** U, double* b, int n);

Algoritmo: Resolver de abajo hacia arriba.

11.3: Eliminación Gaussiana Completa¶

Implementar eliminación gaussiana con pivoteo completo para resolver $Ax = b$.

double* resolver_sistema(double** A, double* b, int n);

11.4: Método de Jacobi¶

Resolver $Ax = b$ iterativamente usando el método de Jacobi.

double* metodo_jacobi(double** A, double* b, int n, double tolerancia, int max_iter);

Fórmula de iteración:

11.5: Método de Gauss-Seidel¶

Similar a Jacobi pero usa valores actualizados inmediatamente.

double* metodo_gauss_seidel(double** A, double* b, int n, double tolerancia, int max_iter);

Converge más rápido que Jacobi para matrices con diagonal dominante.

12: Operaciones Matriciales con Bloques¶

12.1: Multiplicación por Bloques¶

Implementar multiplicación de matrices usando el algoritmo por bloques (más eficiente para matrices grandes por mejor uso de caché).

double** multiplicar_bloques(double** A, double** B, int n, int tam_bloque);

12.2: Transpuesta por Bloques¶

Implementar transpuesta usando bloques para mejor localidad de caché.

void transponer_bloques(double** matriz, int n, int tam_bloque);

12.3: Strassen para Matrices Grandes¶

Implementar el algoritmo de Strassen para multiplicación rápida de matrices grandes.

double** strassen(double** A, double** B, int n);

Complejidad: $O(n^{2.807})$ vs $O(n^3)$ del método tradicional.