Opérations matricielles courantes

Fait partie de la section Logique & Flux du Journey C# de Coddy — leçon 6 sur 66.

Les matrices sont couramment utilisées en mathématiques et en informatique. Explorons quelques opérations courantes sur les tableaux en 2D.

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

Transposer une matrice (intervertir les lignes et les colonnes) :

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

Calculez la somme de chaque ligne :

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

Multiplier deux matrices entre elles :

Dans la multiplication de matrices, chaque élément result[i][j] est calculé en prenant la ligne i de la première matrice et la colonne j de la deuxième matrice, en multipliant leurs éléments correspondants et en additionnant les produits. Formellement : result[i][j] = sum of matrix1[i][k] * matrix2[k][j] pour toutes les valeurs valides de k.
Pour que cela fonctionne, le nombre de colonnes de matrix1 doit être égal au nombre de lignes de matrix2. La matrice résultante a pour dimensions [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;
}

Défi

Difficile

Créez une méthode appelée multiplyMatrices qui :

Prend deux matrices (tableaux dentelés en 2D) comme paramètres : matrix1 et matrix2
Les multiplie en suivant les règles de la multiplication de matrices
Retourne la matrice résultante

Pour que la multiplication de matrices soit valide :

Le nombre de colonnes de matrix1 doit être égal au nombre de lignes de matrix2
Le résultat aura pour dimensions : [matrix1.rows × matrix2.columns]

Comment fonctionne la multiplication de matrices :
Chaque élément à la position [i][j] dans le résultat est calculé en prenant la ligne i de matrix1 et la colonne j de matrix2, en multipliant leurs éléments correspondants ensemble, et en additionnant tous ces produits :

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

En d'autres termes : result[i][j] = sum of (matrix1[i][k] * matrix2[k][j]) pour chaque k.

Par exemple, si matrix1 est :

[1, 2]
[3, 4]

Et matrix2 est :

[5, 6]
[7, 8]

Alors result[0][0] = 1*5 + 2*7 = 19, result[0][1] = 1*6 + 2*8 = 22, et ainsi de suite. Le résultat devrait être :

[19, 22]
[43, 50]

Si les matrices ne peuvent pas être multipliées, retournez null.

Essayez vous-même

public class MultiplyMatrices
{
    // Implémentez la méthode MultiplyMatrices
    public static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2)
    {
        // Écrivez votre code ici
        
    }
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logique & Flux

1Tableaux multidimensionnels

Bases des tableaux 2D Déclaration et initialisation en 2D Accès aux éléments d'un tableau 2D Boucles imbriquées et tableaux 2D Tableaux irréguliersOpérations matricielles courantesRécapitulatif - Multidimensionnel

4Techniques de contrôle de flux

Retours anticipés Clauses de garde Instructions de saut (goto)Break et Continue Aplatir les conditionnelles imbriquées

7Opérateurs logiques avancés

Évaluation court-circuit Opérateurs logiques conditionnels Priorité des opérateurs Récapitulatif - Opérateurs avancés

10HashMap Partie 2

Méthodes HashMap HashMap imbriquée Récapitulatif - Gérer un entrepôt Récapitulatif - Opérations HashMap