مصفوفات متعددة الأبعاد

• المصفوفات متعددة الأبعاد، بناء الجملة العام
• صفائف ثنائية الأبعاد
• الإعلان عن المصفوفات ثنائية الأبعاد وإنشائها وتهيئتها
• عرض مصفوفة ثنائية الأبعاد على الشاشة
• إخراج سريع لمجموعة ثنائية الأبعاد
• "أطوال" مجموعة ثنائية الأبعاد
• مثال على استخدام مصفوفة ثنائية الأبعاد: رقعة الشطرنج
• مثال على استخدام مصفوفة ثنائية الأبعاد: ضرب المصفوفات
• مصفوفات ثنائية الأبعاد غير مستطيلة
• المصفوفات ثلاثية الأبعاد
• المصفوفات متعددة الأبعاد في العمل الحقيقي لمبرمج جافا
• مشاكل مثيرة للاهتمام على المصفوفات ثنائية الأبعاد وثلاثية الأبعاد

ما هي مصفوفة جافا أحادية البعد؟

المصفوفة عبارة عن مجموعة مرتبة من العناصر من نفس النوع أو البدائية أو المرجعية. يمكن العثور على معلومات عامة حول المصفوفات (معظمها أحادية البعد) في المقالة " المصفوفات في Java " وفي دورة JavaRush . سنتحدث في هذه المقالة عن المصفوفات التي تكون عناصرها عبارة عن مصفوفات أخرى. تسمى هذه المصفوفات متعددة الأبعاد. المصفوفة التي تكون عناصرها مصفوفات أخرى، أي مصفوفة من المصفوفات، تسمى ثنائية الأبعاد. لا تحتوي جميع اللغات على مصفوفات متعددة الأبعاد منظمة بهذه الطريقة، ولكن هذا هو الحال في Java.

جافا مصفوفات متعددة الأبعاد، بناء الجملة العام

بشكل عام، تبدو المصفوفات متعددة الأبعاد في Java كما يلي:

Data_type[dimension1][dimension2][]..[dimensionN] array_name = new data_type[size1][size2]….[sizeN];

أين Data_typeهو نوع العناصر في المصفوفة. يمكن أن تكون بدائية أو مرجعية (فئة). عدد أزواج الأقواس بالداخل dimensionهو بُعد المصفوفة (في حالتنا - N). array_name- اسم المصفوفة size1...sizN- عدد العناصر في كل بعد من أبعاد المصفوفة. الإعلان عن المصفوفات متعددة الأبعاد:

int[][] twoDimArray; //two-dimensional array
String[][][] threeDimArray; //three-dimensional array
double[][][][][] fiveDimArray; // five-dimensional array

ربما يبدو كل هذا تجريديًا للغاية، لذا دعنا ننتقل الآن إلى المظاهر الملموسة للمصفوفات متعددة الأبعاد - ثنائية الأبعاد وثلاثية الأبعاد. الحقيقة هي أن مطوري Java يستخدمون أحيانًا مصفوفات ثنائية الأبعاد، وفي كثير من الأحيان أقل - المصفوفات ثلاثية الأبعاد، وحتى المصفوفات الأكبر حجمًا نادرة للغاية. هناك احتمال كبير أنك لن تواجههم.

ما هي مصفوفة جافا ثنائية الأبعاد؟

المصفوفة ثنائية الأبعاد في Java هي مصفوفة من المصفوفات، أي أن كل خلية تحتوي على مرجع إلى مصفوفة. ولكن من الأسهل بكثير تقديمه في شكل جدول يحتوي على عدد معين من الصفوف (البعد الأول) وعدد معين من الأعمدة (البعد الثاني). تسمى المصفوفة ثنائية الأبعاد التي تحتوي جميع الصفوف فيها على عدد متساو من العناصر مستطيلة.

الإعلان عن المصفوفات ثنائية الأبعاد وإنشائها وتهيئتها

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

int[][] twoDimArray = new int[3][4];

