التعامل مع المصفوفات ذات بعدين في الخوارزميات

طرق تعريف مصفوفة ذات بعدين

لتعريف مصفوفة ذات بعدين, يوجد طريقتين:

تعرّف المصفوفة و تعطيها القيم لاحقاً.
تعرّف المصفوفة و تعطيها القيم مباشرةً عند تعريفها.

المصفوفة ذات البعدين شبيهة كثيرة بالمصفوفة ذات البعد الواحد.
الفرق الوحيد بينهما أنه للوصول إلى عنصر في مصفوفة ذات بعدين يجب أن تحدد index السطر و index العامود الموجود فيه العنصر.

طريقة تعريف مصفوفة ذات بعدين و إعطائها القيم لاحقاً

لتعريف مصفوفة من أي نوع سواء ( int, float , double , String... ), نضع فقط الرمزين [][] بعد تحديد نوع البيانات التي ستخزنها, و بهذه الطريقة يفهم الكمبيوتر أننا نريد تعريف مصفوفة ذات بعدين لها نوع محدد.

طريقة تعريف المصفوفة بدون إعطائها قيم أولية

مثال

int[][] matrix = new int[3][5];

هنا قمنا بتعريف مصفوفة ذات بعدين, إسمها matrix, نوعها int و تتألف من 3 أسطر و 5 أعمدة, أي من 15 عنصر.

شرح الكود

كلمة new int نضعها من أجل لغة جافا, و هي تضع القيمة 0 أو 0.0 أو null كقيمة إفتراضية لجميع عناصر المصفوفة بشكل تلقائي كما شرحنا في الدروس السابقة.

شكل المصفوفة في الذاكرة

طريقة الوصول لعناصر المصفوفة

للوصول إلى أي عنصر موجود في المصفوفة, يجب كتابة إسم المصفوفة, ثم تحديد index السطر و index العامود الموجود فيه العنصر الذي نريد الوصول إليه.
ستتعلم ذلك من الأمثلة.

طريقة إعطاء قيم لعناصر المصفوفة

المثال التالي يوضح طريقة إعطاء قيمة لعناصر المصفوفة matrix.

مثال

matrix[0][0] = 6;
matrix[1][2] = -3;
matrix[2][4] = 100;

matrix[0][0]: هنا قمنا بتغيير قيمة العنصر الموجود في السطر الأول و في العامود الأول.
matrix[1][2]: هنا قمنا بتغيير قيمة العنصر الموجود في السطر الثاني و في العامود الثالث.
matrix[2][4]: هنا قمنا بتغيير قيمة العنصر الموجود في السطر الثالث و في العامود الخامس.

شكل المصفوفة في الذاكرة

طريقة عرض القيم المخزنة في عناصر المصفوفة

المثال التالي يوضح طريقة عرض قيم عناصر المصفوفة matrix.

مثال

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الأول
System.out.print("matrix[0][0]: " + matrix[0][0] + "\n" );
System.out.print("matrix[0][1]: " + matrix[0][1] + "\n" );
System.out.print("matrix[0][2]: " + matrix[0][2] + "\n" );
System.out.print("matrix[0][3]: " + matrix[0][3] + "\n" );
System.out.print("matrix[0][4]: " + matrix[0][4] + "\n\n" );

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثاني
System.out.print("matrix[1][0]: " + matrix[1][0] + "\n" );
System.out.print("matrix[1][1]: " + matrix[1][1] + "\n" );
System.out.print("matrix[1][2]: " + matrix[1][2] + "\n" );
System.out.print("matrix[1][3]: " + matrix[1][3] + "\n" );
System.out.print("matrix[1][4]: " + matrix[1][4] + "\n\n" );

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثالث
System.out.print("matrix[2][0]: " + matrix[2][0] + "\n" );
System.out.print("matrix[2][1]: " + matrix[2][1] + "\n" );
System.out.print("matrix[2][2]: " + matrix[2][2] + "\n" );
System.out.print("matrix[2][3]: " + matrix[2][3] + "\n" );
System.out.print("matrix[2][4]: " + matrix[2][4] + "\n\n" );

هنا قمنا بعرض قيم جميع العناصر الموجودة في المصفوفة matrix حتى نتأكد إذا كانت القيم قد تغيرت.

البرنامج كاملاً

نتيجة التشغيل

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        int[][] matrix = new int[3][5];    // هنا قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
 
        matrix[0][0] = 6;       // هنا قمنا بتغيير قيمة العنصر الموجود في السطر الأول و العامود الأول
        matrix[1][2] = -3;      // هنا قمنا بتغيير قيمة العنصر الموجود في السطر الثاني و العامود الثالث
        matrix[2][4] = 100;     // هنا قمنا بتغيير قيمة العنصر الموجود في السطر الثالث و العامود الخامس
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الأول
        System.out.print("matrix[0][0]: " + matrix[0][0] + "\n" );
        System.out.print("matrix[0][1]: " + matrix[0][1] + "\n" );
        System.out.print("matrix[0][2]: " + matrix[0][2] + "\n" );
        System.out.print("matrix[0][3]: " + matrix[0][3] + "\n" );
        System.out.print("matrix[0][4]: " + matrix[0][4] + "\n\n" );
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثاني
        System.out.print("matrix[1][0]: " + matrix[1][0] + "\n" );
        System.out.print("matrix[1][1]: " + matrix[1][1] + "\n" );
        System.out.print("matrix[1][2]: " + matrix[1][2] + "\n" );
        System.out.print("matrix[1][3]: " + matrix[1][3] + "\n" );
        System.out.print("matrix[1][4]: " + matrix[1][4] + "\n\n" );
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثالث
        System.out.print("matrix[2][0]: " + matrix[2][0] + "\n" );
        System.out.print("matrix[2][1]: " + matrix[2][1] + "\n" );
        System.out.print("matrix[2][2]: " + matrix[2][2] + "\n" );
        System.out.print("matrix[2][3]: " + matrix[2][3] + "\n" );
        System.out.print("matrix[2][4]: " + matrix[2][4] + "\n\n" );
 
    }

}

بناء المصفوفة ذات البعدين

إذا ركزت جيداً في الـ matrix التالية ستجد أنها تساوي ثلاثة مصفوفات ذات بعد واحد ( أي مثل ثلاثة vectors ) فوق بعض.

نستنتج أن كل سطر في المصفوفة عبارة عن مصفوفة ذات بعد واحد.
إذاً تعريف مصفوفة ذات بعدين يعني تعريف مصفوفة أساسية و كل عنصر في هذه المصفوفة يمثل مصفوفة ذات بعد واحد.
ستتضح لك هذه الفكرة أكثر عندما تتعلم طريقة تعريف مصفوفة ذات بعدين مع إعطائها قيم أولية مباشرةً عند إنشائها.

طريقة تعريف مصفوفة ذات بعدين و إعطائها القيم مباشرةً عند إنشائها

إذا أردنا إدخال القيم مباشرةً عند تعريف المصفوفة نضع الرمزين { } بعد رمز المساواة =, و هذا يعني أننا نريد إعطاء قيم للمصفوفة و تحديد عدد عناصرها مباشرةً عند إنشائها.
و بما أن كل سطر عبارة عن مصفوفة ذات بعد واحد, نضع كل سطر بين { }, مع الإشارة إلى أنه يجب وضع فاصلة بين كل مصفوفتين ( سطرين ) و بين كل قيمتين ( عنصرين ). و لا تنسى وضع الفاصلة المنقوطة في الأخير.

ملاحظة: سنعيد نفس البرنامج السابق بطريقة أخرى.
الآن, لنفترض أننا نريد تعريف مصفوفة إسمها matrix مع إعطائها 15 قيمة أولية مباشرةً عند إنشائها.

طريقة تعريف المصفوفة مع إعطاء عناصرها قيم أولية

المثال التالي يعلمك طرق تعريف مصفوفة ذات بعدين نوعها int مع إعطائها قيم أولية مباشرةً عند إنشائها.

مثال

الطريقة الأولى: و التي يستخدمها معظم المبرمجون لأنها أسهل في القراءة و التعديل.

int[][] matrix = {
                    {6, 0, 0, 0, 0},
                    {0, 0, -3, 0, 0},
                    {0, 0, 0, 0, 100}
                 };

الطريقة الثانية: هي أن تكتب كل شيء في سطر واحد.

int[][] matrix = { {6, 0, 0, 0, 0}, {0, 0, -3, 0, 0}, {0, 0, 0, 0, 100} };

هنا لأننا وضعنا فيها 15 قيمة مباشرةً عند إنشائها, أصبحت المصفوفة أيضاً تتألف من 15 عنصر تماماً كما عرّفناها (أي نفس عدد الأسطر و الأعمدة) و يمكننا تغير القيم إذا أردنا لاحقاً, لكننا لا نستطيع تغير عدد العناصر.

شكل المصفوفة في الذاكرة

طريقة إعطاء قيم لعناصر المصفوفة

