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

مفهوم المصفوفات

ماذا تعني كلمة مصفوفة في البرمجة؟

المصفوفة تسمى Array في اللغة الإنجليزية.
يمكنك تصوّر المصفوفة كمتغير واحد بإمكانه تخزين عدة قيم, إذاً المصفوفة كأنها متغير واحد يحتوي على عدة خانات.
الخانة في المصفوفة تسمى عنصر و بالإنجليزية كلمة عنصر تعني Element.
إذاً المصفوفة عبارة عن متغير واحد يتكون من عدة عناصر, أي من عدة Elements.

إلى كم نوع تقسم المصفوفات؟

يمكن للمصفوفة أن تكون ذات بعد واحد أي One dimensional array. في في مادة الرياضيات تسمى Vector.
يمكن للمصفوفة أن تكون ذات بعدين أي Two dimensional array. في مادة الرياضيات تسمى Matrix.
يمكن للمصفوفة أن تكون ذات عدة أبعاد أي Multidimensional array. في مادة أيضاً الرياضيات تسمى Matrix.

ما هي المصفوفات التي سنتعامل معها؟

المصفوفات التي سنتعامل معها و التي تعتبر أهم أنواع المصفوفات هي:
المصفوفات ذات البعد الواحد أي الـ One dimensional array, و المصفوفات ذات البعدين أي الـ Two dimensional array.

لن نضيع لك وقتك و نشرح لك الـ Multidimensional array لأنها لا تستخدم بتاتاً, و لأنه لا حاجة لأن يستخدمها أي مبرمج و هناك الكثير من المبرمجين الذين لم يسمعوا بها أصلاً.

كيف نتعامل مع المصفوفة؟

نستخدم الحلقات البسيطة و الحلقات المتداخلة للتعامل مع المصفوفات.
لذلك ركزنا كثيراً على طريقة استخدام الحلقات في الدروس السابقة.

فوائد المصفوفات

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

الآن, لنفترض أننا نريد إنشاء برنامج يطلب من المستخدم إدخال 100 عدد صحيح, و بعد إدخال جميع الأعداد نريده أن يعرض له جميع الأعداد التي قام هو بإدخالها.

للوهلة الأولى ستفكر كالتالي:
- هل أنا بحاجة إلى 100 متغير لكي أحفظ 100 قيمة!
- هل سأطلب من المستخدم 100 مرة أن يدخل عدداً صحيحاً!
- إذا أردت أن أعرض له الأعداد التي قام بإدخالها, هل سأكتب دالة الـ Print() أيضاً 100 مرة!

الجواب هو حتماً كلا, لأنك لو كنت ستفعل ذلك, ستضطر إلى كتابة أكثر من 400 سطر, في حين أنك تستطيع تنفيذ البرنامج بـ 5 أسطر فقط لو استخدمت مصفوفة لتخزين الأشياء التي أدخلها المستخدم.

تستخدم المصفوفات للأسباب التالية

1. تقليل الوقت و الجهد على المبرمج.

2. السرعة في الأداء.

3. تقليل حجم الكود.

4. إمكانية الوصول للقيم بطريقة سريعة و سهلة جداً.

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

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

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

1. تعرّف المصفوفة و تعطيها القيم لاحقاً.

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

معلومة تقنية

في لغة جافا لا يمكن تغيير عدد عناصر المصفوفة بعد أن تم تحديده.

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

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

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

مثال

int[] vector = new int[5]; 
		

• هنا قمنا بتعريف مصفوفة ذات بعد واحد, إسمها vector, نوعها int و تتألف من 5 عناصر.

شرح الكود

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

• إذاً, إذا طبعنا قيم جميع عناصر المصفوفة و وجدناها كلها تساوي ( 0 أو 0.0 أو null ) فذلك يعني أننا لم نغير قيمة أي عنصر بعد.
      لا تقلق ستجد هذه الفكرة مشروحة بتفصيل لاحقاً في آخر الدرس.

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

قواعد ثابتة في جميع لغات البرمجة

• عندما نعرّف مصفوفة ذات بعد واحد تقوم الذاكرة بترقيم الخانات بالترتيب, و تبدأ من الرقم 0.

• العنصر الأول دائماً يتم تخزينه في الخانة رقم 0.

• العنصر الأخير دائماً يتم تخزينه في الخانة رقم vector.length-1. أي عدد جميع العناصر ناقص 1.

• تعطي الذاكرة القيمة صفر لجميع العناصر كقيمة أولية إذا لم نضع لها قيم عند تعريفها, أي إذا لم نغير قيمة العنصر سنجد أن قيمته تساوي صفر.

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

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

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

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

مثال

vector[0] = 7;
vector[1] = 40;
vector[2] = -20; 
		

• هنا قمنا بتغيير قيمة العنصر الأول و الثاني و الثالث.

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

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

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

مثال

System.out.print("vector[0]: " + vector[0] + "\n" );
System.out.print("vector[1]: " + vector[1] + "\n" );
System.out.print("vector[2]: " + vector[2] + "\n" );
System.out.print("vector[3]: " + vector[3] + "\n" );
System.out.print("vector[4]: " + vector[4] + "\n" );
		

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

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

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

كود الجافا

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

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

إذا أردنا إدخال القيم مباشرةً عند تعريف المصفوفة, بعد رمز المساواة = نضع الرمزين { } و بداخلهم نضع القيم التي نريدها, و نضع فاصلة بين كل قيمتين.

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

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

مثال

int[] vector = {7, 40, -20, 0, 0};
		

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

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

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

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

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

مثال

