Operazioni comuni sulle matrici

Fa parte della sezione Logica e flusso del percorso C# di Coddy. Lezione 6 di 66.

Le matrici sono comunemente usate in matematica e informatica. Esploriamo alcune operazioni comuni sugli array 2D.

Somma due matrici:

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;
}

Trasponi una matrice (scambia righe e colonne):

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;
}

Calcola la somma di ogni riga:

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;
}

Moltiplica due matrici tra loro:

Nella moltiplicazione tra matrici, ogni elemento result[i][j] si calcola prendendo la riga i dalla prima matrice e la colonna j dalla seconda matrice, moltiplicando i rispettivi elementi e sommando i prodotti. Formalmente: result[i][j] = sum of matrix1[i][k] * matrix2[k][j] per tutti i valori validi di k.
Perché funzioni, il numero di colonne di matrix1 deve essere uguale al numero di righe di matrix2. La matrice risultante ha dimensioni [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;
}

Sfida

Difficile

Crea un metodo chiamato multiplyMatrices che:

Accetta due matrici (array frastagliati 2D) come parametri: matrix1 e matrix2
Le moltiplica seguendo le regole della moltiplicazione tra matrici
Restituisce la matrice risultante

Affinché la moltiplicazione tra matrici sia valida:

Il numero di colonne di matrix1 deve essere uguale al numero di righe di matrix2
Il risultato avrà dimensioni: [matrix1.rows × matrix2.columns]

Come funziona la moltiplicazione tra matrici:
Ogni elemento nella posizione [i][j] del risultato viene calcolato prendendo la riga i di matrix1 e la colonna j di matrix2, moltiplicando tra loro gli elementi corrispondenti e sommando tutti questi prodotti:

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

In altre parole: result[i][j] = sum of (matrix1[i][k] * matrix2[k][j]) per ogni k.

Per esempio, se matrix1 è:

[1, 2]
[3, 4]

E matrix2 è:

[5, 6]
[7, 8]

Allora result[0][0] = 1*5 + 2*7 = 19, result[0][1] = 1*6 + 2*8 = 22 e così via. Il risultato dovrebbe essere:

[19, 22]
[43, 50]

Se non è possibile moltiplicare le matrici, restituisci null.

Provalo tu

public class MultiplyMatrices
{
    // Implementa il metodo MultiplyMatrices
    public static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2)
    {
        // Scrivi il tuo codice qui
        
    }
}