المثال التالي يوضح طريقة إعطاء قيمة لعناصر المصفوفة matrix.

مثال

matrix[0][0] = 10;
matrix[0][1] = 20;
matrix[0][2] = 30;
matrix[0][3] = 40;
matrix[0][4] = 50;

matrix[1][0] = 60;
matrix[1][1] = 70;
matrix[1][2] = 80;
matrix[1][3] = 90;
matrix[1][4] = 100;

matrix[2][0] = 110;
matrix[2][1] = 120;
matrix[2][2] = 130;
matrix[2][3] = 140;
matrix[2][4] = 150;

هنا قمنا بتغيير قيمة كل عنصر في المصفوفة.

شكل المصفوفة في الذاكرة

طريقة عرض القيم المخزنة في عناصر المصفوفة

المثال التالي يوضح طريقة عرض قيم عناصر المصفوفة matrix.

مثال

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الأول
System.out.print("matrix[0][0]: " + matrix[0][0] + "\n" );
System.out.print("matrix[0][1]: " + matrix[0][1] + "\n" );
System.out.print("matrix[0][2]: " + matrix[0][2] + "\n" );
System.out.print("matrix[0][3]: " + matrix[0][3] + "\n" );
System.out.print("matrix[0][4]: " + matrix[0][4] + "\n\n" );

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثاني
System.out.print("matrix[1][0]: " + matrix[1][0] + "\n" );
System.out.print("matrix[1][1]: " + matrix[1][1] + "\n" );
System.out.print("matrix[1][2]: " + matrix[1][2] + "\n" );
System.out.print("matrix[1][3]: " + matrix[1][3] + "\n" );
System.out.print("matrix[1][4]: " + matrix[1][4] + "\n\n" );

// هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثالث
System.out.print("matrix[2][0]: " + matrix[2][0] + "\n" );
System.out.print("matrix[2][1]: " + matrix[2][1] + "\n" );
System.out.print("matrix[2][2]: " + matrix[2][2] + "\n" );
System.out.print("matrix[2][3]: " + matrix[2][3] + "\n" );
System.out.print("matrix[2][4]: " + matrix[2][4] + "\n\n" );

هنا قمنا بعرض قيم جميع العناصر الموجودة في المصفوفة matrix حتى نتأكد إذا كانت القيم قد تغيرت.

البرنامج كاملاً

نتيجة التشغيل

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // هنا قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
        int[][] matrix = {
                            {6, 0, 0, 0, 0},
                            {0, 0, -3, 0, 0},
                            {0, 0, 0, 0, 100}
                         };
 
        // هنا قمنا بتغير قيم العناصر الموجودة في السطر الأول
        matrix[0][0] = 10;
        matrix[0][1] = 20;
        matrix[0][2] = 30;
        matrix[0][3] = 40;
        matrix[0][4] = 50;
 
        // هنا قمنا بتغير قيم العناصر الموجودة في السطر الثاني
        matrix[1][0] = 60;
        matrix[1][1] = 70;
        matrix[1][2] = 80;
        matrix[1][3] = 90;
        matrix[1][4] = 100;
 
        // هنا قمنا بتغير قيم العناصر الموجودة في السطر الثالث
        matrix[2][0] = 110;
        matrix[2][1] = 120;
        matrix[2][2] = 130;
        matrix[2][3] = 140;
        matrix[2][4] = 150;
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الأول
        System.out.print("matrix[0][0]: " + matrix[0][0] + "\n" );
        System.out.print("matrix[0][1]: " + matrix[0][1] + "\n" );
        System.out.print("matrix[0][2]: " + matrix[0][2] + "\n" );
        System.out.print("matrix[0][3]: " + matrix[0][3] + "\n" );
        System.out.print("matrix[0][4]: " + matrix[0][4] + "\n\n" );
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثاني
        System.out.print("matrix[1][0]: " + matrix[1][0] + "\n" );
        System.out.print("matrix[1][1]: " + matrix[1][1] + "\n" );
        System.out.print("matrix[1][2]: " + matrix[1][2] + "\n" );
        System.out.print("matrix[1][3]: " + matrix[1][3] + "\n" );
        System.out.print("matrix[1][4]: " + matrix[1][4] + "\n\n" );
 
        // هنا قمنا بعرض جميع قيم العناصر الموجودة في السطر الثالث
        System.out.print("matrix[2][0]: " + matrix[2][0] + "\n" );
        System.out.print("matrix[2][1]: " + matrix[2][1] + "\n" );
        System.out.print("matrix[2][2]: " + matrix[2][2] + "\n" );
        System.out.print("matrix[2][3]: " + matrix[2][3] + "\n" );
        System.out.print("matrix[2][4]: " + matrix[2][4] + "\n\n" );
 
    }

}

الوصول إلى عناصر المصفوفة ذات البعدين بواسطة حلقات متداخلة

للوصول إلى جميع عناصر المصفوفة matrix بسرعة و بكود أقل مهما كان حجم المصفوفة نستخدم الحلقات المتداخلة.
فمثلاً تستطيع إستخدام حلقتين for لإعطاء قيم لجميع العناصر الموجودة في المصفوفة أو لعرض جميع قيمها دفعة واحدة.

مثال

في المثال التالي, قمنا بتعريف مصفوفة إسمها matrix تتألف من 3 أسطر و 5 أعمدة, أي من 15 عنصر.
بعدها جعلنا المستخدم يدخل قيمة لكل عنصر من عناصرها.
في الأخير قمنا بعرض جميع القيم التي أدخلها المستخدم في المصفوفة.

نتيجة التشغيل

إذا قمت بإدخال القيم ( 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150 ) عند تشغيل البرنامج, ستكون نتيجة التشغيل كالتالي.

كود الجافا

import java.util.Scanner;
 
public class Matrix {
 
    public static void main (String[] args) {
 
        Scanner input = new Scanner(System.in);
 
        // هنا قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
        int[][] matrix = new int[3][5];
 
        // لإعطاء قيمة لكل عنصر في المصفوفة j و i هنا قمنا بتعريف الحلقتين
        for(int i=0; i<3; i++)
        {
            for(int j=0; j<5; j++)
            {
                System.out.print("Enter matrix["+i+"]["+j+"]: ");
                matrix[i][j] = input.nextInt();
            }
            System.out.print("\n");
        }
 
        System.out.print("matrix values \n");
 
        // لعرض قيم جميع العناصر الموجودة في المصفوفة j و i هنا قمنا بتعريف الحلقتين
        for(int i=0; i<3; i++)
        {
            for(int j=0; j<5; j++)
            {
                System.out.print(matrix[i][j] + "\t");
            }
            System.out.print("\n");
        }
 
        System.out.print("\n");
 
    }
 
}

شرح الكود

int[][] matrix = new int[3][5];

هنا قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة.

for(int i=0; i<3; i++)
{
    for(int j=0; j<5; j++)
    {
        System.out.print("Enter matrix["+i+"]["+j+"]: ");
        matrix[i][j] = input.nextInt();
    }
    System.out.print("\n");
}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيمة لجميع العناصر الموجودة, سيتم النزول على سطر جديد بسبب الرمز \n.
إذاً الحلقتين i و j يعملان كالتالي:

عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 0 سيطلب من المستخدم إدخال قيمة للعنصر matrix[0][0], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 1 سيطلب من المستخدم إدخال قيمة للعنصر matrix[0][1], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 2 سيطلب من المستخدم إدخال قيمة للعنصر matrix[0][2], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 3 سيطلب من المستخدم إدخال قيمة للعنصر matrix[0][3], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 4 سيطلب من المستخدم إدخال قيمة للعنصر matrix[0][4], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 0 سيطلب من المستخدم إدخال قيمة للعنصر matrix[1][0], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 1 سيطلب من المستخدم إدخال قيمة للعنصر matrix[1][1], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 2 سيطلب من المستخدم إدخال قيمة للعنصر matrix[1][2], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 3 سيطلب من المستخدم إدخال قيمة للعنصر matrix[1][3], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 4 سيطلب من المستخدم إدخال قيمة للعنصر matrix[1][4], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 0 سيطلب من المستخدم إدخال قيمة للعنصر matrix[3][0], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 1 سيطلب من المستخدم إدخال قيمة للعنصر matrix[3][1], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 2 سيطلب من المستخدم إدخال قيمة للعنصر matrix[3][2], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 3 سيطلب من المستخدم إدخال قيمة للعنصر matrix[3][3], بعدها سيتم تخزين القيمة التي أدخلها فيه.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 4 سيطلب من المستخدم إدخال قيمة للعنصر matrix[3][4], بعدها سيتم تخزين القيمة التي أدخلها فيه.

for(int i=0; i<3; i++)
{
    for(int j=0; j<5; j++)
    {
        System.out.print(matrix[i][j] + "\t");
    }
    System.out.print("\n");
}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.
إذاً الحلقتين i و j يعملان كالتالي:

عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 0, سيطبع له أن قيمة العنصر matrix[0][0] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 1, سيطبع له أن قيمة العنصر matrix[0][1] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 2, سيطبع له أن قيمة العنصر matrix[0][2] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 3, سيطبع له أن قيمة العنصر matrix[0][3] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 4, سيطبع له أن قيمة العنصر matrix[0][4] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 0, سيطبع له أن قيمة العنصر matrix[1][0] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 1, سيطبع له أن قيمة العنصر matrix[1][1] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 2, سيطبع له أن قيمة العنصر matrix[1][2] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 3, سيطبع له أن قيمة العنصر matrix[1][3] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 4, سيطبع له أن قيمة العنصر matrix[1][4] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 0, سيطبع له أن قيمة العنصر matrix[2][0] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 1, سيطبع له أن قيمة العنصر matrix[2][1] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 2, سيطبع له أن قيمة العنصر matrix[2][2] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 3, سيطبع له أن قيمة العنصر matrix[2][3] تساوي القيمة التي أدخلها له سابقاً.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 4, سيطبع له أن قيمة العنصر matrix[2][4] تساوي القيمة التي أدخلها له سابقاً.

شكل المصفوفة في الذاكرة قبل و بعد

في البداية تم إنشاءها في الذاكرة كما في الصورة التالية.

بعد أن قمنا بإدخال القيم فيها, أصبح شكلها في الذاكرة كما في الصورة التالية.

الآن, أنت فهمت جيداً كيف يمكنك تعريف مصفوفة ذات بعدين و الوصول إلى عناصرها و تغيير و عرض قيمها.
في الدرس التالية ستتعرف على الخاصية length التي تستخدم لمعرفة عدد عناصر المصفوفة بالإضافة إلى عدة طرق يمكن إتباعها لتخزين, مقارنة, و عرض قيم عناصر المصفوفة.

إستخدام الخاصية `length` مع المصفوفات ذات البعدين

في الدروس السابقة كنا نضع إسم المصفوفة, ثم نقطة, ثم الخاصية length لنعرف عدد عناصر المصفوفة ذات البعد الواحد.

مثال

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // قمنا بتعريف مصفوفة تتألف من 3 عناصر
        int vector[] = { 1, 2, 3 };
 
        System.out.print("the number of elements is : " + vector.length + "\n" );
 
    }
 
}

نتيجة التشغيل

الآن سنحاول استخدام الخاصية length مع مصفوفة ذات بعدين لمعرفة عدد عناصرها بنفس الطريقة.

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
        int[][] matrix = {
                            {1, 2, 3, 4, 5},
                            {6, 7, 8, 9, 10},
                            {11, 12, 13, 14, 15}
                         };
 
        System.out.print("the number of elements is : " + matrix.length + "\n" );
 
    }

}

نتيجة التشغيل

حتماً أنت الآن تتسائل لماذا طبع لنا أن عدد عناصرها يساوي 3 و ليس 15.

السبب هو أن المصفوفة matrix تتألف من 3 عناصر أساسية (و هي 3 مصفوفات)
و كل عنصر منها (أي كل مصفوفة فيها) تتألف من 5 عناصر (خانات) كما في الصورة التالية.

إذاً عندما كتبت matrix.length قام بإعطائك عدد المصفوفات ذات البعد الواحد الموجودة بداخل المصفوفة matrix و الذي يساوي 3.

الطريقة الصحيحة لإستخدام الخاصية `length` مع المصفوفة ذات البعدين لمعرفة عدد جميع الأشياء الموجودة فيها

مثال

الآن سنقوم بتعريف نفس المصفوفة السابقة و سنطبع المعلومات التالية:

عدد المصفوفات الداخلية (أي عدد الأسطر) الموجودة في المصفوفة matrix.
عدد العناصر الموجودة في كل سطر (أي في كل مصفوفة داخلية) في المصفوفة matrix.

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
        int[][] matrix = {
                            {1, 2, 3, 4, 5},
                            {6, 7, 8, 9, 10},
                            {11, 12, 13, 14, 15}
                         };
 
        // matrix هنا طبعنا عدد عناصر المصفوفات الموجودة في المصفوفة
        System.out.print("the number of elements is : " + matrix.length + "\n\n" );
 
 
        // matrix[0] هنا طبعنا عدد العناصر الموجودة في المصفوفة
        System.out.print("the number of elements of matrix[0] is : " + matrix[0].length + "\n" );
 
        // matrix[1] هنا طبعنا عدد العناصر الموجودة في المصفوفة
        System.out.print("the number of elements of matrix[1] is : " + matrix[1].length + "\n" );
 
        // matrix[2] هنا طبعنا عدد العناصر الموجودة في المصفوفة
        System.out.print("the number of elements of matrix[2] is : " + matrix[2].length + "\n" );
 
    }
 
}

نتيجة التشغيل

شرح الكود

matrix.length ترجع عدد العناصر الأساسية الموجودة في المصفوفة matrix, أي عدد المصفوفات الموجودة فيها.
matrix[0].length ترجع لنا عدد عناصر المصفوفة الأولى في المصفوفة matrix.
matrix[1].length ترجع لنا عدد عناصر المصفوفة الثانية في المصفوفة matrix.
matrix[2].length ترجع لنا عدد عناصر المصفوفة الثالثة في المصفوفة matrix.

طريقة معرفة عدد عناصر المصفوفة ذات البعدين

لمعرفة عدد عناصر المصفوفة هناك ثلاث طرق يمكنك إستخدام إحداها و ذلك حسب حاجتك.

الطريقة الأولى

إذا كان شكل المصفوفة يشبه شكل المربع أي عدد الأعمدة يساوي عدد الأسطر, كما في الصورة التالية:

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // قمنا بتعريف مصفوفة تتألف من 3 أسطر و 3 أعمدة
        int[][] matrix = {
                            {1, 2, 3},
                            {4, 5, 6},
                            {7, 8, 9}
                         };
 
        // هنا قلنا أن عدد عناصر المصفوفة يساوي عدد الأسطر ضرب عدد الأعمدة في أي سطر
        System.out.print("the number of elements is : " + (matrix.length * matrix[0].length) + "\n" );
 
        // هنا قلنا أن عدد الأعمدة في أي سطر ضرب عدد الأعمدة في أي سطر
        System.out.print("the number of elements is : " + (matrix[0].length * matrix[0].length) + "\n" );
 
        // هنا قلنا أن عدد العناصر يساوي عدد الأسطر ضرب عدد الأسطر
        System.out.print("the number of elements is : " + (matrix.length * matrix.length) + "\n" );
 
    }

}

نتيجة التشغيل

الطريقة الثانية

إذا كان شكل المصفوفة يشبه شكل المستطيل أي عدد الأعمدة لا يساوي عدد الأسطر, كما في الصورة التالية.

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // هنا قمنا بتعريف مصفوفة تتألف من 3 أسطر و 5 أعمدة
        int[][] matrix = {
                            {1, 2, 3, 4, 5},
                            {6, 7, 8, 9, 10},
                            {11, 12, 13, 14, 15}
                         };
 
        // هنا قلنا أن عدد العناصر يساوي عدد الأسطر ضرب عدد الأعمدة في أي سطر
        System.out.print("the number of elements is : " + (matrix.length * matrix[0].length) + "\n" );
 
    }
 
}

نتيجة التشغيل

الطريقة الثالثة

معرفة عدد العناصر التي تحتوي على قيم مهما كان شكل المصفوفة, كما في الصورة التالية.

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        int elements_found = 0;
 
        int[][] matrix = {
                            {1, 2, 3},
                            {4, 5, 6, 7, 8},
                            {9, 10, 11, 12},
                            {13, 14}
                         };
 
        for (int i=0; i<matrix.length; i++)
        {
            elements_found = elements_found + matrix[i].length;
        }
 
        System.out.print("the number of elements is : " + elements_found + "\n" );
 
    }
 
}

نتيجة التشغيل

شرح الكود

الهدف من هذا البرنامج معرفة عدد عناصر المصفوفة مهما كان شكلها.

		int elements_found = 0;
		
		int[][] matrix = {
							{1, 2, 3},
							{4, 5, 6, 7, 8},
							{9, 10, 11, 12},
							{13, 14}
						};

قمنا بتجهيز المتغير elements_found لتخزين عدد جميع عناصر المصفوفة لاحقاً.
و أنشأنا المصفوفة ذات البعدين matrix و التي ليس لها شكل محدد مثل المربع أو المستطيل.

		for (int i=0; i<matrix.length; i++)
		{
			elements_found = elements_found + matrix[i].length;
		}

هنا قمنا بإنشاء تبدأ من index أول سطر إلى آخر سطر موجود في المصفوفة matrix.
في كل دورة من دورات الحلقة i سيتم إضافة عدد العناصر الموجودة في كل سطر (أي في كل مصفوفة ذات بعد واحد فيها) على قيمة المتغير elements_found.

		System.out.print("the number of elements is : " + elements_found + "\n" );