vector[0] = 3;
vector[3] = 121;
vector[4] = 10;
		

• هنا قمنا بتغيير قيمة العنصر الأول و الرابع و الخامس.

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

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

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

مثال

System.out.print("vector[0]: " + vector[0] + "\n" );
System.out.print("vector[1]: " + vector[1] + "\n" );
System.out.print("vector[2]: " + vector[2] + "\n" );
System.out.print("vector[3]: " + vector[3] + "\n" );
System.out.print("vector[4]: " + vector[4] + "\n" );
		

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

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

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

كود الجافا

public class Vector {
 
    public static void main (String[] args) {
 
        int[] vector = {7, 40, -20, 0, 0};                       // هنا قمنا بتعريف مصفوفة تتألف من 5 عناصر و أعطيناها القيم مباشرة عند إنشائها
 
        vector[0] = 3;                                           // هنا قمنا بتغيير قيمة العنصر الأول
        vector[3] = 121;                                         // هنا قمنا بتغيير قيمة العنصر الرابع
        vector[4] = 10;                                          // هنا قمنا بتغيير قيمة العنصر الخامس
 
        System.out.print("vector[0]: " + vector[0] + "\n" );     // هنا قمنا بعرض قيمة العنصر الأول
        System.out.print("vector[1]: " + vector[1] + "\n" );     // هنا قمنا بعرض قيمة العنصر الثاني
        System.out.print("vector[2]: " + vector[2] + "\n" );     // هنا قمنا بعرض قيمة العنصر الثالث
        System.out.print("vector[3]: " + vector[3] + "\n" );     // هنا قمنا بعرض قيمة العنصر الرابع
        System.out.print("vector[4]: " + vector[4] + "\n" );     // هنا قمنا بعرض قيمة العنصر الخامس
 
    }
 
}
		

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

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

مثال

في المثال التالي, قمنا بتعريف مصفوفة إسمها vector تتألف من 10 عناصر.
بعدها جعلنا المستخدم يدخل قيمة لكل عنصر من عناصرها.
في الأخير قمنا بعرض جميع القيم التي أدخلها المستخدم في المصفوفة.

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

• إذا قمت بإدخال القيم ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ) عند تشغيل البرنامج, ستكون نتيجة التشغيل كالتالي.

كود الجافا

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

شرح الكود

int[] vector = new int[10];
				

• هنا قمنا بتعريف مصفوفة تتألف من 10 عناصر.





for(int i=0; i<10; i++)
{
    System.out.print("Enter vector["+i+"]: ");
    vector[i] = input.nextInt();
}
				

• هنا في كل دورة من دورات الحلقة i سيطلب من المستخدم إدخال قيمة في عنصر محدد من عناصر المصفوفة و بعدها سيتم وضع القيمة التي أدخلها في هذا العنصر كالتالي:

• عندما تكون قيمة العداد i تساوي 0, سيطلب من المستخدم إدخال قيمة للعنصر vector[0], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[0].

• عندما تكون قيمة العداد i تساوي 1, سيطلب من المستخدم إدخال قيمة للعنصر vector[1], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[1].

• عندما تكون قيمة العداد i تساوي 2, سيطلب من المستخدم إدخال قيمة للعنصر vector[2], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[2].

• عندما تكون قيمة العداد i تساوي 3, سيطلب من المستخدم إدخال قيمة للعنصر vector[3], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[3].

• عندما تكون قيمة العداد i تساوي 4, سيطلب من المستخدم إدخال قيمة للعنصر vector[4], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[4].

• عندما تكون قيمة العداد i تساوي 5, سيطلب من المستخدم إدخال قيمة للعنصر vector[5], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[5].

• عندما تكون قيمة العداد i تساوي 6, سيطلب من المستخدم إدخال قيمة للعنصر vector[6], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[6].

• عندما تكون قيمة العداد i تساوي 7, سيطلب من المستخدم إدخال قيمة للعنصر vector[7], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[7].

• عندما تكون قيمة العداد i تساوي 8, سيطلب من المستخدم إدخال قيمة للعنصر vector[8], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[8].

• عندما تكون قيمة العداد i تساوي 9, سيطلب من المستخدم إدخال قيمة للعنصر vector[9], بعدها سيتم تخزين القيمة التي أدخلها في العنصر vector[9].





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

• هنا في كل دورة من دورات الحلقة i سيتم عرض قيمة عنصر محدد من عناصر المصفوفة. سيعرض له أن العنصر رقم كذا قيمته كذا كالتالي:

• عندما تكون قيمة العداد i تساوي 0, سيطبع له أن قيمة العنصر vector[0] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 1, سيطبع له أن قيمة العنصر vector[1] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 2, سيطبع له أن قيمة العنصر vector[2] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 3, سيطبع له أن قيمة العنصر vector[3] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 4, سيطبع له أن قيمة العنصر vector[4] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 5, سيطبع له أن قيمة العنصر vector[5] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 6, سيطبع له أن قيمة العنصر vector[6] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 7, سيطبع له أن قيمة العنصر vector[7] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 8, سيطبع له أن قيمة العنصر vector[8] تساوي القيمة التي أدخلها له سابقاً.

• عندما تكون قيمة العداد i تساوي 9, سيطبع له أن قيمة العنصر vector[9] تساوي القيمة التي أدخلها له سابقاً.

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

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

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

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

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

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

مثال

في المثال التالي, قمنا بتعريف 3 مصفوفات, و كل مصفوفة تخزن نوع بيانات مختلف.

• المصفوفة الأولى نوعها int, إسمها vector_int, و تتألف من 3 عناصر.

