التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات
طريقة تبديل قيم المتغيرات أو العناصر
ركز جيداً على طريقة تبديل قيم المتغيرات, لأن الطريقة نفسها يمكن إستخدامها مع المصفوفات.
لنفترض أنه عندنا متغير إسمه 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في حال كنت تريد جعل المستخدم يدخل قيمة تستوفي شرط معين.
ستفهم كل هذه المبادئ من التمارين.
تمارين شاملة حول المصفوفات ذات البعد الواحد
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين الأول
هذا التمرين مقسّم إلى أربع أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يطلب من المستخدم إعطائه عدد يمثل عدد عناصر مصفوفة إسمها
vectorو يخزنه في متغير إسمهN.
    إنتبه: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.ثم ينشئ المصفوفة
vectorو يحدد أن عدد عناصرها هو العدد الذي أدخله المستخدم.ثم يعرض عدد عناصر المصفوفة
vectorللمستخدم باستخدام الخاصيةlength.ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة
vector.ثم يعرض للمستخدم جميع قيم عناصر المصفوفة
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.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين الثاني
هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يطلب من المستخدم إعطائه عدد يمثل عدد عناصر مصفوفة إسمها
vectorو يخزنه في متغير إسمهN.
    تذكر: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة
vector.ثم يعرض للمستخدم ناتج جمع جميع قيم عناصر المصفوفة
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.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين الثالث
هذا التمرين مقسّم إلى ثلاثة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يطلب من المستخدم إعطائه عدد يمثل عدد عناصر مصفوفة إسمها
vectorو يخزنه في المتغيرL.
    تذكر: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة
vector.في الأخير يعرض للمستخدم عدد العناصر التي تملك قيم أكبر من صفر, و عدد العناصر التي تملك قيم الأصغر من صفر, و عدد العناصر التي تملك قيم تساوي صفر.
إستخدم متغير خاص لتخزين عدد العناصر التي تملك قيم أكبر من صفر.
و متغير خاص لتخزين عدد العناصر التي تملك قيم أصغر من صفر.
و متغير خاص لتخزين عدد العناصر التي تملك قيم تساوي صفر.
لنفترض أن المستخدم أدخل " 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.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين الرابع
هذا التمرين مقسّم إلى أربع أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يطلب من المستخدم إدخال 5 قيم و يخزنهم في مصفوفة إسمها
vectorتتألف من 5 عناصر.ثم يعرض للمستخدم قيم المصفوفة التي قام هو بإدخالها.
بعدها يقوم بترتيب هذه القيم من الأصغر إلى الأكبر.
في الأخير يعرض للمستخدم قيم المصفوفة من جديد.
لنفترض أن المستخدم أدخل " 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 كما فعلنا لما كنت ستضطر إلى تعديل كود أي حلقة.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين الخامس
هذا التمرين مقسّم إلى خمسة أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يطلب من المستخدم إعطائه عدد يمثل عدد عناصر مصفوفة إسمها
vectorو يخزنه في متغير إسمهN.
    تذكر: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفة لا يمكن أن يكون صفر أو أقل من صفر.ثم يطلب من المستخدم إدخال قيمة لكل عنصر من عناصر المصفوفة
vector.ثم يعرض للمستخدم قيم المصفوفة التي قام هو بإدخالها.
بعدها يقوم بالمرور على جميع عناصر المصفوفة و يفعل التالي:
    - كل قيمة يجدها أكبر من صفر يحولها إلى1.
    - كل قيمة يجدها أصغر من صفر يحولها إلى-1.في الأخير يعرض للمستخدم قيم المصفوفة من جديد.
لنفترض أن المستخدم أدخل " 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 العنصر الأول في المصفوفة إلى آخر عنصر موجود فيها لعرض قيم المصفوفة بعد أن تم تحويلهم.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين السادس
هذا التمرين مقسّم إلى أربع أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يقوم بتعريف ثلاث مصفوفات
AوBوC.ثم يطلب من المستخدم إدخال عدد يمثل عدد عناصر المصفوفات الثلاثة.
    تذكر: يجب أن يدخل المستخدم عدد أكبر من صفر, لأن عدد عناصر المصفوفات لا يمكن أن يكون صفر أو أقل من صفر.بعدها يطلب من المستخدم إدخال قيمة لجميع عناصر المصفوفتين
AوBو يجمعهم في المصفوفةC.في الأخير يعرض للمستخدم القيم التي أصبحت تحتويها المصفوفة
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 سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.
التعامل مع المصفوفة ذات البعد الواحد في الخوارزميات - التمرين السابع
هذا التمرين مقسّم إلى أربع أفكار رئيسية, عليك اتباع التقسيم التالي خطوة خطوة حتى تنجز البرنامج.
أكتب برنامج يعرّف ثلاث مصفوفات
AوBوC.ثم يطلب من المستخدم إدخال العدد الذي يمثل عدد عناصر المصفوفتين
AوB.بعدها يطلب من المستخدم إعطاء قيم للمصفوفتين
AوBو يخزنهم في المصفوفةC.في الأخير يعرض للمستخدم القيم التي أصبحت تحتويها المصفوفة
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 سيطبع للمستخدم أن العنصر رقم كذا قيمته كذا.