کثیر جہتی صفیں۔

• کثیر جہتی صفیں، عمومی نحو
• دو جہتی صفیں۔
• دو جہتی صفوں کا اعلان کرنا، بنانا اور شروع کرنا
• اسکرین پر دو جہتی صف دکھانا
• دو جہتی صف کی تیز پیداوار
• دو جہتی صف کی "لمبائی"
• دو جہتی صف کے استعمال کی مثال: بساط
• دو جہتی صف کے استعمال کی مثال: میٹرکس ضرب
• غیر مستطیل دو جہتی صفیں۔
• سہ جہتی صفیں۔
• جاوا پروگرامر کے حقیقی کام میں کثیر جہتی صفیں۔
• دو جہتی اور تین جہتی صفوں پر دلچسپ مسائل

ایک جہتی جاوا سرنی کیا ہے؟

ایک صف ایک ہی قسم کے عناصر کا ترتیب شدہ سیٹ ہے، قدیم یا حوالہ۔ صفوں کے بارے میں عمومی معلومات (زیادہ تر ایک جہتی) مضمون میں " Arays in Java " اور JavaRush کورس میں مل سکتی ہیں ۔ اس آرٹیکل میں ہم ان arrays کے بارے میں بات کریں گے جن کے عناصر دیگر arrays ہیں۔ ایسی صفوں کو کثیر جہتی کہا جاتا ہے۔ ایک ایسی صف جس کے عناصر دوسرے ارے ہوں، یعنی صفوں کی ایک صف، دو جہتی کہلاتی ہے۔ تمام زبانوں میں اس طرح سے کثیر جہتی صفوں کی تشکیل نہیں ہوتی ہے، لیکن جاوا میں ایسا ہی ہے۔

جاوا کثیر جہتی صفیں، عمومی نحو

عام طور پر، جاوا میں کثیر جہتی صفیں اس طرح نظر آتی ہیں:

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

شاید یہ سب کچھ بہت تجریدی لگتا ہے، اس لیے اب ہم ملٹی جہتی صفوں کے ٹھوس مظاہر کی طرف چلتے ہیں - دو جہتی اور تین جہتی۔ حقیقت یہ ہے کہ جاوا کے ڈویلپرز بعض اوقات دو جہتی صفوں کا استعمال کرتے ہیں، بہت کم اکثر - تین جہتی والے، اور یہاں تک کہ بڑی صفیں انتہائی نایاب ہیں۔ اس بات کا بہت زیادہ امکان ہے کہ آپ ان کا سامنا نہیں کریں گے۔

دو جہتی جاوا سرنی کیا ہے؟

جاوا میں دو جہتی سرنی صفوں کی ایک صف ہے، یعنی ہر سیل میں ایک صف کا حوالہ ہوتا ہے۔ لیکن اسے ایک ٹیبل کی شکل میں پیش کرنا بہت آسان ہے جس میں قطاروں کی تعداد (پہلی جہت) اور کالموں کی تعداد (دوسری جہت) ہے۔ ایک دو جہتی صف جس میں تمام قطاروں میں عناصر کی یکساں تعداد ہوتی ہے اسے مستطیل کہا جاتا ہے۔

دو جہتی صفوں کا اعلان کرنا، بنانا اور شروع کرنا

دو جہتی صف کا اعلان کرنے اور اسے بنانے کا طریقہ کار تقریباً وہی ہے جیسا کہ ایک جہتی کے معاملے میں:

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

دونوں صورتوں میں، ہمیں تین قطاروں اور چار کالموں کے ساتھ ایک دو جہتی صف ملے گی، جو عدد سے بھری ہوئی ہے۔

اسکرین پر دو جہتی صف دکھانا

اس آپریشن کو کرنے کا سب سے منطقی طریقہ یہ ہے کہ پہلے صفر لائن عنصر کو عنصر کے ذریعے آؤٹ پٹ کریں، پھر دوسرا، وغیرہ۔ جاوا میں دو جہتی سرنی کو آؤٹ پٹ کرنے کا سب سے عام طریقہ دو نیسٹڈ لوپس کا استعمال کرنا ہے۔

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۔ یعنی، اگر ہم ایک array کی وضاحت کرتے ہیں int a[] = {1,2,3}، تو آپریشن a.length3 لوٹتا ہے۔ لیکن کیا ہوگا اگر ہم اسی طریقہ کار کو اپنی دو جہتی سرنی پر لاگو کریں؟

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