• المصفوفة الثانية نوعها double, إسمها vector_double, و تتألف من 3 عناصر.

• المصفوفة الثالثة نوعها String, إسمها vector_String, و تتألف من 3 عناصر.

بعدها قمنا بعرض القيم الإفتراضية التي تم وضعها لعناصر هذه المصفوفات.

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

كود الجافا

public class Vector {
 
    public static void main (String[] args) {
 
        int[] vector_int = new int[3];
        double[] vector_double = new double[3];
        String[] vector_String = new String[3];
 
        System.out.print("vector_int[0]: " + vector_int[0] + "\n" );
        System.out.print("vector_int[1]: " + vector_int[1] + "\n" );
        System.out.print("vector_int[2]: " + vector_int[2] + "\n\n" );
 
        System.out.print("vector_double[0]: " + vector_double[0] + "\n" );
        System.out.print("vector_double[1]: " + vector_double[1] + "\n" );
        System.out.print("vector_double[2]: " + vector_double[2] + "\n\n" );
 
        System.out.print("vector_String[0]: " + vector_String[0] + "\n" );
        System.out.print("vector_String[1]: " + vector_String[1] + "\n" );
        System.out.print("vector_String[2]: " + vector_String[2] + "\n\n" );
 
    }
 
}
		

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

• المصفوفة vector_int نوعها int, لذلك تم إعطاء عناصرها القيمة 0 كقيمة أولية.

• المصفوفة vector_double نوعها double, لذلك تم إعطاء عناصرها القيمة 0.0 كقيمة أولية.

• المصفوفة vector_String نوعها String, لذلك تم إعطاء عناصرها القيمة null كقيمة أولية.

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

مفهوم الخاصيّة length

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

بشكل عام, نحتاج إستخدامها عند بناء كود للتعامل مع المصفوفة مهما كان حجمها.
ستتعرف على أهميتها و فائدتها عند دراسة التمارين الموضوعة في آخر الدرس.

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

لإستخدام الخاصيّة length الموجودة في أي مصفوفة: نضع إسم المصفوفة, ثم نقطة, ثم الكلمة length كالتالي:

ArrayName.length;
	

المثال الأول

في المثال التالي قمنا بإنشاء مصفوفة تتألف من 50 عنصر, ثم إستخدمنا الخاصيّة length لمعرفة عدد عناصر المصفوفة.

كود الجافا

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

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

إذاً الكود vector.length جعلنا نعرف حجم المصفوفة.

المثال الثاني

سنقوم بإنشاء مصفوفة و نعطيها القيم مباشرةً عند إنشائها, ثم سنستخدم الخاصيّة length لمعرفة عدد عناصر المصفوفة.

كود الجافا

public class Vector {
 
    public static void main (String[] args) {
 
        // هنا قمنا بتعريف مصفوفة تتألف من 7 عناصر
        int[] vector = {10, 23, -30, 0, 500, 660, -70};
 
        // ثم عرضنا عدد عناصر المصفوفة
        System.out.print("the number of elements is: " + vector.length + "\n" );
 
    }

}
		

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

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

طريقة تبديل قيم المتغيرات أو العناصر

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

مثال

لنفترض أنه عندنا متغير إسمه A و قيمته 5, و متغير آخر إسمه B و قيمته 10 كالتالي.

كود لجافا

int A = 5;
int B = 10;
		

كيف نستطيع تبديل قيم المتغيرات A و B برمجياً؟

لتبديل قيمة أي متغيّرين أو عنصرين, نحن بحاجة دائماً إلى متغير ثالث نستخدمه بشكل مؤقت حتى نتم من خلاله عملية التبديل.

الآن, سنستخدم متغير ثالث إسمه temp لنتم من خلاله عملية التبديل.
إذاً المتغير temp سيكون مجرد وسيط في عملية التبادل.

كود لجافا

int A = 5;
int B = 10;
int temp;

temp = B;          // و التي تساوي 10 temp في المتغير B هنا وضعنا قيمة المتغير
   B = A;          // و التي تساوي 5 B في المتغير A هنا وضعنا قيمة المتغير
   A = temp;       // و التي تساوي 10 A في المتغير temp هنا وضعنا قيمة المتغير
		

شرح الكود

ملاحظة

معظم المبرمجون يطلقون على المتغير الوسيط في عملية ما إسم temp و هي اختصار لكلمة temporary و التي تعني أن هذا المتغير سيستخدم بشكل مؤقت لإتمام عملية ما.
تذكر أن معرفة إسم المتغير يسهّل العمل عليك و على المبرمجين الذين يعملون معك لذلك حاول دائماً استخدام تسميات متعارف عليها.

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

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

• إستخدم الحلقة for في حال أردت الوصول لجميع عناصر المصفوفة و إجعلها تبدأ من 0 إلى عدد عناصرها ناقص 1.

• إستخدم الحلقة while أو do while في حال لم تكن تريد الوصول لجميع عناصر المصفوفة.

• إستخدم الحلقة do while في حال كنت تريد جعل المستخدم يدخل قيمة تستوفي شرط معين.

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

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

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

المطلوب

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

1. أكتب برنامج يطلب من المستخدم إعطائه عدد يمثل عدد عناصر مصفوفة إسمها vector و يخزنه في متغير إسمه N.
       إنتبه: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.

2. ثم ينشئ المصفوفة vector و يحدد أن عدد عناصرها هو العدد الذي أدخله المستخدم.

3. ثم يعرض عدد عناصر المصفوفة vector للمستخدم باستخدام الخاصية length.

4. ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة vector.

5. ثم يعرض للمستخدم جميع قيم عناصر المصفوفة vector.

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

في الخطوة الأولى: عند تشغيل البرنامج سيطلب من المستخدم إدخال عدد يمثل عدد عناصر المصفوفة.

• لنفترض أن المستخدم أدخل العدد " 5- " سيطلب منه إدخال عدد جديد لأنه أصغر أو يساوي 0.

• لنفترض أن المستخدم أدخل العدد " 0 " سيطلب منه إدخال عدد جديد لأنه أصغر أو يساوي 0.

• لنفترض أن المستخدم أدخل العدد " 5 ". هنا سيقبله لأنه ليس أصغر أو يساوي 0, ثم سينتقل إلى الخطوة التالية.

في الخطوة الثانية: سيعرض له العدد الذي قبله من المستخدم و الذي سيمثل عدد عناصر المصفوفة.

في الخطوة الثالثة: سينتظر المستخدم ليدخل قيمة لكل عنصر.

في الخطوة الرابعة: سيعرض له قيم جميع عناصر المصفوفة النهائية.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int N;
        int[] vector;

        do
        {
		System.out.print("Enter the length of the vector: ");
		N = input.nextInt();
        }
        while ( N  <= 0 );

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

        vector = new int[N];
        System.out.print("vector contains " + vector.length + " elements \n" );

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("Enter vector[" +i+ "]: " );
		vector[i] = input.nextInt();
        }

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("vector[" +i+ "]: " +vector[i]+ "\n" );
        }

		}

		}
	  

شرح الكود

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





			int N;
			int[] vector;
		  

• هنا قمنا بتجهيز المتغير N لتخزين عدد عناصر المصفوفة, و هو أول شيء سيطلب من المستخدم إدخاله.

• و المصفوفة vector و التي لم يتم تحديد عدد عناصرها.





			do
			{
			System.out.print("Enter the length of the vector: ");
			N = input.nextInt();
			}
			while ( N  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفة, بعدها سيتم تخزينه في المتغير N.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			vector = new int[N];
			System.out.print("vector contains " + vector.length + " elements \n" );
		  

• هنا سيتم تحديد عدد عناصر المصفوفة و الذي يساوي قيمة العدد N التي أدخلها المستخدم.

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

• لو وضعنا N بدل vector.length لكان الجواب نفسه لأن عدد العناصر أيضاً يساوي قيمة المتغير N.





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("Enter vector[" +i+ "]: " );
			vector[i] = input.nextInt();
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها بهدف إعطاء قيمة لكل عنصر فيها.

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





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("vector[" +i+ "]: " +vector[i]+ "\n" );
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها بهدف عرض قيمة كل عنصر فيها.

• في كل دورة من دورات الحلقة i سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.

ملاحظة

جميع الحلقات i التي قمنا بتعريفها في هذا البرنامح, يمكن كتابتها بطرق مختلفة.
فمثلاً لو وضعنا الشرط i<N أو i<=vector.length-1 أو i<vector.length بدل i<=N-1 لعمل البرنامج أيضاً بنفس الطريقة لأن كل هذه الشروط ستجعل الحلقة تتوقف عند index آحر عنصر في المصفوفة.

لو عدت للتمرين, و وضعت أي شرط منهم و أدخلت نفس القيم التي أدخلناها, فإن آخر قيمة للعداد i ستكون 4 لأن قيمة المتغير N الذي يمثل عدد عناصر المصفوفة تساوي 5.

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

المطلوب

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

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

2. ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة vector.

3. ثم يعرض للمستخدم ناتج جمع جميع قيم عناصر المصفوفة vector.

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

لنفترض أن المستخدم أدخل " 6 " عناصر.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int N;
        int S = 0;
        int[] vector;

        do
        {
		System.out.print("Enter the length of the vector: ");
		N = input.nextInt();
        }
        while ( N  <= 0 );

        vector = new int[N];

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("Enter vector[" +i+ "]: " );
		vector[i] = input.nextInt();
		S = S + vector[i];
        }

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

		}

		}
	  

شرح الكود

			int N;
			int S = 0;
			int[] vector;
		  

• هنا قمنا بتجهيز المتغير N لتخزين عدد عناصر المصفوفة, و هو أول شيء سيطلب من المستخدم إدخاله.

• و المتغير S لتخزين مجموع قيم عناصر المصفوفة.