تحتوي هذه المصفوفة على 3 صفوف و4 أعمدة. حجم مصفوفة مستطيلة ثنائية الأبعاد (قد لا تكون مستطيلة، المزيد عن ذلك أدناه)، أي يمكن تحديد العدد الإجمالي للعناصر عن طريق ضرب عدد الصفوف في عدد الأعمدة. تمت تهيئته (ملؤه) الآن بالقيم الافتراضية. وهذا هو، الأصفار. دعونا نملأها بالقيم التي نحتاجها.

twoDimArray[0][0] = 5;//write the value 5 into the cell at the intersection of the zero row and zero column
twoDimArray[0][1] = 7; //write the value 7 into the cell at the intersection of the zero row and the first column
twoDimArray[0][2]  = 3;
twoDimArray[0][3] = 17;
twoDimArray[1][0] = 7;
twoDimArray[1][1] = 0;
twoDimArray[1][2] = 1;
twoDimArray[1][3] = 12;
twoDimArray[2][0] = 8;
twoDimArray[2][1] = 1;
twoDimArray[2][2] = 2;
twoDimArray[2][3] = 3;

كما هو الحال مع المصفوفات أحادية البعد، يمكنك تنفيذ إجراء التهيئة بشكل أسرع:

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};

في كلتا الحالتين، سوف نحصل على مصفوفة ثنائية الأبعاد مكونة من ثلاثة صفوف وأربعة أعمدة، مملوءة بالأعداد الصحيحة.

عرض مصفوفة ثنائية الأبعاد على الشاشة

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

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};//declared an array and filled it with elements
for (int i = 0; i < 3; i++) {  //go through the lines
            for (int j = 0; j < 4; j++) {//go through the columns
                System.out.print(" " + twoDimArray[i][j] + " "); //output element
            }
            System.out.println();// line wrap for the visual preservation of the tabular form
        }

إخراج سريع لمجموعة ثنائية الأبعاد

أقصر طريقة لعرض قائمة عناصر مصفوفة ثنائية الأبعاد على الشاشة هي استخدام طريقة deepToStringالفصل Arrays. مثال:

int[][] myArray = {{18,28,18},{28,45,90},{45,3,14}};
System.out.printLn(Arrays.deepToString(myArray));

ونتيجة البرنامج هي المخرجات التالية: [[18، 28، 18]، [28، 45، 90]، [45، 3، 14]]

"أطوال" مجموعة ثنائية الأبعاد

للحصول على طول مصفوفة أحادية البعد (أي عدد العناصر فيها)، يمكنك استخدام المتغير length. أي أننا إذا قمنا بتعريف مصفوفة int a[] = {1,2,3}، فإن العملية a.lengthترجع 3. ولكن ماذا لو طبقنا نفس الإجراء على مصفوفتنا ثنائية الأبعاد؟

int [][] twoDimArray = {{5,7,3,17}, {7,0,1,12}, {8,1,2,3}};
System.out.println(twoDimArray.length);

الإخراج: 3 إذن تقوم هذه العملية بإخراج عدد الصفوف في المصفوفة. كيفية الحصول على عدد الأعمدة؟ إذا كنا نتعامل مع صفائف مستطيلة ثنائية الأبعاد (أي تلك التي تكون فيها جميع الخطوط بنفس الطول)، فيمكننا تطبيق العملية twoDimArray[0].lengthأو بدلاً من عنصر الصفر (خط الصفر بشكل أساسي) - أي عنصر آخر موجود. يمكننا القيام بذلك لأنه في Java، المصفوفة ثنائية الأبعاد هي مصفوفة من المصفوفات، والعنصر صفر twoDimArray[0]هو مصفوفة بطول 4. يمكنك التحقق من ذلك بنفسك.

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