آؤٹ پٹ: 3 تو یہ آپریشن صفوں کی تعداد کو آؤٹ پٹ کرتا ہے۔ کالموں کی تعداد کیسے حاصل کی جائے؟ اگر ہم مستطیل دو جہتی صفوں کے ساتھ کام کر رہے ہیں (یعنی وہ جن میں تمام لائنیں ایک ہی لمبائی کی ہیں)، تو ہم آپریشن کو لاگو کر سکتے ہیں twoDimArray[0].lengthیا صفر عنصر (بنیادی طور پر صفر لائن) کے بجائے - کوئی اور موجودہ ایک۔ ہم یہ کر سکتے ہیں کیونکہ جاوا میں، دو جہتی سرنی صفوں کی ایک صف ہے، اور عنصر صفر 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";
            }
        }

پروگرام کا آؤٹ پٹ اس طرح ہے: WBWBWBWBWBBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBWBW سب کچھ ایک حقیقی بساط کی طرح ہے، آپ اسے چیک کر سکتے ہیں۔ اب سیلز کو صحیح طریقے سے نمبر دینے کا طریقہ ارے کی زبان میں نہیں بلکہ "شطرنج" زبان میں لکھتے ہیں۔ بورڈ پر نیچے بائیں سیل کو 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 Wh5 B4B4B43W4B443 d 3 Be3 Wf3 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 1 0 0 0

غیر مستطیل دو جہتی صفیں۔

چونکہ دو جہتی صفیں جاوا میں صفوں کی صفیں ہیں، اس لیے اندرونی صفوں میں سے ہر ایک مختلف لمبائی کی ہو سکتی ہے۔ ایک صف بناتے وقت، ہم صرف قطاروں کی تعداد بتا سکتے ہیں نہ کہ کالموں کی تعداد (یعنی انہی قطاروں کی لمبائی)۔ آئیے ایک مثال دیکھتے ہیں۔

//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}۔

جاوا میں تین جہتی صفیں۔

عام فہم اور جاوا زبان کی منطق کی پیروی کرتے ہوئے، تین جہتی سرنی کو " arrays of arrays" یا "ایک ایسی صف جس کا ہر عنصر دو جہتی سرنی ہے" کہلا سکتا ہے۔ مزید یہ کہ یہ دو جہتی صفیں مختلف ہو سکتی ہیں۔ مثال:

// 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];

لیکن زیادہ تر عملی طور پر تین جہتی صفیں ہوتی ہیں جن میں تینوں مقداروں کو ایک ساتھ بیان کیا جاتا ہے، مستطیل دو جہتی صفوں کا ایک اینالاگ۔ جیسا کہ ہم نے پہلے ہی ذکر کیا ہے، تین جہتی یا زیادہ صفیں بہت کم استعمال ہوتی ہیں۔ تاہم، آپ 3D صف کے ساتھ کچھ دلچسپ پروگرام کر سکتے ہیں۔ مثال کے طور پر، ایک کثیر المنزلہ کار پارک۔ ہر منزل کو دو جہتی صف سمجھا جا سکتا ہے، اور پارکنگ کی جگہ کو تین جہتی سرنی کا ایک مخصوص عنصر سمجھا جا سکتا ہے۔ اگر اسپیس خالی ہو اور صحیح ہو تو اسپیس پر قبضہ کر لیا گیا ہو تو اس طرح کے ارے کے عنصر کو ایک قسم کے ذریعے ظاہر کیا جا سکتا ہے جس کی booleanقدر غلط ہے ۔

//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();
            }
        }

دو جہتی اور تین جہتی صفوں پر دلچسپ مسائل