• و المصفوفة vector و التي لم يتم تحديد عدد عناصرها.





			do
			{
			System.out.print("Enter the length of the vector: ");
			N = input.nextInt();
			}
			while ( N  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفة, بعدها سيتم تخزينه في المتغير N.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			vector = new int[N];
		  

• هنا سيتم تحديد عدد عناصر المصفوفة و الذي يساوي قيمة العدد N التي أدخلها المستخدم.

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

• لو وضعنا N بدل vector.length لكان الجواب نفسه لأن عدد العناصر أيضاً يساوي قيمة المتغير N.





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("Enter vector[" +i+ "]: " );
			vector[i] = input.nextInt();
			S = S + vector[i];
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها.

• في كل دورة من دورات الحلقة i سيحدث التالي:

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

• بعدها سيتم تخزين العدد الذي سيدخله في هذا العنصر.

• بعدها سيتم إضافة قيمة العنصر على قيمة المتغير S.





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

• في الأخير سيتم عرض ناتج جمع جميع عناصر المصفوفة vector المخزن في المتغير S.

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

المطلوب

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

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

2. ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة vector.

3. في الأخير يعرض للمستخدم عدد العناصر التي تملك قيم أكبر من صفر, و عدد العناصر التي تملك قيم الأصغر من صفر, و عدد العناصر التي تملك قيم تساوي صفر.

إرشادات

إستخدم متغير خاص لتخزين عدد العناصر التي تملك قيم أكبر من صفر.
و متغير خاص لتخزين عدد العناصر التي تملك قيم أصغر من صفر.
و متغير خاص لتخزين عدد العناصر التي تملك قيم تساوي صفر.

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

لنفترض أن المستخدم أدخل " 10 " عناصر كما في الصورة التالية.

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

لنفترض أن المستخدم أدخل " 10 " عناصر كما في الصورة السابقة.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int L;
        int[] vector;
        int P = 0;
        int N = 0;
        int Z = 0;

        do
        {
		System.out.print("Enter the length of the vector: ");
		L = input.nextInt();
        }
        while ( L  <= 0 );

        vector = new int[L];

        for (int i=0; i <=L-1; i++)
        {
		System.out.print("Enter vector[" +i+ "]: " );
		vector[i] = input.nextInt();

		if ( vector[i] > 0 )
		{
		P = P + 1;
		}

		else if ( vector[i] < 0 )
		{
		N = N + 1;
		}

		else
		{
		Z = Z + 1;
		}
        }

        System.out.print("The number of positive numbers is: " +P+ "\n" );
        System.out.print("The number of negative numbers is: " +N+ "\n" );
        System.out.print("The number of zero numbers is: " +Z+ "\n" );

		}

		}
	  

شرح الكود

			int L;
			int[] vector;
			int P = 0;
			int N = 0;
			int Z = 0;
		  

• هنا قمنا بتجهيز المتغير L لتخزين عدد عناصر المصفوفة, و هو أول شيء سيطلب من المستخدم إدخاله.

• و المصفوفة vector و التي لم يتم تحديد عدد عناصرها.

• و المتغير P لتخزين عدد العناصر التي تملك قيمة أكبر من صفر.

• و المتغير N لتخزين عدد العناصر التي تملك قيمة أصغر من صفر.

• و المتغير Z لتخزين عدد العناصر التي تملك قيمة تساوي صفر.





			do
			{
			System.out.print("Enter the length of the vector: ");
			L = input.nextInt();
			}
			while ( L  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفة, بعدها سيتم تخزينه في المتغير L.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			vector = new int[L];
		  

• هنا سيتم تحديد عدد عناصر المصفوفة و الذي يساوي قيمة العدد L التي أدخلها المستخدم.

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

• لو وضعنا L بدل vector.length لكان الجواب نفسه لأن عدد العناصر أيضاً يساوي قيمة المتغير L.





			for (int i=0; i <=L-1; i++)
			{
			System.out.print("Enter vector[" +i+ "]: " );
			vector[i] = input.nextInt();

			if ( vector[i] > 0 )
			{
			P = P + 1;
			}

			else if ( vector[i] < 0 )
			{
			N = N + 1;
			}

			else
			{
			Z = Z + 1;
			}
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها.

• في كل دورة من دورات الحلقة i سيحدث التالي:

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

• بعدها سيتم تخزين العدد الذي سيدخله في هذا العنصر.

• بعدها سيتم فحص قيمة العنصر لمعرفة ما إذا كانت عبارة عن عدد أكبر أو أصغر أو يساوي صفر.

• إذا كانت قيمة العنصر عبارة عن عدد أكبر من صفر, سيتم إضافة 1 على قيمة المتغير P.

• إذا كانت قيمة العنصر عبارة عن عدد أصغر من صفر, سيتم إضافة 1 على قيمة المتغير N.

• إذا كانت قيمة العنصر عبارة عن عدد يساوي صفر, سيتم إضافة 1 على قيمة المتغير Z.





			System.out.print("The number of positive numbers is: " +P+ "\n" );
			System.out.print("The number of negative numbers is: " +N+ "\n" );
			System.out.print("The number of zero numbers is: " +Z+ "\n" );
		  

• في الأخير سيتم عرض عدد الأرقام الأكبر و الأصغر و التي تساوي صفر, التي تم تخزينها في المتغيرات P و N و Z.

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

المطلوب

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

1. أكتب برنامج يطلب من المستخدم إدخال 5 قيم و يخزنهم في مصفوفة إسمها vector تتألف من 5 عناصر.

2. ثم يعرض للمستخدم قيم المصفوفة التي قام هو بإدخالها.

3. بعدها يقوم بترتيب هذه القيم من الأصغر إلى الأكبر.

4. في الأخير يعرض للمستخدم قيم المصفوفة من جديد.

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

لنفترض أن المستخدم أدخل " 5 " عناصر كما في الصورة التالية.

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

لنفترض أن المستخدم أدخل " 5 " عناصر كما في الصورة السابقة.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int[] vector = new int[5];
        int temp;

        for (int i=0; i<vector.length; i++)
        {
		System.out.print("Enter vector[" +i+ "]: ");
		vector[i] = input.nextInt();
        }

        System.out.print("\nBefore arrangement: \n");

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

        for (int i=0; i<vector.length-1; i++)
        {
		for (int j=i+1; j<vector.length; j++)
		{
		if ( vector[i] > vector[j] )
		{
		temp = vector[i];
		vector[i] = vector[j];
		vector[j] = temp;
		}
		}
        }

        System.out.print("\nAfter arrangement: \n");

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

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

		}

		}
	  

شرح الكود

			int[] vector = new int[5];
			int temp;
		  