يمكن استخدام المصفوفات ثنائية الأبعاد لإنشاء أي مجال ثنائي الأبعاد محدود، على سبيل المثال في الألعاب، وخاصة في لعبة الشطرنج. من السهل أن نفكر في رقعة الشطرنج كمصفوفة ثنائية الأبعاد. يمكنك "إرفاق" الرسومات بهذا، لكن الآن، دعنا نحدد رقعة الشطرنج باستخدام الرموز ونخرجها إلى وحدة التحكم. تم طلاء المربع الأيسر السفلي من رقعة الشطرنج باللون الأسود، والمربع التالي باللون الأبيض، كما هو الحال فوقه. لذلك، يتغير اللون في كل مرة تنتقل فيها إلى خلية مجاورة للجانب. لتعيين تلوين الشطرنج ليس يدويًا، ولكن باستخدام خوارزمية، يمكنك استخدام التحقق من التكافؤ: إذا كان مجموع فهرس الصف والعمود متساويًا أو صفرًا، فستكون الخلية بيضاء، وإلا ستكون سوداء. لإجراء هذا الفحص، نستخدم عامل التشغيل المتبقي % في الخوارزمية. نظرًا لأننا لا نعمل مع الرسومات، بل مع الرموز، فسنشير إلى الخلية البيضاء بالحرف W(الأبيض)، والخلية السوداء بالحرف B(الأسود).

//set the chessboard as a two-dimensional array
String [][] chessBoard = new String[8][8];
        for (int i = 0; i< chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W";
                else chessBoard[i][j] = "B";
            }
        }

إخراج البرنامج هو كما يلي: WBWBWBWBBWBWBWBWWBWBW BWBBWBWBWBWBWBBW BWBWBWWBWBWBWBBWBWBWB W كل شيء يشبه رقعة الشطرنج الحقيقية، يمكنك التحقق من ذلك. الآن دعونا نكتب طريقة لترقيم الخلايا بشكل صحيح ليس بلغة المصفوفات، بل بلغة "الشطرنج". الخلية اليسرى السفلية على اللوحة تسمى A1، بينما في مصفوفتنا تسمى chessBoard[7][0]. دعونا نربط كل زوج من المؤشرات في مصفوفة ثنائية الأبعاد بما يعادلها من "الشطرنج". للقيام بذلك، نستخدم سطرين - " abcdefgh" و " 87654321" (بترتيب عكسي - للتبسيط، بحيث تتوافق رقعة الشطرنج 8 مع العمود الصفري).

public static String chessBoardCoord(int a, int b) {
            String letters = "abcdefgh";
            String numbers = "87654321";
            if ((a > 7)|| (b>7)) return null; //if the number is outside the board, return the default value - null
            else return (Character.toString(letters.charAt(a)) + numbers.charAt(b)); /*charAt - a method with which we extract from the string the element under the passed number, here - under the numbers a and b. Character.toString - a method that converts the received character into a string */
        }

الآن دعونا نعرض في كل خلية ليس لونها فحسب، بل رقمها أيضًا، باستخدام هذه الطريقةchessBoardCoord

String [][] chessBoard = new String[8][8];
        for (int i = 0; i < chessBoard.length; i++) {
            for (int j = 0; j < chessBoard[0].length; j++) {
                if ((i + j) % 2 == 0) chessBoard[i][j] = "W" + chessBoardCoord(j,i);
                else chessBoard[i][j] = "B"+ chessBoardCoord(j,i);
            }
        }

            for (int i = 0; i < chessBoard.length; i++) {
                for (int j = 0; j < chessBoard[0].length; j++) {
                    System.out.print(" " + chessBoard[i][j] + " ");
                }
                System.out.println();
            }

إخراج البرنامج: Wa8 Bb8 Wc8 Bd8 We8 Bf8 Wg8 Bh8 Ba7 Wb7 Bc7 Wd7 Be7 Wf7 Bg7 Wh7 Wa6 Bb6 Wc6 Bd6 We6 Bf6 Wg6 Bh6 Ba5 Wb5 Bc5 Wd5 Be5 Wf5 Bg5 Wh5 Wa4 Bb4 Wc4 Bd4 We4 Bf4 Wg4 Bh4 Ba3 Wb3 Bc3 Wd 3 بي 3 دبليو إف 3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 حيث We2يعني المربع الأبيض المرقم e2.