في الأخير عرضنا قيمة المتغير elements_found لنتأكد من الجواب.

ملاحظة

الطريقة الثالثة هي أهم طريقة لأنها تجعلك تعرف عدد عناصر المصفوفة ذات البعدين مهما كان شكلها, لكننا لا ننصحك باستخدامها إلا إذا كنت ستتعامل مع مصفوفة ذات بعدين لا تشبه شكل المربع أو المستطيل لأنها تتطلب كود أكبر.

المبادئ التي عليك اتباعها أو تقليدها مع المصفوفات ذات البعدين

تذكر المبادئ التالية في كل مرة تتعامل فيها مع مصفوفة ذات بعدين:

إستخدم حلقتين for متداخلتين في حال أردت الوصول لجميع عناصر المصفوفة.
الحلقة التي تجعلك تنتقل من سطر لآخر قم بتسمية العداد فيها i و إجعلها تبدأ من 0 إلى عدد الأسطر فيها ناقص 1.
الحلقة التي تجعلك تنتقل من عامود لآخر قم بتسمية العداد فيها j و إجعلها تبدأ من 0 إلى عدد الأعمدة فيها ناقص 1.
إستخدم الرمز \t في حال كنت تريد عرض عناصر المصفوفة كجدول لأنه يضع مسافات فارغة بشكل تلقائي بين كل قيمتين على نفس السطر.
إستخدم الحلقة while أو do while في حال لم تكن تريد الوصول لجميع عناصر المصفوفة.
إستخدم الحلقة do while في حال كنت تريد جعل المستخدم يدخل قيمة تستوفي شرط معين.

ستفهم كل هذه المبادئ من التمارين.

طريقة الوصول إلى قيم عناصر المصفوفة سطراً - سطراً أو عاموداً - عاموداً

في حال أردت الوصول إلى عناصر المصفوفة سطراً سطراً, عليك جعل الحلقة الخارجية تنتقل من سطر لآخر و الحلقة الداخلية تنتقل من عامود لآخر.
في حال أردت الوصول إلى عناصر المصفوفة عاموداً عاموداً, عليك جعل الحلقة الخارجية تنتقل من عامود لآخر و الحلقة الداخلية تنتقل من سطر لآخر.

المثال التالي يوضح كيف تعرّف الحلقتين i و j قي حال كنت تريد التنقل في المصفوفة سطراً - سطراً أو عاموداً - عاموداً.

كود الجافا

public class Matrix {
 
    public static void main (String[] args) {
 
        // قمنا بتعريف مصفوفة تتألف من 3 أسطر و 3 أعمدة
        int[][] matrix = {
                            {1, 2, 3},
                            {4, 5, 6},
                            {7, 8, 9}
                         };
 
 
        // هنا قمنا بعرض القيم الموجودة في كل سطر في المصفوفة
        for (int i=0; i<3; i++)
        {
            System.out.print("Row ["+i+"] values: ");
            for (int j=0; j<3; j++)
            {
                System.out.print( matrix[i][j] + " " );
            }
            System.out.print( "\n" );
        }
 
 
        System.out.print( "\n" );
 
 
        // هنا قمنا بعرض القيم الموجودة في كل جدول في المصفوفة
        for (int j=0; j<3; j++)
        {
            System.out.print("Column ["+j+"] values: ");
            for (int i=0; i<3; i++)
            {
                System.out.print( matrix[i][j] + " " );
            }
            System.out.print( "\n" );
        }
 
 
    }
 
}

نتيجة التشغيل

تذكر

يمكنك دائماً كتابة الكود بأكثر من طريقة و الحصول على نفس النتيجة.
بمعنى أخر, يوجد طريقة أخرى للتنقل بين عناصر المصفوفة غير التلاعب بأمكان الحلقات i و j.
الطريقة الأخرى ستتعلمها من التمارين الموضوعة ضمن هذا الدرس.

تمارين شاملة حول المصفوفات ذات البعدين

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الأول

المطلوب

هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يطلب من المستخدم إعطائه عددين, العدد الأول يمثل عدد أسطر مصفوفة ذات بعدين إسمها matrix و العدد الثاني يمثل عدد أعمدتها.
خزن العدد الأول في متغير إسمه a و العدد الثاني في متغير إسمه b.
إنتبه: يجب أن يدخل المستخدم عددين أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.
ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة matrix.
ثم يعرض له جميع قيم عناصر المصفوفة matrix.

النتيجة المطلوبة

لنفترض أن المستخدم أراد عدد الأسطر يساوي 3 و الأعمدة 4, و أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9, 10, 11, 12 ) عند التشغيل.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int a;
        int b;
        int[][] matrix;

        do
        {
		System.out.print("Enter the number of rows: ");
		a = input.nextInt();
        }
        while ( a  <= 0 );

        do
        {
		System.out.print("Enter the number of columns: ");
		b = input.nextInt();
        }
        while ( b  <= 0 );

        matrix = new int[a][b];

        System.out.print("\n");

        for (int i=0; i<a; i++)
        {
		for (int j=0; j<b; j++)
		{
		System.out.print("Enter matrix[" +i+ "][" +j+ "]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<a; i++)
        {
		for (int j=0; j<b; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        System.out.print("\n");

		}

		}

شرح الكود

			int a;
			int b;
			int[][] matrix;

هنا قمنا بتجهيز المتغير a و الذي سنستخدمه لتخزين عدد أسطر المصفوفة, و هو أول شيء سيطلب من المستخدم إدخاله.
و المتغير b و الذي سنستخدمه لتخزين عدد أعمدة المصفوفة, و هو ثاني شيء سيطلب من المستخدم إدخاله.
و المصفوفة matrix و التي لم يتم تحديد عدد عناصرها.

			do
			{
			System.out.print("Enter the number of rows: ");
			a = input.nextInt();
			}
			while ( a  <= 0 );

هنا سيطلب من المستخدم إدخال عدد أسطر المصفوفة, بعدها سيتم تخزينه في المتغير a.
بعدها سيتم فحص قيمة المتغير a. إذا كانت أصغر أو تساوي 0, سيطلب من المستخدم إدخال العدد من جديد.
إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0 كعدد أسطر المصفوفة.

			do
			{
			System.out.print("Enter the number of columns: ");
			b = input.nextInt();
			}
			while ( b  <= 0 );

هنا سيطلب من المستخدم إدخال عدد أعمدة المصفوفة, بعدها سيتم تخزينه في المتغير b.
بعدها سيتم فحص قيمة المتغير b. إذا كانت أصغر أو تساوي 0, سيطلب من المستخدم إدخال العدد من جديد.
إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0 كعدد أعمدة المصفوفة.

			matrix = new int[a][b];

هنا سيتم تحديد قيمة المتغيرين a و b اللتين أدخلهما المستخدم كعدد أسطر و أعمدة المصفوفة matrix.

			for (int i=0; i<a; i++)
			{
			for (int j=0; j<b; j++)
			{
			System.out.print("Enter matrix[" +i+ "][" +j+ "]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<a; i++)
			{
			for (int j=0; j<b; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الثاني

المطلوب

هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 3 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم ناتج جمع جميع قيم عناصرها.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9 ) عند التشغيل.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][3];
        int S = 0;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<3; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<3; j++)
		{
		S = S + matrix[i][j];
		}
        }

        System.out.print("The sum of all elements is: " +S+ "\n");

		}

		}

شرح الكود

			int[][] matrix = new int[3][3];
			int S = 0;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 3 أعمدة.
و المتغير S الذي سنستخدمه لاحقاً لتخزين ناتج جمع قيم جميع العناصر الموجودة في المصفوفة لذلك أعطيناه القيمة 0 كقيمة أولية.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<3; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<3; j++)
			{
			S = S + matrix[i][j];
			}
			}

هنا قمنا بإنشاء الحلقتين i و j للوصول إلى جميع قيم عناصر المصفوفة.
كل عنصر يتم الوصول إليه, يتم إضافة قيمته على قيمة المتغير S.
إذاً عند توقف الحلقتين i و j سيكون المتغير S يحتوي على ناتج جميع قيم عناصر المصفوفة.

			System.out.print("The sum of all elements is: " +S+ "\n");

هنا قمنا بعرض قيمة المتغير S كناتج جمع جميع قيم العناصر الموجودة في المصفوفة.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الثالث

المطلوب

هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 3 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم ناتج جمع قيم العناصر الموجودة في كل سطر فيها.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][3];
        int S;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<3; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<3; i++)
        {
		S = 0;

		for (int j=0; j<3; j++)
		{
		S = S + matrix[i][j];
		}

		System.out.print("The sum of elements in row "+i+" is : " +S+ "\n");
        }

		}

		}

شرح الكود

			int[][] matrix = new int[3][3];
			int S;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 3 أعمدة.