• هنا قمنا بتجهيز المصفوفة vector التي سنضع فيها القيم التي يدخلها المستخدم و حددنا عند إنشائها أن عدد عناصرها يساوي 5.

• و المتغير temp الذي سنستخدمه بشكل مؤقت أثناء عملية ترتيب العناصر من الأصغر إلى الأكبر.





			for (int i=0; i<vector.length; i++)
			{
			System.out.print("Enter vector[" +i+ "]: ");
			vector[i] = input.nextInt();
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها.

• في كل دورة من دورات الحلقة i سيحدث التالي:

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

• بعدها سيتم تخزين العدد الذي سيدخله في هذا العنصر.





			System.out.print("\nBefore arrangement: \n");

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

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها لعرض جميع قيم المصفوفة قبل أن نرّتب قيمها من الأصغر إلى الأكبر.





			for (int i=0; i<vector.length-1; i++)
			{
			for (int j=i+1; j<vector.length; j++)
			{
			if ( vector[i] > vector[j] )
			{
			temp = vector[i];
			vector[i] = vector[j];
			vector[j] = temp;
			}
			}
			}
		  

• هنا عندنا حلقتين متداخلتين, الحلقة i و الحلقة j.

• الحلقة i تبدأ من أول عنصر إلى العنصر ما قبل الأخير, أي من 0 إلى 3.

• الحلقة j تبدأ من أول عنصر بعد العداد i إلى آخر عنصر, أي من i+1 إلى 4.

• إذاً هنا في كل دورة من دورات الحلقة i سيتم مقارنة قيمة عنصر جديد في المصفوفة, مع قيمة جميع العناصر التي تليه في المصفوفة عن طريق الحلقة j.

• إذا كانت قيمة العنصر vector[i] أكبر من قيمة أي عنصر بعده من العناصر vector[j], سيتم تبديل قيمهم.

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





			System.out.print("\nAfter arrangement: \n");

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

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

ملاحظات مهمة حول عدد عناصر المصوفة

في هذا التمرين قمنا بإنشاء مصفوفة vector مع تحديد أنها تتألف من 5 عناصر لحظة إنشاءها.
هذا يعني أن الكود vector.length سيعطينا الرقم 5 لأن عدد عناصر المصفوفة يساوي 5.

لاحظ كم طريقة يمكنك إعتمادها لكتابة حلقة for للوصول إلى جميع عناصر المصفوفة vector.
ركز على الشرط الذي سيجعل الحلقة تتوقف عن التنفيذ فقط.

أمثلة

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

		  for (int i=0; i<vector.length; i++)
		

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

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

		  for (int i=0; i<=vector.length-1; i++)
		

هذه الحلقة تبدأ من 0 إلى ما قبل عدد عناصر المصفوفة. أي من 0 إلى 5-1. أي من 0 إلى 4.
هذه الطريقة تشبه الطريقة الأولى لكن لا ننصح بها لأنه بإمكانك تقليل حجم الكود كما في الطريقة الأولى.

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

		  for (int i=0; i<5; i++)
		

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

الطريقة الرابعة

		  for (int i=0; i<=5-1; i++)
		

هذه الحلقة تبدأ من 0 إلى ما قبل الرقم 5-1. أي من 0 إلى 4.
لا تستخدم هذه الطريقة لأنه لا يمكنك إعتمادها إلا إذا كنت تعرف حجم المصفوفة و لأنه بإمكانك تقليل حجم الكود كما في الطريقة الثالثة.

خلاصة

من الآن فصاعداً حاول دائماً استخدام الخاصية length بدل كتابة عدد ثابت عند كتابة شرط إيقاف الحلقة حتى يكون برنامجك مرن.
فمثلاً لو عدت للبرنامج و أردت تغيير عدد عناصر المصفوفة من 5 إلى 10 و كنت قد إستخدمت الطريقة الثالثة في الوصول إلى عناصر المصفوفة, لكان عليك الدخول لجميع الحلقات و كتابة الرقم 10 بدل كل رقم 5 حتى يعمل البرنامج بشكل صحيح.
بينما لو استخدمت الخاصية length كما فعلنا لما كنت ستضطر إلى تعديل كود أي حلقة.

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

المطلوب

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

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

2. ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة vector.

3. ثم يعرض للمستخدم قيم المصفوفة التي قام هو بإدخالها.

4. بعدها يقوم بالمرور على جميع عناصر المصفوفة و يفعل التالي:
       - كل قيمة يجدها أكبر من صفر يحولها إلى 1.
       - كل قيمة يجدها أصغر من صفر يحولها إلى -1.

5. في الأخير يعرض للمستخدم قيم المصفوفة من جديد.

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

لنفترض أن المستخدم أدخل " 6 " عناصر كما في الصورة التالية.

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

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

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int N;
        int[] vector;

        do
        {
		System.out.print("Enter the length of the vector: ");
		N = input.nextInt();
        }
        while ( N  <= 0 );

        vector = new int[N];

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("Enter vector[" +i+ "]: " );
		vector[i] = input.nextInt();
        }

        System.out.print("\nBefore changing: \n");

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("vector[" +i+ "]: " + vector[i] +"\n");
        }

        for (int i=0; i <=N-1; i++)
        {
		if ( vector[i] > 0 )
		{
		vector[i] = 1;
		}
		else if ( vector[i] < 0 )
		{
		vector[i] = -1;
		}
        }

        System.out.print("\nAfter changing: \n");

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("vector[" +i+ "]: " + vector[i] +"\n");
        }

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

		}

		}
	  

شرح الكود

			int N;
			int[] vector;
		  