مثال على استخدام مصفوفة ثنائية الأبعاد: ضرب المصفوفات

انتباه!يتطلب هذا المثال معرفة أساسية بالمصفوفات. هنا سيتم قول القليل جدًا عنهم، وهذه المعلومات مخصصة لأولئك الذين درسوا حساب المصفوفات ولكنهم نسوا إلى حد ما. ومع ذلك، يمكن استخلاص هذه المعرفة من المصادر المفتوحة، ولا سيما من مقالة على ويكيبيديا . هذا مثال جيد على استخدام المصفوفات ثنائية الأبعاد، لكن يمكننا المضي قدمًا بدونها. لذا، إذا بدا الأمر غير مفهوم بالنسبة لك الآن من وجهة نظر رياضية، ولا تريد الخوض فيه حقًا، فلا تتردد في تخطي المثال. إذا كنت قد درست الجبر الخطي الأساسي، فربما تكون قد تعلمت عن المصفوفات المستطيلة كمصفوفات مستطيلة. حيث a11، a12... aNN هي بعض الأرقام. في الشكل، المصفوفة ليست مستطيلة، بل مربعة (عدد الصفوف يساوي عدد الأعمدة، ولكن هذا ليس هو الحال دائمًا). في الحياة الواقعية، نادرًا ما توجد مثل هذه المصفوفات، ولكنها شائعة جدًا في البرمجة وعلوم الكمبيوتر. على وجه الخصوص، يتم استخدامها في رسومات الحاسوب ومحركات الألعاب. على سبيل المثال، يمكن برمجة دوران جسم ما على الشاشة إلى أي زاوية باستخدام مصفوفة الدوران. في الفضاء ثنائي الأبعاد، تبدو مصفوفة الدوران كما يلي: حيث ثيتا هي الزاوية التي يجب أن يدور الجسم من خلالها. يمكن إضافة مصفوفات ذات أبعاد متساوية لبعضها البعض، وتتم عملية الإضافة عنصرًا بعنصر (نضيف عناصر لها نفس المؤشرات). لكن عملية ضرب المصفوفات أقل شيوعًا. وبالتالي، لا يمكن ضرب المصفوفات ولا يمكن الحصول على المصفوفة الناتجة إلا إذا كان عدد أعمدة المصفوفة الأولى يتزامن مع عدد صفوف الثانية. ستحتوي مصفوفة النتائج على نفس عدد الصفوف الموجودة في المصفوفة الأولى ونفس عدد الأعمدة الموجودة في المصفوفة الثانية. يتم تنفيذ الضرب على النحو التالي. دعونا نحصل على مصفوفة a[l][m]و b[m][n]. ونتيجة لضربهم، يجب أن نحصل على مصفوفة c[l][n]. للحصول على عنصر من c[0][0]مصفوفة حاصل الضرب، عليك a[0][0]ضرب العنصر الصفري من الصف الصفري من المصفوفة الأولى في العنصر الصفري من المصفوفة الثانية، ثم ضرب العنصر الأول من الصف الأول من المصفوفة الأولى في العنصر الأول من العمود الأول من المصفوفة الثانية، وهكذا، وبعد ذلك يتم إضافة جميع المنتجات الناتجة.

a[0][0]*b[0][0] + a[0][1]*b[1][0] + … + a[0][m-1]*b[m-1][0]

للحصول على العنصر الثاني من الصف الأول من مصفوفة النتائج، نقوم بنفس الإجراء مع الصف الثاني

a[1][0]*b[0][0] + a[1][1]*b[0][1] + … + a[0][m-1]*b[m-1][0]

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

//declaring two matrices
int [][] twoDimArray1 = {{1,0,0,0},{0,1,0,0},{0,0,0,0}};
int[][] twoDimArray2 = {{1,2,3},{1,1,1},{0,0,0},{2,1,0}};

