Operaciones comunes con matrices

Parte de la sección Lógica y Flujo del Journey de C# de Coddy. Lección 6 de 66.

Las matrices se utilizan comúnmente en matemáticas y ciencias de la computación. Exploremos algunas operaciones comunes en arreglos bidimensionales.

Sumar dos matrices:

int[][] AddMatrices(int[][] a, int[][] b)
{
    int rows = a.Length;
    int[][] result = new int[rows][];
    
    for (int i = 0; i < rows; i++)
    {
        result[i] = new int[a[i].Length];
        for (int j = 0; j < a[i].Length; j++)
        {
            result[i][j] = a[i][j] + b[i][j];
        }
    }
    return result;
}

Transponer una matriz (intercambiar filas y columnas):

int[][] Transpose(int[][] matrix)
{
    int rows = matrix.Length;
    int cols = matrix[0].Length;
    
    int[][] result = new int[cols][];
    for (int i = 0; i < cols; i++)
    {
        result[i] = new int[rows];
        for (int j = 0; j < rows; j++)
        {
            result[i][j] = matrix[j][i];
        }
    }
    return result;
}

Calcula la suma de cada fila:

int[] RowSums(int[][] matrix)
{
    int rows = matrix.Length;
    int[] sums = new int[rows];
    
    for (int i = 0; i < rows; i++)
    {
        int sum = 0;
        for (int j = 0; j < matrix[i].Length; j++)
        {
            sum += matrix[i][j];
        }
        sums[i] = sum;
    }
    return sums;
}

Multiplica dos matrices entre sí:

En la multiplicación de matrices, cada elemento result[i][j] se calcula tomando la fila i de la primera matriz y la columna j de la segunda matriz, multiplicando sus elementos correspondientes y sumando los productos. Formalmente: result[i][j] = sum of matrix1[i][k] * matrix2[k][j] para todos los valores válidos de k.
Para que esto funcione, el número de columnas de matrix1 debe ser igual al número de filas de matrix2. La matriz resultante tiene dimensiones [matrix1.rows × matrix2.cols].

int[][] MultiplyMatrices(int[][] a, int[][] b)
{
    int rows = a.Length;
    int cols = b[0].Length;
    int inner = b.Length;
    
    int[][] result = new int[rows][];
    for (int i = 0; i < rows; i++)
    {
        result[i] = new int[cols];
        for (int j = 0; j < cols; j++)
        {
            int sum = 0;
            for (int k = 0; k < inner; k++)
            {
                sum += a[i][k] * b[k][j];
            }
            result[i][j] = sum;
        }
    }
    return result;
}

Desafío

Difícil

Crea un método llamado multiplyMatrices que:

Acepte dos matrices (arreglos irregulares bidimensionales) como parámetros: matrix1 y matrix2
Las multiplique siguiendo las reglas de la multiplicación de matrices
Devuelva la matriz resultante

Para que la multiplicación de matrices sea válida:

El número de columnas de matrix1 debe ser igual al número de filas de matrix2
El resultado tendrá las dimensiones: [matrix1.rows × matrix2.columns]

Cómo funciona la multiplicación de matrices:
Cada elemento en la posición [i][j] del resultado se calcula tomando la fila i de matrix1 y la columna j de matrix2, multiplicando entre sí sus elementos correspondientes y sumando todos esos productos:

result[i][j] = matrix1[i][0] * matrix2[0][j] + matrix1[i][1] * matrix2[1][j] + ...

En otras palabras: result[i][j] = sum of (matrix1[i][k] * matrix2[k][j]) para cada k.

Por ejemplo, si matrix1 es:

[1, 2]
[3, 4]

Y matrix2 es:

[5, 6]
[7, 8]

Después, result[0][0] = 1*5 + 2*7 = 19, result[0][1] = 1*6 + 2*8 = 22, y así sucesivamente. El resultado debería ser:

[19, 22]
[43, 50]

Si las matrices no se pueden multiplicar, devuelve null.

Pruébalo tú mismo

public class MultiplyMatrices
{
    // Implementa el método MultiplyMatrices
    public static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2)
    {
        // Escribe tu código aquí
        
    }
}