• هنا قمنا بتجهيز المتغير N لتخزين عدد عناصر المصفوفة, و هو أول شيء سيطلب من المستخدم إدخاله.

• و المصفوفة vector و التي لم يتم تحديد عدد عناصرها.





			do
			{
			System.out.print("Enter the length of the vector: ");
			N = input.nextInt();
			}
			while ( N  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفة, بعدها سيتم تخزينه في المتغير N.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			vector = new int[N];
		  

• هنا سيتم تحديد عدد عناصر المصفوفة و الذي يساوي قيمة العدد N التي أدخلها المستخدم.

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

• لو وضعنا N بدل vector.length لكان الجواب نفسه لأن عدد العناصر أيضاً يساوي قيمة المتغير N.





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("Enter vector[" +i+ "]: " );
			vector[i] = input.nextInt();
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها لعرض جميع قيم المصفوفة قبل قيمة أي عنصر فيها.





			System.out.print("\nBefore changing: \n");

			for (int i=0; i<=N-1; i++)
			{
			System.out.print("vector[" +i+ "]: " + vector[i] +"\n");
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها بهدف عرض قيمة كل عنصر فيها.

• في كل دورة من دورات الحلقة i سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.





			for (int i=0; i <=N-1; i++)
			{
			if ( vector[i] > 0 )
			{
			vector[i] = 1;
			}
			else if ( vector[i] < 0 )
			{
			vector[i] = -1;
			}
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها لفحص قيمة كل عنصر فيها.

• في كل دورة من دورات الحلقة i سيقوم البرنامج بفحص قيمة عنصر ثم تحويلها كالتالي:

• إذا وجد أن قيمة العنصر أكبر من 0 سيقوم بوضع 1 مكانها.

• إذا وجد أن قيمة العنصر أصغر من 0 سيقوم بوضع -1 مكانها.





			System.out.print("\nAfter arrangement: \n");

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

• في الأخير سيتم إنشاء حلقة تبدأ من index العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها لعرض قيم المصفوفة بعد أن تم تحويلهم.

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

المطلوب

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

1. أكتب برنامج يقوم بتعريف ثلاث مصفوفات A و B و C.

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

3. بعدها يطلب من المستخدم إدخال قيمة لجميع عناصر المصفوفتين A و B و يجمعهم في المصفوفة C.

4. في الأخير يعرض للمستخدم القيم التي أصبحت تحتويها المصفوفة C.

إرشادات

يجب أن يتم جمع قيم عناصر المصفوفتين A و B قي المصفوفة C كالتالي.

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

لنفترض أن المستخدم أراد حجم المصفوفات يساوي " 3 " و أدخل نفس القيم كما في الصورة السابقة.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int N;
        int[] A;
        int[] B;
        int[] C;

        do
        {
		System.out.print("Enter the length for all vectors: ");
		N = input.nextInt();
        }
        while ( N  <= 0 );

        A = new int[N];
        B = new int[N];
        C = new int[N];

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("Enter A[" +i+ "]: ");
		A[i] = input.nextInt();

		System.out.print("Enter B[" +i+ "]: ");
		B[i] = input.nextInt();

		C[i] = A[i] + B[i];
        }

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("C[" +i+ "]: " + C[i] +"\n");
        }

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

		}

		}
	  

شرح الكود

			int N;
			int[] A;
			int[] B;
			int[] C;
		  

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