//matrix multiplication process
int[][]twoDimArray3 = new int [twoDimArray1.length][twoDimArray2[0].length];
        for (int i=0; i<twoDimArray3[0].length; i++)
            for (int j=0; j<twoDimArray3.length; j++)
                for (int k=0; k<twoDimArray1[0].length; k++)
                              twoDimArray3[i][j] = twoDimArray3[i][j] + twoDimArray1[i][k] * twoDimArray2[k][j];

//output on display
        for (int i = 0; i < twoDimArray3.length; i++) {
            for (int j = 0; j < twoDimArray3[0].length; j++) {
                System.out.print(" " + twoDimArray3[i][j] + " ");
            }
            System.out.println();
        }

ويخرج البرنامج النتيجة التالية: 1 2 3 1 1 0 0 0

مصفوفات ثنائية الأبعاد غير مستطيلة

نظرًا لأن المصفوفات ثنائية الأبعاد عبارة عن مصفوفات من المصفوفات في Java، فيمكن أن تكون كل من المصفوفات الداخلية ذات أطوال مختلفة. عند إنشاء مصفوفة، يمكننا فقط تحديد عدد الصفوف وليس عدد الأعمدة (أي، في الواقع، طول هذه الصفوف نفسها). لنلقي نظرة على مثال.

//declaring and creating an array, specifying only the number of rows
int [][] twoDimArray = new int[5][];

//initialize the array, filling it with arrays of different lengths
        twoDimArray[0] = new int[]{1, 2, 3, 4, 5};
        twoDimArray[1] = new int[]{1,2,3,4};
        twoDimArray[2] = new int[]{1,2,3};
        twoDimArray[3] = new int[]{1,2};
        twoDimArray[4] = new int[]{1};
//display the resulting non-rectangular two-dimensional array on the screen
        for (int i = 0; i < twoDimArray.length; i++) {
            for (int j = 0; j < twoDimArray[i].length; j++) {
                System.out.print(" " + twoDimArray[i][j] + " ");
            }
            System.out.println();
        }

مخرجات البرنامج: 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1 وبالتالي، يحتوي السطر الصفري من المصفوفة على المصفوفة {1,2,3,4,5}، والسطر الرابع يحتوي على المصفوفة {1}.

المصفوفات ثلاثية الأبعاد في جافا

باتباع المنطق السليم ومنطق لغة جافا، يمكن تسمية المصفوفة ثلاثية الأبعاد بـ "مصفوفة مصفوفات من المصفوفات" أو "مصفوفة يكون كل عنصر فيها عبارة عن مصفوفة ثنائية الأبعاد". علاوة على ذلك، يمكن أن تكون هذه المصفوفات ثنائية الأبعاد مختلفة. مثال:

// create a three-dimensional array consisting of two two-dimensional arrays
int[][][] threeDimArr = new int[2][][];
//create the first 2D array of a 5x2 3D array
        threeDimArr[0] = new int[5][2];
//create a second 2D array of a 1x1 3D array
        threeDimArr[1] = new int[1][1];

ولكن في أغلب الأحيان، توجد في الممارسة العملية صفائف ثلاثية الأبعاد يتم فيها تعريف الكميات الثلاثة مرة واحدة، وهو ما يشبه المصفوفات المستطيلة ثنائية الأبعاد. كما ذكرنا سابقًا، نادرًا ما يتم استخدام المصفوفات ثلاثية الأبعاد أو أكثر. ومع ذلك، يمكنك برمجة شيء مثير للاهتمام باستخدام مجموعة ثلاثية الأبعاد. على سبيل المثال، موقف سيارات متعدد الطوابق. ويمكن اعتبار كل طابق مصفوفة ثنائية الأبعاد، كما يمكن اعتبار مكان وقوف السيارات عنصرا محددا في مصفوفة ثلاثية الأبعاد. يمكن تمثيل عنصر من هذا المصفوفة بنوع booleanبقيمة false إذا كانت المساحة خالية وصحيح إذا كانت المساحة مشغولة.