آپ جاوا میں کثیر جہتی صفوں کے بارے میں کافی جانتے ہیں اور، اگر آپ پر اعتماد محسوس کرتے ہیں، تو آپ ذیل میں سے کچھ مسائل کو حل کرنے کی کوشش کر سکتے ہیں۔ وہ آسان نہیں ہیں، لیکن دلچسپ ہیں. ٹک ٹیک ٹو. ایک 3x3 فیلڈ قائم کریں، دو کھلاڑی بنائیں جو باری باری لیتے ہیں۔ ابتدائی طور پر، میدان خالی ہے، اور ہر خالی فیلڈ میں پہلا کھلاڑی کراس لگا سکتا ہے، اور دوسرا صفر۔ فاتح وہ ہے جو سب سے پہلے ایک قطار، ایک کالم یا ترچھے ترتیب میں تین کراس یا تین صفر جمع کرتا ہے۔ لینگٹن کی چیونٹی ایک مخصوص فیلڈ ہے، جسے خلیوں میں تقسیم کیا گیا ہے (ایک دو جہتی صف)، سیاہ یا سفید پینٹ کیا گیا ہے (ایک بے ترتیب فنکشن کے ذریعے سیٹ کیا جا سکتا ہے)۔ ایک "چیونٹی" تصادفی طور پر کسی ایک خلیے میں پیدا ہوتی ہے، اور ہر قدم پر یہ چار سمتوں میں سے کسی ایک میں ملحقہ خلیے کی طرف، افقی یا عمودی طور پر منتقل ہو سکتی ہے۔ چیونٹی کی حرکت کے اصول:

• کالے مربع پر، چیونٹی کو 90° بائیں طرف مڑنا چاہیے، اپنے سیل کا رنگ سفید میں تبدیل کریں، پھر اگلے مربع کی طرف بڑھیں۔
• ایک سفید مربع پر، چیونٹی 90° دائیں طرف مڑتی ہے اور اپنے سیل کا رنگ سیاہ کر دیتی ہے، پھر اگلے مربع کی طرف قدم بڑھاتی ہے۔

nایک طریقہ لکھیں جو چیونٹی کی ابتدائی پوزیشن کو دیکھتے ہوئے مرحلہ نمبر پر تکرار کا حساب لگاتا ہے ۔ فیلڈ کو تصادفی طور پر صفر اور والے سے بھرا جا سکتا ہے (یا حروف سے اشارہ کیا جاتا ہے Wاور Bجیسا کہ ہم نے بساط کی مثال میں کیا تھا)۔ ہمیں دو مزید پیرامیٹرز کی بھی ضرورت ہے - چیونٹی کی افقی اور عمودی پوزیشن کے ساتھ ساتھ اس قدم پر اس کی سمت (شمال، جنوب، مغرب، مشرق)، جبکہ پہلے سے طے شدہ طور پر چیونٹی شمال کی طرف نظر آتی ہے۔ آپ تین جہتی صفوں کا استعمال کرتے ہوئے روبک کیوب کو ماڈل بنانے کی کوشش کر سکتے ہیں۔ ایک معیاری Rubik's کیوب کے 6 چہرے ہوتے ہیں، اور ان میں سے ہر ایک رنگین چوکوں کی تین جہتی صف ہے Color[][][] rubik = new Color[6][3][3]۔ تاہم، Rubik's کیوب کو نافذ کرنا کوئی معمولی کام نہیں ہے۔

صفوں کے بارے میں مفید مواد

JavaRush پر بہت سے مضامین arrays کے لیے وقف ہیں (بنیادی طور پر ایک جہتی مضامین، کیونکہ وہ عملی طور پر زیادہ استعمال ہوتے ہیں)۔ ان پر توجہ دیں۔

1. جاوا میں ارے - مثالوں کے ساتھ beginners کے لیے arrays کے بارے میں
2. Arrays کے بارے میں کچھ - arrays پر اچھا تفصیلی مضمون
3. Arrays کلاس اور اس کا استعمال - مضمون کلاس کے کچھ طریقے بیان کرتا ہے۔Array
4. Arrays پہلا JavaRush لیکچر ہے جو arrays کے لیے وقف ہے۔
5. صفر کی لمبائی والی صف واپس کریں، کالعدم نہیں - موثر پروگرامنگ مصنف جوشوا بلوچ خالی صفوں کو بہتر طریقے سے واپس کرنے کے طریقہ کے بارے میں بات کرتے ہیں۔