و المتغير S الذي سنستخدمه لاحقاً لتخزين ناتج جمع القيم الموجودة في كل سطر.
ملاحظة: لم نضع القيمة 0 كقيمة أولية للمتغير S الآن لأننا قبل حساب ناتج قيمة العناصر الموجودة في كل سطر سنضع فيه القيمة 0 كقيمة أولية.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<3; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<3; i++)
			{
			S = 0;

			for (int j=0; j<3; j++)
			{
			S = S + matrix[i][j];
			}

			System.out.print("The sum of elements in row "+i+" is : " +S+ "\n");
			}

هنا قمنا بإنشاء الحلقتين i و j للوصول إلى جميع قيم عناصر المصفوفة.
في كل دورة من دورات الحلقة i سيتم حساب ناتج جمع القيم الموجودة في نفس السطر, ثم طباعة الناتج كالتالي:

سيتم تصفير قيمة المتغير S قبل البدء بحساب ناتج جمع قيم العناصر الموجودة في نفس السطر حتى لا يتم إضافة ناتج جمع القيم الموجودة في السطر القديم على ناتج القيم الموجودة في السطر الحالي في كل مرة يتم فيها الإنتقال إلى سطر جديد.
بعدها سيتم إنشاء الحلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم إضافة قيمة عنصر من العناصر الموجودة في نفس السطر على قيمة المتغير S.
عند توقف الحلقة j سيكون ناتج جمع جميع العناصر الموجودة في نفس السطر موجود في المتغير S.
لذلك سيتم عرض قيمة المتغير S كناتج جمع جميع العناصر الموجودة في نفس السطر.

لاحظ كيف سيتم إضافة قيم العناصر الموجودة في نفس السطر على قيمة المتغير S :

عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[0][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[0][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[0][2] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في السطر الأول.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[1][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[1][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[1][2] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في السطر الثاني.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[2][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[2][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[2][2] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في السطر الثالث.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الرابع

المطلوب

هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 3 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم ناتج جمع قيم العناصر الموجودة في كل عامود فيها.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][3];
        int S;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<3; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int j=0; j<3; j++)
        {
		S = 0;

		for (int i=0; i<3; i++)
		{
		S = S + matrix[i][j];
		}

		System.out.print("The sum of elements in column "+j+" is: " +S+ "\n");
        }

		}

		}

شرح الكود

			int[][] matrix = new int[3][3];
			int S;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 3 أعمدة.
و المتغير S الذي سنستخدمه لاحقاً لتخزين ناتج جمع القيم الموجودة في كل عامود.
ملاحظة: لم نضع القيمة 0 كقيمة أولية للمتغير S الآن لأننا قبل حساب ناتج قيمة العناصر الموجودة في كل عامود سنضع فيه القيمة 0 كقيمة أولية.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<3; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int j=0; j<3; j++)
			{
			S = 0;

			for (int i=0; i<3; i++)
			{
			S = S + matrix[i][j];
			}

			System.out.print("The sum of elements in column "+j+" is: " +S+ "\n");
			}

هنا قمنا بإنشاء الحلقتين j و i للوصول إلى جميع قيم عناصر المصفوفة.
ملاحظة: الإختلاف الوحيد في هذا التمرين عن التمرين السابق, هو أننا جعلنا الحلقة j الحلقة الخارجية و الحلقة i الحلقة الداخلية.
في كل دورة من دورات الحلقة j سيتم حساب ناتج جمع القيم الموجودة في نفس العامود, ثم طباعة الناتج كالتالي:

سيتم تصفير قيمة المتغير S قبل البدء بحساب ناتج جمع قيم العناصر الموجودة في نفس العامود حتى لا يتم إضافة ناتج جمع القيم الموجودة في العامود القديم على ناتج القيم الموجودة في العامود الحالي في كل مرة يتم فيها الإنتقال إلى عامود جديد.
بعدها سيتم إنشاء الحلقة i للمرور على جميع العناصر الموجودة في نفس العامود.
في كل دورة من دورات الحلقة i سيتم إضافة قيمة عنصر من العناصر الموجودة في نفس العامود على قيمة المتغير S.
عند توقف الحلقة i سيكون ناتج جمع جميع العناصر الموجودة في نفس العامود موجود في المتغير S.
لذلك سيتم عرض قيمة المتغير S كناتج جمع جميع العناصر الموجودة في نفس العامود.

لاحظ كيف سيتم إضافة قيم العناصر الموجودة في نفس العامود على قيمة المتغير S :

عندما تكون قيمة العداد j تساوي 0 و قيمة العداد i تساوي 0, سيتم إضافة قيمة العنصر matrix[0][0] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 0 و قيمة العداد i تساوي 1, سيتم إضافة قيمة العنصر matrix[1][0] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 0 و قيمة العداد i تساوي 2, سيتم إضافة قيمة العنصر matrix[2][0] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الأول.
عندما تكون قيمة العداد j تساوي 1 و قيمة العداد i تساوي 0, سيتم إضافة قيمة العنصر matrix[0][1] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 1 و قيمة العداد i تساوي 1, سيتم إضافة قيمة العنصر matrix[1][1] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 1 و قيمة العداد i تساوي 2, سيتم إضافة قيمة العنصر matrix[2][1] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الثاني.
عندما تكون قيمة العداد j تساوي 2 و قيمة العداد i تساوي 0, سيتم إضافة قيمة العنصر matrix[0][2] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 2 و قيمة العداد i تساوي 1, سيتم إضافة قيمة العنصر matrix[1][2] على قيمة المتغير S.
عندما تكون قيمة العداد j تساوي 2 و قيمة العداد i تساوي 2, سيتم إضافة قيمة العنصر matrix[2][2] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الثالث.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الخامس

المطلوب

هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 3 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض له ناتج جمع قيم عناصر كل عامود فيها.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][3];
        int S;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<3; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<3; i++)
        {
		S = 0;

		for (int j=0; j<3; j++)
		{
		S = S + matrix[j][i];
		}

		System.out.print("the sum of elements in column ["+i+"] is : " +S+ "\n");
        }

        System.out.print("\n");

		}

		}

شرح الكود

			int[][] matrix = new int[3][3];
			int S;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 3 أعمدة.
و المتغير S الذي سنستخدمه لاحقاً لتخزين ناتج جمع القيم الموجودة في كل عامود.
ملاحظة: لم نضع القيمة 0 كقيمة أولية للمتغير S الآن لأننا قبل حساب ناتج قيمة العناصر الموجودة في كل عامود سنضع فيه القيمة 0 كقيمة أولية.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<3; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<3; i++)
			{
			S = 0;

			for (int j=0; j<3; j++)
			{
			S = S + matrix[j][i];
			}

			System.out.print("the sum of elements in column ["+i+"] is : " +S+ "\n");
			}

هنا قمنا بإنشاء الحلقتين i و j للوصول إلى جميع قيم عناصر المصفوفة.
ملاحظة: الإختلاف الوحيد بين هذا التمرين و التمرين الثالث, هو أننا كتبنا matrix[j][i] بدلاً من matrix[i][j] مما جعلنا نمر على عناصر المصفوفة عاموداً عاموداً.
إذاً هنا سيتم الإنتقال من من سطر إلى آخر بواسطة الحلقة j و من عامود إلى آخر بواسطة الحلقة i.
في كل دورة من دورات الحلقة i سيتم حساب ناتج جمع القيم الموجودة في نفس العامود, ثم طباعة الناتج كالتالي:

سيتم تصفير قيمة المتغير S قبل البدء بحساب ناتج جمع قيم العناصر الموجودة في نفس العامود حتى لا يتم إضافة ناتج جمع القيم الموجودة في العامود القديم على ناتج القيم الموجودة في العامود الحالي في كل مرة يتم فيها الإنتقال إلى عامود جديد.
بعدها سيتم إنشاء الحلقة j للمرور على جميع العناصر الموجودة في نفس العامود.
في كل دورة من دورات الحلقة j سيتم إضافة قيمة عنصر من العناصر الموجودة في نفس العامود على قيمة المتغير S.
عند توقف الحلقة j سيكون ناتج جمع جميع العناصر الموجودة في نفس العامود موجود في المتغير S.
لذلك سيتم عرض قيمة المتغير S كناتج جمع جميع العناصر الموجودة في نفس العامود.

لاحظ كيف سيتم إضافة قيم العناصر الموجودة في نفس العامود على قيمة المتغير S :

عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[0][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[1][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[2][0] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الأول.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[0][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[1][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[2][1] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الثاني.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[0][2] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[1][2] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[2][2] على قيمة المتغير S.
إلى هنا يكون قد تم حساب ناتج جمع قيم العناصر الموجودة في العامود الثالث.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين السادس

المطلوب

هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 4 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويها المصفوفة.
ثم يقوم بتخزين جميع القيم الموجودة في المصفوفة matrix بداخل مصفوفة ذات بعد واحد, قم بتسميتها vector.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويهم المصفوفة vector على نفس السطر.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9, 10, 11, 12 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][4];
        int[] vector = new int[3*4];
        int k=0;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<4; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<4; j++)
		{
		vector[k] = matrix[i][j];
		k = k + 1 ;
		}
        }

        System.out.print("matrix contain these values: \n");

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<4; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        System.out.print("\nvector contain these values: \n");

        for (int i=0; i<vector.length; i++)
        {
		System.out.print(vector[i] + "\t");
        }

        System.out.print("\n\n");

		}

		}