//set a boolean three-dimensional array. This car park has 3 floors, each of which can accommodate 2x5 = 10 cars. By default, all cells are empty (false)
boolean[][][] parkingLot = new boolean[3][2][5];
//two cars arrived and parked on the ground floor in cell [1][0] and [1][3]
        parkingLot[0][1][0] = true;
        parkingLot[0][1][3] = true;

//Output the array to the console
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 2; j++) {
                for (int k = 0; k < 5; k++) {
                    System.out.print("arr[" + i + "][" + j + "][" + k + "] = " + parkingLot[i][j][k] + "\t");

                }
                System.out.println();
            }
        }

مشاكل مثيرة للاهتمام على المصفوفات ثنائية الأبعاد وثلاثية الأبعاد

أنت تعرف ما يكفي عن المصفوفات متعددة الأبعاد في Java، وإذا كنت تشعر بالثقة، فيمكنك محاولة حل بعض المشكلات أدناه. فهي ليست سهلة، ولكنها مثيرة للاهتمام. تيك تاك تو. قم بإعداد حقل 3x3، وقم بإنشاء لاعبين يتناوبان. في البداية، الملعب فارغ، وفي كل حقل من الحقول الفارغة يمكن للاعب الأول وضع علامة عرضية، والثاني صفر. الفائز هو من يجمع أولاً ثلاثة تقاطعات أو ثلاثة أصفار مرتبة في صف واحد أو عمود واحد أو قطريًا. نملة لانغتون . يوجد حقل معين، مقسم إلى خلايا (مصفوفة ثنائية الأبعاد)، مطلية باللون الأسود أو الأبيض (يمكن ضبطها بواسطة وظيفة عشوائية). تتجسد «النملة» عشوائيًا في إحدى الخلايا، وفي كل خطوة يمكنها التحرك في أحد الاتجاهات الأربعة إلى الخلية المجاورة، أفقيًا أو رأسيًا. قواعد حركة النملة:

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

اكتب طريقة لحساب التكرار عند رقم الخطوة nبمعلومية الموضع الأولي للنملة. يمكن ملء الحقل عشوائيًا بالأصفار والواحدات (أو يُشار إليه بالحروف Wو B، كما فعلنا في مثال رقعة الشطرنج). نحتاج أيضًا إلى معلمتين إضافيتين - الموضع الأفقي والرأسي للنملة، وكذلك اتجاهها في هذه الخطوة (الشمال والجنوب والغرب والشرق)، بينما تنظر النملة افتراضيًا إلى الشمال. يمكنك محاولة تصميم مكعب روبيك باستخدام مصفوفات ثلاثية الأبعاد. يحتوي مكعب روبيك القياسي على 6 وجوه، وكل وجه منها عبارة عن مجموعة ثلاثية الأبعاد من المربعات الملونة Color[][][] rubik = new Color[6][3][3]. ومع ذلك، فإن تنفيذ مكعب روبيك ليس مهمة تافهة.

مواد مفيدة حول المصفوفات

تم تخصيص العديد من المقالات حول JavaRush للمصفوفات (بشكل أساسي المصفوفات أحادية البعد، حيث يتم استخدامها في كثير من الأحيان في الممارسة العملية). انتبه لهم.

1. المصفوفات في جافا - حول المصفوفات للمبتدئين مع الأمثلة
2. شيء عن المصفوفات - مقالة مفصلة جيدة عن المصفوفات
3. فئة المصفوفات واستخدامها - توضح المقالة بعض أساليب الفئةArray
4. المصفوفات هي أول محاضرة في JavaRush مخصصة للمصفوفات.
5. إرجاع مصفوفة ذات طول صفري، وليست خالية - يتحدث مؤلف البرمجة الفعالة جوشوا بلوخ عن كيفية إرجاع المصفوفات الفارغة بشكل أفضل