عمليات المصفوفات الشائعة

جزء من قسم Logic & Flow في رحلة C# على Coddy — الدرس 6 من 66.

تُستخدم المصفوفات بشكل شائع في الرياضيات وعلوم الحاسوب. دعونا نستكشف بعض العمليات الشائعة على المصفوفات ثنائية الأبعاد.

جمع مصفوفتين معاً:

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

تبديل مصفوفة (تبديل الصفوف والأعمدة):

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

احسب مجموع كل صف:

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

ضرب مصفوفتين معاً:

في ضرب المصفوفات، يتم حساب كل عنصر result[i][j] باعتباره الضرب النقطي للصف i من المصفوفة الأولى والعمود j من المصفوفة الثانية — أي مجموع matrix1[i][k] * matrix2[k][j] لكل k. يجب أن تحتوي المصفوفة الأولى على عدد من الأعمدة يساوي عدد الصفوف في المصفوفة الثانية.

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

التحدي

صعب

قم بإنشاء طريقة تسمى multiplyMatrices تقوم بما يلي:

تأخذ مصفوفتين (مصفوفات مسننة ثنائية الأبعاد 2D jagged arrays) كمعاملات: matrix1 و matrix2
تقوم بضربهما باتباع قواعد ضرب المصفوفات
تعيد المصفوفة الناتجة

لكي يكون ضرب المصفوفات صالحاً:

يجب أن يكون عدد الأعمدة في matrix1 مساوياً لعدد الصفوف في matrix2
ستكون أبعاد النتيجة: [matrix1.rows × matrix2.columns]

كيفية عمل ضرب المصفوفات:
يتم حساب كل عنصر في الموضع [i][j] في النتيجة عن طريق أخذ الصف i من matrix1 والعمود j من matrix2، وضرب عناصرهما المتقابلة معاً، وجمع كل تلك النواتج:

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

بمعنى آخر: result[i][j] = sum of (matrix1[i][k] * matrix2[k][j]) لكل k.

على سبيل المثال، إذا كانت matrix1 هي:

[1, 2]
[3, 4]

وكانت matrix2 هي:

[5, 6]
[7, 8]

فإن result[0][0] = 1*5 + 2*7 = 19، و result[0][1] = 1*6 + 2*8 = 22، وهكذا. يجب أن تكون النتيجة:

[19, 22]
[43, 50]

إذا تعذر ضرب المصفوفات، فقم بإرجاع null.

ورقة مرجعية

عمليات المصفوفات الشائعة باستخدام المصفوفات المتعرجة (jagged arrays) ثنائية الأبعاد:

جمع مصفوفتين:

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

تبديل المصفوفة (تبديل الصفوف والأعمدة):

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

حساب مجموع كل صف:

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

ضرب مصفوفتين:
كل عنصر result[i][j] هو مجموع نواتج ضرب الصف i من المصفوفة الأولى والعمود j من المصفوفة الثانية:
result[i][j] += matrix1[i][k] * matrix2[k][j] لكل k.
يجب أن تحتوي المصفوفة الأولى على عدد أعمدة يساوي عدد صفوف المصفوفة الثانية.

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++)
        {
            for (int k = 0; k < inner; k++)
            {
                result[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return result;
}

جرّب بنفسك

public class MultiplyMatrices
{
    // قم بتنفيذ دالة ضرب المصفوفات
    public static int[][] multiplyMatrices(int[][] matrix1, int[][] matrix2)
    {
        // اكتب الكود الخاص بك هنا
        
    }
}