شرح الكود

			int[][] matrix = new int[3][4];
			int[] vector = new int[3*4];
			int k=0;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 4 أعمدة ( 3 * 4 = 12 عنصر ).
و المصفوفة vector و حددنا أنها تتألف من 3 * 4 عناصر أيضاً, أي من 12 عنصر لأن عدد عناصرها يجب أن يساوي عدد عناصر المصفوفة matrix.
و المتغير k الذي أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه لاحقاً كعداد للوصول إلى عناصر المصفوفة vector.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<4; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<4; j++)
			{
			vector[k] = matrix[i][j];
			k = k + 1 ;
			}
			}

هنا أنشأنا الحلقتين i و j لتخزين قيمة كل عنصر موجود في المصفوفة matrix في المصفوفة vector.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
المتغير k إستخدمناه كعداد بالنسبة للمصفوفة vector فبواسطته إستطعنا الوصول إلى عناصر المصفوفة vector بشكل متوازي مع عناصر المصفوفة matrix.
إذاً في كل دورة من دورات الحلقة j سيتم وضع قيمة العنصر الحالي في المصفوفة matrix في العنصر التالي في المصفوفة vector لأن قيمة العداد k تزيد واحد في كل مرة.

			System.out.print("matrix contain these values: \n");

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<4; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			System.out.print("\nvector contain these values: \n");

			for (int i=0; i<vector.length; i++)
			{
			System.out.print(vector[i] + "\t");
			}

هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة vector إلى آخر عنصر موجود فيها بهدف عرض قيمة كل عنصر فيها.
في كل دورة من دورات الحلقة i سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين السابع

المطلوب

هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 4 أسطر و 4 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
إنتبه: نريد هذه المصفوفة أن تحتوي فقط على قيم أكبر أو تساوي صفر, مثل 10, 43, 3, 5, 8.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويها المصفوفة.
بعدها يقوم بجمع قيم جميع العناصر الموجودة على الـ Diagonal, فوق الـ Diagonal, و تحت الـ Diagonal.
في الأخير يعرض للمستخدم ناتج الجمع.

إرشادات

لتمييز قيم العناصر الموجودة على الـ Diagonal, فوق الـ Diagonal, و تحت الـ Diagonal برمجياً عليك إستغلال مكان وجود العنصر في المصفوفة.

ركز جيداً في الصورة و ستلاحظ أنه يمكنك تمييز مكان وجود العنصر بالنسبة للـ Diagonal كالتالي:

إذا كان index السطر يساوي index العامود فهذا يعني أن العنصر موجود على الـ Diagonal مثل العناصر التالية:
matrix[0][0] matrix[1][1] matrix[2][2] matrix[3][3].

إذا كان index السطر أكبر من index العامود فهذا يعني أن العنصر موجود تحت الـ Diagonal مثل العناصر التالية:
matrix[1][0] matrix[2][0] matrix[2][1] matrix[3][0] matrix[3][1] matrix[3][2].

إذا كان index السطر أصغر من index العامود فهذا يعني أن العنصر موجود فوق الـ Diagonal مثل العناصر التالية:
matrix[0][1] matrix[0][2] matrix[0][3] matrix[1][2] matrix[1][3] matrix[2][3].

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9, 10, 11, 12 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[4][4];
        int SOD = 0;                         // Diagonal سنخزن فيه قيم العناصر الموجودة على الـ SOD المتغير
        int SAD = 0;                         // Diagonal سنخزن فيه قيم العناصر الموجودة فوق الـ SAD المتغير
        int SUD = 0;                         // Diagonal سنخزن فيه قيم العناصر الموجودة تحت الـ SUD المتغير

        for (int i=0; i<4; i++)
        {
		for (int j=0; j<4; j++)
		{
		do
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		while( matrix[i][j] < 0 );
		}
		System.out.print("\n");
        }

        for (int i=0; i<4; i++)
        {
		for (int j=0; j<4; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        for (int i=0; i<4; i++)
        {
		for (int j=0; j<4; j++)
		{
		if ( i == j )
		{
		SOD = SOD + matrix[i][j];
		}
		else if ( i < j )
		{
		SAD = SAD + matrix[i][j];
		}
		else if ( i > j )
		{
		SUD = SUD + matrix[i][j];
		}
		}
        }

        System.out.print("\n");
        System.out.print("The sum of elements above the diagonal is: " +SAD+ "\n");
        System.out.print("The sum of elements on the diagonal is: " +SOD+ "\n");
        System.out.print("The sum of elements under the diagonal is: " +SUD+ "\n");

		}

		}

شرح الكود

			int[][] matrix = new int[4][4];
			int SOD = 0;
			int SAD = 0;
			int SUD = 0;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 4 أسطر و 4 أعمدة.
و المتغير SOD و أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه لتخزين ناتج جمع قيم العناصر الموجودة على الـ Diagonal.
و المتغير SAD و أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه لتخزين ناتج جمع قيم العناصر الموجودة فوق الـ Diagonal.
و المتغير SUD و أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه لتخزين ناتج جمع قيم العناصر الموجودة تحت الـ Diagonal.

			for (int i=0; i<4; i++)
			{
			for (int j=0; j<4; j++)
			{
			do
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			while( matrix[i][j] < 0 );
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر محدد في المصفوفة.
قبل تخزين القيمة التي أدخلها المستخدم في المصفوفة سيتم فحصها, إذا كانت أصغر من 0 سيطلب من المستخدم إدخال القيمة من جديد.
الآن, بعد أن يدخل المستخدم قيمة أكبر أو تساوي 0 سيتم تخزينها في المصفوفة, و سيطلب من المستخدم إدخال قيمة للعنصر التالي في المصفوفة.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<4; i++)
			{
			for (int j=0; j<4; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<4; i++)
			{
			for (int j=0; j<4; j++)
			{
			if ( i == j )
			{
			SOD = SOD + matrix[i][j];
			}
			else if ( i < j )
			{
			SAD = SAD + matrix[i][j];
			}
			else if ( i > j )
			{
			SUD = SUD + matrix[i][j];
			}
			}
			}

هنا أنشانا الحلقتين i و j للوصول إلى جميع عناصر المصفوفة.
كل عنصر يتم الوصول إليه سيتم مقارنة مكان وجوده مع قيمة العدادين i و j كالتالي:

إذا كانت قيمة العداد i تساوي قيمة العداد j, يعني ذلك أن العنصر موجود على الـ Diagonal. و بالتالي سيتم إضافة قيمته على قيمة المتغير SOD.
و إذا كانت قيمة العداد i أصغر من قيمة العداد j, يعني ذلك أن العنصر موجود فوق الـ Diagonal. و بالتالي سيتم إضافة قيمته على قيمة المتغير SAD.
و إذا كانت قيمة العداد i أكبر من قيمة العداد j, يعني ذلك أن العنصر موجود تحت الـ Diagonal. و بالتالي سيتم إضافة قيمته على قيمة المتغير SUD.

			System.out.print("\n");
			System.out.print("The sum of elements above the diagonal is: " +SAD+ "\n");
			System.out.print("The sum of elements on the diagonal is: " +SOD+ "\n");
			System.out.print("The sum of elements under the diagonal is: " +SUD+ "\n");

هنا قمنا بعرض ناتج جمع قيم العناصر الموجودة على الـ Diagonal, فوق الـ Diagonal, و تحت الـ Diagonal و التي تم تخزينه في المتغيرات SAD, و SOD, و SUD.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الثامن

المطلوب

هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 5 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويها المصفوفة.
بعدها يطلب من المستخدم إدخال أي عدد ليرى كم مرة هذا العدد موجود في المصفوفة, و يخزنه في المتغير x.
في الأخير يعرض للمستخدم ناتج عملية البحث, أي كم مرة وجد نفس قيمة المتغير x في المصفوفة matrix.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل قيم عشوائية في المصفوفة, ثم أدخل العدد 3 ليعرف كم مرة توجد القيمة 3 في المصفوفة.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][5];
        int x;
        int found = 0;

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<5; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<5; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        System.out.print("\nEnter any number: ");
        x = input.nextInt();

        for (int i=0; i<3; i++)
        {
		for (int j=0; j<5; j++)
		{
		if( matrix[i][j] == x )
		{
		found = found + 1;
		}
		}
        }

        System.out.print(x + " is exist " +found+ " times in the Matrix \n");

		}

		}

شرح الكود

			int[][] matrix = new int[3][5];
			int x;
			int found = 0;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 5 أعمدة.