• و المصفوفات A و B و C و لم نحدد عدد عناصرهم.





			do
			{
			System.out.print("Enter the length for all vectors: ");
			N = input.nextInt();
			}
			while ( N  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفات الثلاثة, بعدها سيتم تخزينه في المتغير N.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			A = new int[N];
			B = new int[N];
			C = new int[N];
		  

• هنا سيتم تحديد عدد عناصر المصفوفات الثلاثة و الذي هو قيمة المتغير N الذي أدخله المستخدم.





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("Enter A[" +i+ "]: ");
			A[i] = input.nextInt();

			System.out.print("Enter B[" +i+ "]: ");
			B[i] = input.nextInt();

			C[i] = A[i] + B[i];
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في كل المصفوفات, أي العنصر رقم 0, إلى آخر عنصر موجود في المصفوفات و الذي يملك الـ index الأخير, أي N-1.

• في كل دورة من دورات الحلقة i سيحدث التالي:

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

• فمثلاً, عندما تكون قيمة العداد i تساوي 0 , سيطلب منه إدخال قيمة للعنصر A[0] و العنصر B[0] ثم يجمعهم و يضع الناتج في العنصر C[0].





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("C[" +i+ "]: " + C[i] +"\n");
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة C إلى آخر عنصر موجود فيها بهدف عرض قيمة كل عنصر فيها.

• في كل دورة من دورات الحلقة i سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.

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

المطلوب

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

1. أكتب برنامج يعرّف ثلاث مصفوفات A و B و C.

2. ثم يطلب من المستخدم إدخال العدد الذي يمثل عدد عناصر المصفوفتين A و B.

3. بعدها يطلب من المستخدم إعطاء قيم للمصفوفتين A و B و يخزنهم في المصفوفة C.

4. في الأخير يعرض للمستخدم القيم التي أصبحت تحتويها المصفوفة C.

إرشادات

يجب أن يتم جمع قيم عناصر المصفوفتين A و B قي المصفوفة C كالتالي.

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

لنفترض أن المستخدم أراد حجم المصفوفتين A و B يساوي " 4 " و أدخل نفس القيم كما في الصورة السابقة.

الخوارزمية

كود الجافا

		import java.util.Scanner;

		public class Vector {

		public static void main (String[] args) {

        Scanner input = new Scanner(System.in);

        int N;
        int[] A;
        int[] B;
        int[] C;
        int k = 0;     // C سنستخدم هذا المتغير كعداد للوصول لعناصر المصفوفة

        do
        {
		System.out.print("Enter the length for vectors ( A ) and ( B ): ");
		N = input.nextInt();
        }
        while ( N  <= 0 );

        A = new int[N];
        B = new int[N];
        C = new int[N*2];

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

        for (int i=0; i <=N-1; i++)
        {
		System.out.print("Enter A[" +i+ "]: ");
		A[i] = input.nextInt();

		System.out.print("Enter B[" +i+ "]: ");
		B[i] = input.nextInt();
        }

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

        for (int i=0; i <=N-1; i++)
        {
		C[k] = A[i];
		C[k+1] = B[i];

		k = k+2;
        }

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

        for (int i=0; i <=(N*2)-1; i++)
        {
		System.out.print("C[" +i+ "]: " + C[i] +"\n");
        }

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

		}

		}
	  

شرح الكود

			int N;
			int[] A;
			int[] B;
			int[] C;
			int k = 0;
		  

• هنا قمنا بتجهيز المتغير N لتخزين عدد عناصر المصفوفتين A و B, و هو أول شيء سيطلب من المستخدم إدخاله.

• و المصفوفات A و B و C و لم نحدد عدد عناصرهم.

• و المتغير k الذي أعطيناه القيمة 0 كقيمة أولية لأننا سنستخدمه كعداد للوصول إلى عناصر المصفوفة C.





			do
			{
			System.out.print("Enter the length for vectors ( A ) and ( B ): ");
			N = input.nextInt();
			}
			while ( N  <= 0 );
		  

• هنا سيطلب من المستخدم إدخال عدد عناصر المصفوفتينA و B, بعدها سيتم تخزينه في المتغير N.

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

• إذاً هذه الحلقة تضمن أن لا يقوم المستخدم بإدخال عدد أصغر أو يساوي 0.





			A = new int[N];
			B = new int[N];
			C = new int[N*2];
		  

• هنا سيتم تحديد عدد عناصر المصفوفات الثلاثة كالتالي:

• عدد عناصر المصفوفتان A و B يساوي قيمة المتغير N.

• عدد عناصر المصفوفة c يساوي عدد عناصر المصفوفتين A و B مع بعض, أي يساوي قيمة المتغير N*2.
  ملاحظة: عدد عناصر المصفوفة C يمكن تحديدها بأكثر من طريقة, فمثلاً يمكنك أن تكتب N+N أو A.length + B.length بدل N*2.





			for (int i=0; i <=N-1; i++)
			{
			System.out.print("Enter A[" +i+ "]: ");
			A[i] = input.nextInt();

			System.out.print("Enter B[" +i+ "]: ");
			B[i] = input.nextInt();
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في كلا المصفوفتين, أي العنصر رقم 0, إلى آخر عنصر موجود فيهما و الذي يملك الـ index الأخير, أي N-1.

• في كل دورة من دورات الحلقة i سيطلب من المستخدم إدخال قيمة لعنصر في المصفوفة A, و قيمة لعنصر في المصفوفة B.
      فمثلاً, عندما تكون قيمة العداد i تساوي 0 , سيطلب منه إدخال قيمة للعنصر A[0] و العنصر B[0].





			for (int i=0; i <=N-1; i++)
			{
			C[k] = A[i];
			C[k+1] = B[i];

			k = k+2;
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في كل المصفوفات, أي العنصر رقم 0, إلى آخر عنصر موجود في المصفوفات و الذي يملك الـ index الأخير, أي N-1.

• في كل دورة من دورات الحلقة i سيحدث التالي في المصفوفة C من خلال العداد k:
  

  • سيتم وضع قيمة عنصر المصفوفة A في عنصر جديد في المصفوفة C.

  • ثم وضع قيمة عنصر المصفوفة B في العنصر التالي في المصفوفة C.

  • ثم سيتم زيادة قيمة المتغير k إثنين لتجاوز الخانتين السابقتين اللتين تم وضع القيم فيهما.

  • طريقة عمل الكود:

  • في البداية, قيمة العداد i تساوي 0, لذلك سيتم وضع قيمة العنصر A[0] في العنصر C[0], ثم قيمة العنصر B[0] في العنصر C[1].

  • بعد أن تم إضافة 2 على قيمة المتغير k و أصبحت قيمة العداد i تساوي 1, سيتم وضع قيمة العنصر A[1] في العنصر C[2], ثم قيمة العنصر B[1] في العنصر C[3].

  • بعد أن تم إضافة 2 على قيمة المتغير k و أصبحت قيمة العداد i تساوي 2, سيتم وضع قيمة العنصر A[2] في العنصر C[4], ثم قيمة العنصر B[2] في العنصر C[5].

  • بعد أن تم إضافة 2 على قيمة المتغير k و أصبحت قيمة العداد i تساوي 3, سيتم وضع قيمة العنصر A[3] في العنصر C[6], ثم قيمة العنصر B[3] في العنصر C[7].

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

			for (int i=0; i <=(N*2)-1; i++)
			{
			System.out.print("C[" +i+ "]: " + C[i] +"\n");
			}
		  

• هنا أنشأنا حلقة تبدأ من index العنصر الأول في المصفوفة C إلى آخر عنصر موجود فيها بهدف عرض قيمة كل عنصر أصبح فيها.

• في كل دورة من دورات الحلقة i سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.