و المتغير x سنستخدمه لتخزين القيمة (أي العدد) التي سيدخلها المستخدم لاحقاً للبحث عنها في المصفوفة.
و المتغير found و أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه لاحقاً لحساب كم مرة تم إيجاد القيمة التي بحث عنها المستخدم.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<5; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<5; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			System.out.print("\nEnter any number: ");
			x = input.nextInt();

هنا سيطلب من المستخدم إدخال أي عدد, و بعدها سيتم تخزينه في المتغير x.

			for (int i=0; i<3; i++)
			{
			for (int j=0; j<5; j++)
			{
			if( matrix[i][j] == x )
			{
			found = found + 1;
			}
			}
			}

هنا أنشانا الحلقتين i و j للمرور على جميع عناصر المصفوفة.
سيتم مقارنة قيمة كل عنصر في المصفوفة مع قيمة المتغير x أي ( مع العدد الذي أدخله المستخدم ).
في كل مرة تكون فيها قيمة العنصر تساوي قيمة المتغير x سيتم زيادة قيمة العداد found واحداً
إذاً المتغير found سيمثل عدد وجود قيمة المتغير x في المصفوفة matrix.

			System.out.print(x + " is exist " +found+ " times in the Matrix \n");

هنا قمنا بعرض قيمة المتغير found لعرض نتيجة البحث, أي لعرض كم مرة قد وجدت القيمة المتغير x في المصفوفة.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين التاسع

المطلوب

هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 5 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويها المصفوفة.
بعدها يطلب من المستخدم إدخال أي عدد ليرى إذا كان موجوداً في المصفوفة, و يخزنه في المتغير x.
إنتبه: يكفي أن يعرف المستخدم إذا كان العدد الذي يبحث عنه موجوداً مرة واحدة في المصفوفة.
في الأخير يعرض للمستخدم ناتج عملية البحث, أي إذا وجد نفس قيمة المتغير x في المصفوفة matrix أم لا.

ملاحظة: قم بتعريف العدادين i و j مرة واحدة في بداية البرنامج.

إرشادات

هنا يجب إستخدام حلقتين while أو do while أثناء عملية البحث في المصفوفة لأنك لست بحاجة إلى المرور على جميع عناصرها.
ملاحظة: الأسلوب الذي ستتعلمه في هذا التمرين مهم جداً و يستخدم كثيراً.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل قيم عشوائية في المصفوفة, ثم أدخل العدد 8 ليعرف إذا كانت القيمة 8 موجودة في المصفوفة أم لا.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][5];
        int x;
        boolean found = false;

        int i;
        int j;

        for (i=0; i<3; i++)
        {
		for (j=0; j<5; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        for (i=0; i<3; i++)
        {
		for (j=0; j<5; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        System.out.print("\nEnter any number: ");
        x = input.nextInt();

        i=0;
        while (i<3 && found == false)
        {
		j=0;
		while (j<5 && found == false)
		{
		if( matrix[i][j] == x )
		{
		found = true;
		}
		j++;
		}
		i++;
        }

        if( found == true )
        {
		System.out.print(x + " is exist in the matrix \n");
        }
        else
        {
		System.out.print(x + " is not exist in the matrix \n");
        }

		}

		}

شرح الكود

			int[][] matrix = new int[3][5];
			int x;
			boolean found = false;

			int i;
			int j;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 5 أعمدة.
و المتغير x لأننا سنستخدمه لتخزين القيمة (أي العدد) التي سيدخلها المستخدم لاحقاً للبحث عنها في المصفوفة.
و المتغير found الذي نوعه boolean أعطيناه القيمة false عند إنشائه لأننا سنستخدمه كشرط أساسي لإيقاف عملية البحث لاحقاً.
و المتغيران i و j سنستخدمها كعدادين لاحقاً بداخل حلقتين while عند البحث في المصفوفة لأننا هذه المرة لا نريد المرور على جميع عناصرها.

			for (i=0; i<3; i++)
			{
			for (j=0; j<5; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (i=0; i<3; i++)
			{
			for (j=0; j<5; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			System.out.print("\nEnter any number: ");
			x = input.nextInt();

هنا سيطلب من المستخدم إدخال أي عدد, و بعدها سيتم تخزينه في المتغير x.

			i=0;
			while (i<3 && found == false)
			{
			j=0;
			while (j<3 && found == false)
			{
			if( matrix[i][j] == x )
			{
			found = true;
			}
			j++;
			}
			i++;
			}

هنا أنشانا الحلقتين i و j للمرور على جميع عناصر المصفوفة طالما أن القيمة التي نريد البحث عنها لم يتم إيجادها بعد.
قبل بداية الحلقة i أعطينا العداد i القيمة 0 لكي نبدأ عملية البحث إبتداءاً من السطر الأول في المصفوفة.
بعدها إستخدمنا الحلقة while و التي ستجعلنا ننتقل من سطر إلى آخر طالما أننا لا نتعدى عدد أسطر المصفوفة و أن القيمة التي نبحث عنها لم يتم إيجادها بعد.
قبل بداية الحلقة j أعطينا العداد j القيمة 0 لكي نبدأ عملية البحث إبتداءاً من العامود الأول في كل سطر من أسطر المصفوفة.
بعدها إستخدمنا الحلقة while و التي ستجعلنا ننتقل من عامود إلى آخر طالما أننا لا نتعدى عدد أعمدة المصفوفة و أن القيمة التي نبحث عنها لم يتم إيجادها بعد.
إذاً كما تلاحظ أن الحلقتين سيمرون على جميع العناصر الموجودة في المصفوفة طالما أن قيمة المتغير found تساوي false
إذاً في حال وجدنا القيمة التي نبحث عنها في المصفوفة, علينا تغيير قيمة المتغير found إلى true لجعل الحلقتان تتوقفان عن العمل.

بداخل الحلقة j سيتم مقارنة قيمة كل عنصر في المصفوفة مع قيمة المتغير x أي ( مع العدد الذي أدخله المستخدم ) كالتالي:

في حال كانت قيمة العنصر تساوي قيمة المتغير x سيتم تغيير قيمة المتغير found إلى true حتى يتم إيقاف الحلقتين, لأنه عندها سنكون قد وجدنا ما نبحث عنه.
بعدها سيتم زيادة قيمة العداد j واحداً حتى يتم الإنتقال إلى العنصر التالي في نفس السطر في حال بقيت قيمة المتغير found تساوي false

في حال بحثنا في جميع العناصر الموجودة في نفس السطر و لم نجد قيمة أي عنصر تساوي قيمة المتغير x سيتم زيادة قيمة العداد i واحداً للإنتقال إلى السطر التالي, لأننا سنكون قد لم نجد بعد ما نبحث عنه.

إذاً, إذا تغيرت قيمة المتغير found إلى true يعني ذلك أننا وجدنا القيمة التي يبحث عنهاالمستخدم و سنوقف مباشرةً الحلقتين i و j لأننا سنوقف حينها عملية البحث.

			if( found == true )
			{
			System.out.print(x + " is exist in the matrix \n");
			}
			else
			{
			System.out.print(x + " is not exist in the matrix \n");
			}

هنا سيتم فحص قيمة المتغير found لتحديد الجملة التي سيتم طباعتها للمستخدم.
إذا أصبحت قيمة المتغير found تساوي true فهذا يعني أن القيمة التي بحث عنها المستخدم موجودة في المصفوفة.
أما إذا بقيت قيمة المتغير found تساوي false فهذا يعني أن القيمة التي بحث عنها المستخدم غير موجودة في المصفوفة.

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين العاشر

المطلوب

هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.

أكتب برنامج يعرّف مصفوفة إسمها matrix تتألف من 3 أسطر و 3 أعمدة.
ثم يطلب من المستخدم إدخال قيم لها.
ثم يعرض للمستخدم جميع القيم التي أصبحت تحتويها المصفوفة.
بعدها يقوم بجمع قيم العناصر الموجودة في كل سطر, و يخزن ناتج الجمع في مصفوفة ذات بعد واحد إسمها vector.
في الأخير يعرض للمستخدم القيم التي أصبحت تحتويها المصفوفة vector.

ملاحظة: قم بتعريف العدادين i و j مرة واحدة في بداية البرنامج.

النتيجة المطلوبة

لنفترض أن المستخدم أدخل القيم ( 1, 2, 3, 4, 5, 6, 7 ,8, 9 ) عند التشغيل.

تحليل النتيجة

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Matrix {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[][] matrix = new int[3][3];
        int[] vector = new int[3];
        int i;
        int j;
        int S;

        for (i=0; i<3; i++)
        {
		for (j=0; j<3; j++)
		{
		System.out.print("Enter matrix["+i+"]["+j+"]: ");
		matrix[i][j] = input.nextInt();
		}
		System.out.print("\n");
        }

        System.out.print("matrix contain these values:\n");
        for (i=0; i<3; i++)
        {
		for (j=0; j<3; j++)
		{
		System.out.print(matrix[i][j] + "\t");
		}
		System.out.print("\n");
        }

        for (i=0; i<3; i++)
        {
		S=0;
		for (j=0; j<3; j++)
		{
		S = S + matrix[i][j];
		}
		vector[i] = S;
        }

        System.out.print("\nvector contain these values:\n");
        for (i=0; i<3; i++)
        {
		System.out.print(vector[i] +"\t");
        }

        System.out.print("\n");
		}

		}

شرح الكود

			int[][] matrix = new int[3][3];
			int[] vector = new int[3];
			int i;
			int j;
			int S;

هنا قمنا بتجهيز المصفوفة matrix و حددنا أنها تتألف من 3 أسطر و 3 أعمدة.
و المصفوفة vector و حددنا أنها تتألف من 3 عناصر فقط لأن كل عنصر بداخلها سنضع فيه ناتج جمع قيم سطر كامل من سطور المصفوفة matrix.
و المتغيران i و j في البداية ليكونا عدادين لأي مصفوفتين في البرنامج. و في كل مرة سنستخدمها سنقوم فقط بتصفير قيمتيهما بدل أن نقوم بتعريفهما من جديد.
و المتغير S لتخزين مجموع القيم الموجودة في كل سطر. سنعطيه القيمة 0 كقيمة أولية لاحقاً قبل البدء بحساب ناتج قيم الموجودة في نفس السطر.

			for (i=0; i<3; i++)
			{
			for (j=0; j<3; j++)
			{
			System.out.print("Enter matrix["+i+"]["+j+"]: ");
			matrix[i][j] = input.nextInt();
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لجعل المستخدم يدخل قيمة لكل عنصر في المصفوفة.
الحلقة i للإنتقال من سطر إلى آخر في المصفوفة, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر في المصفوفة.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيطلب من المستخدم إدخال قيمة لعنصر, ثم سيتم تخزينها في هذا العنصر.
بعد توقف الحلقة j, أي بعد إعطاء قيم لجميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			System.out.print("matrix contain these values:\n");
			for (i=0; i<3; i++)
			{
			for (j=0; j<3; j++)
			{
			System.out.print(matrix[i][j] + "\t");
			}
			System.out.print("\n");
			}

هنا قمنا بإنشاء الحلقتين i و j لعرض جميع قيم المصفوفة matrix.
الحلقة i للإنتقال من سطر إلى آخر فيها, و الحلقة j للإنتقال من عمود إلى آخر في كل سطر فيها.
هنا في كل دورة من دورات الحلقة i سيتم إنشاء حلقة j لعرض قيمة جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم عرض قيمة عنصر, ثم وضع بعض المسافات الفارغة بسبب الرمز \t.
بعد توقف الحلقة j, أي بعد عرض قيم جميع العناصر الموجودة في نفس السطر, سيتم النزول على سطر جديد بسبب الرمز \n.

			for (i=0; i<3; i++)
			{
			S=0;
			for (j=0; j<3; j++)
			{
			S = S + matrix[i][j];
			}
			vector[i] = S;
			}

هنا قمنا بإنشاء الحلقتين i و j للوصول إلى جميع قيم عناصر المصفوفة.
في كل دورة من دورات الحلقة i سيتم حساب ناتج جمع القيم الموجودة في نفس السطر, ثم وضع الناتج في المصفوفة vector كالتالي:

سيتم تصفير قيمة المتغير S قبل البدء بحساب ناتج جمع قيم العناصر الموجودة في نفس السطر حتى لا يتم إضافة ناتج جمع القيم الموجودة في السطر القديم على ناتج القيم الموجودة في السطر الحالي في كل مرة يتم فيها الإنتقال إلى سطر جديد.
بعدها سيتم إنشاء الحلقة j للمرور على جميع العناصر الموجودة في نفس السطر.
في كل دورة من دورات الحلقة j سيتم إضافة قيمة عنصر من العناصر الموجودة في نفس السطر على قيمة المتغير S.
عند توقف الحلقة j سيكون ناتج جمع جميع العناصر الموجودة في نفس السطر موجود في المتغير S و عندها سيتم إضافة قيمة المتغير S في عنصر جديد في المصفوفة vector.

لاحظ كيف سيتم إضافة قيم العناصر الموجودة في نفس السطر على قيمة المتغير S ثم إضافتها في المصفوفة vector :

عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[0][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[0][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 0 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[0][2] على قيمة المتغير S.
إلى هنا يكون المتغير S قد إحتوى على ناتج جمع جميع قيم العناصر الموجودة في السطر الأول في المصفوفة matrix و بالتالي سيتم وضع قيمته في العنصر vector[0].
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[1][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[1][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 1 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[1][2] على قيمة المتغير S.
إلى هنا يكون المتغير S قد إحتوى على ناتج جمع جميع قيم العناصر الموجودة في السطر الأول في المصفوفة matrix و بالتالي سيتم وضع قيمته في العنصر vector[1].
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 0, سيتم إضافة قيمة العنصر matrix[2][0] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 1, سيتم إضافة قيمة العنصر matrix[2][1] على قيمة المتغير S.
عندما تكون قيمة العداد i تساوي 2 و قيمة العداد j تساوي 2, سيتم إضافة قيمة العنصر matrix[2][2] على قيمة المتغير S.
إلى هنا يكون المتغير S قد إحتوى على ناتج جمع جميع قيم العناصر الموجودة في السطر الأول في المصفوفة matrix و بالتالي سيتم وضع قيمته في العنصر vector[2].

			System.out.print("\nvector contain these values:\n");
			for (i=0; i<3; i++)
			{
			System.out.print(vector[i] +"\t");
			}

هنا قمنا بإنشاء الحلقة i لعرض جميع قيم التي أصبحت تحتويهم المصفوفة vector بعد أن تم وضع ناتج جمع كل سطر في المصفوفة matrix فيها.

القائمة الرئيسية

الصفحات

التعامل مع المصفوفات ذات بعدين في الخوارزميات

طرق تعريف مصفوفة ذات بعدين

طريقة تعريف مصفوفة ذات بعدين و إعطائها القيم لاحقاً

طريقة تعريف المصفوفة بدون إعطائها قيم أولية

مثال

شرح الكود

شكل المصفوفة في الذاكرة

طريقة الوصول لعناصر المصفوفة

طريقة إعطاء قيم لعناصر المصفوفة

مثال

شكل المصفوفة في الذاكرة

طريقة عرض القيم المخزنة في عناصر المصفوفة

مثال

البرنامج كاملاً

نتيجة التشغيل

كود الجافا

بناء المصفوفة ذات البعدين

طريقة تعريف مصفوفة ذات بعدين و إعطائها القيم مباشرةً عند إنشائها

طريقة تعريف المصفوفة مع إعطاء عناصرها قيم أولية

مثال

شكل المصفوفة في الذاكرة

طريقة إعطاء قيم لعناصر المصفوفة

مثال

شكل المصفوفة في الذاكرة

طريقة عرض القيم المخزنة في عناصر المصفوفة

مثال

البرنامج كاملاً

نتيجة التشغيل

كود الجافا

الوصول إلى عناصر المصفوفة ذات البعدين بواسطة حلقات متداخلة

مثال

نتيجة التشغيل

كود الجافا

شرح الكود

شكل المصفوفة في الذاكرة قبل و بعد

إستخدام الخاصية length مع المصفوفات ذات البعدين

مثال

كود الجافا

نتيجة التشغيل

كود الجافا

نتيجة التشغيل

الطريقة الصحيحة لإستخدام الخاصية length مع المصفوفة ذات البعدين لمعرفة عدد جميع الأشياء الموجودة فيها

مثال

كود الجافا

نتيجة التشغيل

شرح الكود

طريقة معرفة عدد عناصر المصفوفة ذات البعدين

الطريقة الأولى

كود الجافا

نتيجة التشغيل

الطريقة الثانية

كود الجافا

نتيجة التشغيل

الطريقة الثالثة

كود الجافا

نتيجة التشغيل

شرح الكود

ملاحظة

المبادئ التي عليك اتباعها أو تقليدها مع المصفوفات ذات البعدين

طريقة الوصول إلى قيم عناصر المصفوفة سطراً - سطراً أو عاموداً - عاموداً

كود الجافا

نتيجة التشغيل

تذكر

تمارين شاملة حول المصفوفات ذات البعدين

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الأول

المطلوب

النتيجة المطلوبة

الخوارزمية

كود الجافا

شرح الكود

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الثاني

المطلوب

النتيجة المطلوبة

الخوارزمية

كود الجافا

شرح الكود

التعامل مع المصفوفة ذات البعدين في الخوارزميات - التمرين الثالث

المطلوب

إستخدام الخاصية `length` مع المصفوفات ذات البعدين

الطريقة الصحيحة لإستخدام الخاصية `length` مع المصفوفة ذات البعدين لمعرفة عدد جميع الأشياء الموجودة فيها