گھڻائي وارين صفن

• گھڻائي مجموعو، عام نحو
• ٻه-dimensional arrays
• اعلان ڪرڻ، ٺاھڻ ۽ شروع ڪرڻ ٻه-dimensional arrays
• اسڪرين تي ٻه-dimensional صف ڏيکاريندي
• هڪ ٻه-dimensional صف جي تيز پيداوار
• "ڊگهي" هڪ ٻه-dimensional صف جي
• هڪ ٻه-dimensional صف استعمال ڪرڻ جو مثال: checkerboard
• ٻه-dimensional صف استعمال ڪرڻ جو مثال: ميٽرڪس ضرب
• غير مستطيل ٻه-dimensional arrays
• ٽي-dimensional arrays
• جاوا پروگرامر جي حقيقي ڪم ۾ گھڻائي واريون صفون
• دلچسپ مسئلا ٻه-dimensional ۽ ٽي-dimensional arrays تي

هڪ طرفي جاوا صف ڇا آهي؟

هڪ صف هڪ ئي قسم جي عناصر جو هڪ ترتيب ڏنل سيٽ آهي، ابتدائي يا حوالو. arrays بابت عام معلومات (اڪثر ڪري هڪ طرفي) مضمون ۾ ڳولهي سگهجي ٿي “ Arays in Java ” ۽ JavaRush ڪورس ۾ . هن آرٽيڪل ۾ اسان انهن صفن بابت ڳالهائينداسين جن جا عنصر ٻيا صفا آهن. اهڙين صفن کي ملٽي ڊيمانشنل چئبو آهي. هڪ اهڃاڻ جنهن جا عنصر ٻيا هجن، يعني صفن جي هڪ صف، کي ٻه طرفي چئبو آهي. نه سڀئي ٻوليون ملٽي ڊئمنشنل ايريون هن طرح ٺهيل آهن، پر جاوا ۾ اهو معاملو آهي.

جاوا ملٽي ڊيمانشنل آري، جنرل نحو

عام طور تي، جاوا ۾ گھڻائي واريون صفون هن طرح نظر اچن ٿا:

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

شايد اهو سڀ ڪجهه بلڪل تجريدي نظر اچي ٿو، تنهنڪري هاڻي اچو ته اڳتي وڌون ڪنڪريٽ مظهر جي گهڻ طرفي صفن ڏانهن - ٻه طرفي ۽ ٽي جہتي. حقيقت اها آهي ته جاوا ڊولپرز ڪڏهن ڪڏهن ٻه-dimensional arrays استعمال ڪندا آهن، گهڻو ڪري گهٽ - ٽي-dimensional وارا، ۽ اڃا به وڏا صفون انتهائي ناياب آهن. اتي هڪ اعلي امڪان آهي ته توهان انهن کي منهن نه ڪندا.

هڪ ٻه-dimensional جاوا صف ڇا آهي؟

جاوا ۾ هڪ ٻه-dimensional صف آهي arrays جو هڪ صف، اهو آهي، هر سيل ۾ هڪ صف جو حوالو آهي. پر ان کي ٽيبل جي صورت ۾ پيش ڪرڻ تمام آسان آهي جنهن ۾ قطارن جو تعداد (پهريون طول و عرض) ۽ ڪالمن جو تعداد (ٻيو طول) آهي. هڪ ٻه-dimensional صف جنهن ۾ سڀني قطارن ۾ عنصرن جو هڪ جيتري تعداد آهي مستطيل سڏيو ويندو آهي.

اعلان ڪرڻ، ٺاھڻ ۽ شروع ڪرڻ ٻه-dimensional arrays

هڪ ٻه-dimensional صف جو اعلان ۽ ٺاھڻ جو طريقو لڳ ڀڳ ساڳيو آهي جيئن هڪ-dimensional جي صورت ۾:

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

ھن صف ۾ 3 قطارون ۽ 4 ڪالمن آھن. هڪ مستطيل ٻه-dimensional صف جي سائيز (اهي شايد مستطيل نه هجن، وڌيڪ هيٺ ڏنل تي)، يعني عناصر جو ڪل تعداد قطارن جي تعداد کي ڪالمن جي تعداد سان ضرب ڪندي طئي ڪري سگهجي ٿو. اهو هاڻي شروع ڪيو ويو آهي (ڀريل) ڊفالٽ قدرن سان. يعني صفر. اچو ته ان کي ڀريون انھن قدرن سان جن جي اسان کي ضرورت آھي.

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;

جيئن ته هڪ-dimensional arrays سان، توهان شروعاتي عمل کي تيز ڪري سگهو ٿا:

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

ٻنهي صورتن ۾، اسان کي ٽن قطارن ۽ چار ڪالمن سان گڏ هڪ ٻه-dimensional صف ملندي، عددن سان ڀريل.

اسڪرين تي ٻه-dimensional صف ڏيکاريندي

هن آپريشن کي ڪرڻ جو سڀ کان وڌيڪ منطقي طريقو اهو آهي ته پهرين صفر لائن عنصر کي عنصر جي ذريعي، پوء ٻيو، وغيره. جاوا ۾ ٻه-dimensional صف کي ٻاھر ڪڍڻ لاء سڀ کان وڌيڪ عام طريقو آھي ٻه nested loops استعمال ڪرڻ.

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
        }

هڪ ٻه-dimensional صف جي تيز پيداوار

اسڪرين تي ٻه-dimensional صف جي عناصر جي فهرست کي ڊسپلي ڪرڻ جو مختصر ترين طريقو استعمال ڪرڻ آهي deepToStringclass method 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]]

"ڊگهي" هڪ ٻه-dimensional صف جي

ھڪڙي طول و عرض واري صف جي ڊگھائي حاصل ڪرڻ لاء (يعني ان ۾ عناصر جو تعداد)، توھان استعمال ڪري سگھو ٿا variable length. اهو آهي، جيڪڏهن اسان هڪ آري جي وضاحت ڪريون ٿا 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 تنھنڪري ھي آپريشن صف ۾ قطارن جو تعداد ڪڍي ٿو. ڪالمن جو تعداد ڪيئن حاصل ڪجي؟ جيڪڏهن اسان مستطيل ٻه-dimensional arrays سان ڊيل ڪري رهيا آهيون (يعني اهي جن ۾ سڀئي لائينون هڪجهڙيون ڊگھيون هونديون آهن) ته پوءِ اسان آپريشن لاڳو ڪري سگهون ٿا twoDimArray[0].lengthيا صفر عنصر جي بدران (ضروري طور تي صفر لڪير) - ڪنهن ٻئي موجود هڪ. اسان اهو ڪري سگهون ٿا ڇاڪاڻ ته جاوا ۾، هڪ ٻه-dimensional arrays جي هڪ صف آهي، ۽ عنصر صفر twoDimArray[0]4 جي ڊيگهه جي هڪ صف آهي. توهان ان کي پاڻ چيڪ ڪري سگهو ٿا.

هڪ ٻه-dimensional صف استعمال ڪرڻ جو مثال: checkerboard

ٻه-dimensional arrays استعمال ڪري سگھجن ٿا ڪو به محدود ٻه-dimensional ميدان ٺاهڻ لاءِ، مثال طور راندين ۾، ۽ خاص طور تي شطرنج ۾. اهو آسان آهي ته هڪ شطرنج جي تختي کي ٻه طرفي صف وانگر سوچڻ. توھان ھن سان گرافڪس "منسلڪ" ڪري سگھو ٿا، پر ھاڻي، اچو ته علامتون استعمال ڪندي شطرنج جو تختو بيان ڪريون ۽ ان کي ڪنسول ڏانھن ٻاھر ڪڍون. شطرنج جي تختي جي هيٺان کاٻي چورس ڪارو رنگ ڪيو ويو آهي، اڳيان هڪ اڇو آهي، جيئن ان جي مٿان هڪ آهي. تنهن ڪري، رنگ بدلجي ٿو هر وقت جڏهن توهان پاسي جي ڀرسان سيل ڏانهن وڃو. شطرنج جي رنگ کي دستي طور تي نه، پر هڪ الگورٿم استعمال ڪندي، توهان برابري چيڪ استعمال ڪري سگهو ٿا: جيڪڏهن قطار ۽ ڪالمن جي انڊيڪس جو مجموعو برابر يا صفر آهي، ته سيل اڇو ٿيندو، ٻي صورت ۾ اهو ڪارو ٿيندو. ھن چيڪ لاءِ، اسين استعمال ڪريون ٿا باقي آپريٽر % الورورٿم ۾. جيئن ته اسان گرافڪس سان نه، پر علامتن سان ڪم ڪري رهيا آهيون، اسان اڇو سيل کي اکر 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";
            }
        }

پروگرام جو نتيجو هيٺ ڏنل آهي : WBWBWBBBWBBWBWBBWBBWBBWBBWBBBWBBBWBBWBBBBWBBBWBBW ھاڻي اچو ته سيلز جي صحيح انگن اکرن لاءِ طريقه ڪار جي ٻوليءَ ۾ نه پر ”شطرنج“ ٻوليءَ ۾ لکون. بورڊ تي هيٺئين کاٻي سيل کي 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 B4B4B4B44444 d 3 Be3 Wf3 Bg3 Wh3 Wa2 Bb2 Wc2 Bd2 We2 Bf2 Wg2 Bh2 Ba1 Wb1 Bc1 Wd1 Be1 Wf1 Bg1 Wh1 جتي We2مطلب آھي اڇو چورس نمبر e2.

ٻه-dimensional صف استعمال ڪرڻ جو مثال: ميٽرڪس ضرب

ڌيان!ھن مثال کي ميٽرڪ جي بنيادي ڄاڻ جي ضرورت آھي. هتي انهن جي باري ۾ تمام گهٽ چيو ويندو، ۽ اها معلومات انهن لاءِ آهي جن اڀياس ڪيو آهي، پر ڪجهه وساري ڇڏيو آهي، ميٽرڪس رياضي. بهرحال، هي علم کليل ذريعن مان حاصل ڪري سگهجي ٿو، خاص طور تي وڪيپيڊيا تي هڪ مضمون مان . هي ٻه-dimensional arrays استعمال ڪرڻ جو هڪ سٺو مثال آهي، پر اسان ان جي بغير اڳتي وڌي سگهون ٿا. تنهن ڪري جيڪڏهن اهو لڳي ٿو ته هاڻي توهان کي رياضياتي نقطي نظر کان، ۽ توهان واقعي ان ۾ شامل ٿيڻ نٿا چاهيو، مثال کي ڇڏڻ لاء آزاد محسوس ڪريو. جيڪڏهن توهان بنيادي لڪير واري الجبرا جو مطالعو ڪيو آهي، ته توهان شايد مستطيل ماپن جي طور تي مستطيل صفن جي باري ۾ سکيو هوندو. جتي 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

غير مستطيل ٻه-dimensional arrays

جيئن ته جاوا ۾ ٻه-dimensional arrays arrays آهن، ان ڪري هر هڪ اندروني صف مختلف ڊگھائي ٿي سگهي ٿي. جڏهن هڪ صف ٺاهي، اسان صرف قطارن جو تعداد بيان ڪري سگهون ٿا ۽ نه ڪالمن جو تعداد (جيڪو حقيقت ۾، انهن ساڳين قطارن جي ڊيگهه آهي). اچو ته هڪ مثال ڏسو.

//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 اھڙيء طرح، اسان جي صف جي زيروٿ لائن ۾ شامل آھي array {1,2,3,4,5}، ۽ چوٿين لڪير ۾ صف شامل آھي {1}.

جاوا ۾ ٽي-dimensional arrays

عام فهم ۽ جاوا ٻوليءَ جي منطق جي پٺيان، هڪ ٽي-dimensional array کي سڏيو وڃي ٿو " arrays of arrays" يا "اهڙو صف جنهن جو هر عنصر هڪ ٻه-dimensional array آهي." ان کان سواء، اهي ٻه-dimensional 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];

پر گهڻو ڪري عملي طور تي ٽي-dimensional arrays آهن جن ۾ سڀني ٽن مقدارن کي هڪ ئي وقت ۾ بيان ڪيو ويو آهي، مستطيل ٻه-dimensional arrays جو هڪ اينالاگ. جيئن اسان اڳ ۾ ئي ذڪر ڪيو آهي، ٽي-dimensional يا وڌيڪ arrays تمام گهٽ استعمال ٿيندا آهن. تنهن هوندي، توهان 3D صف سان ڪجهه دلچسپ پروگرام ڪري سگهو ٿا. مثال طور، هڪ گهڻ-ماڙ ڪار پارڪ. هر منزل کي ٻه-dimensional صف سمجهي سگهجي ٿو، ۽ پارڪنگ جي جڳهه کي هڪ مخصوص عنصر سمجهي سگهجي ٿو ٽي-dimensional صف جو. اهڙي قسم جي هڪ عنصر جي نمائندگي ڪري سگهجي ٿو هڪ قسم جي 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();
            }
        }

دلچسپ مسئلا ٻه-dimensional ۽ ٽي-dimensional arrays تي

توھان جاوا ۾ گھڻائي جہتي صفن جي باري ۾ ڪافي ڄاڻو ٿا ۽، جيڪڏھن توھان اعتماد محسوس ڪريو، توھان ھيٺ ڏنل ڪجھ مسئلن کي حل ڪرڻ جي ڪوشش ڪري سگھو ٿا. اهي آسان نه آهن، پر دلچسپ. ٽڪ ٽيڪ ٽو. ھڪڙو 3x3 فيلڊ سيٽ ڪريو، ٻه رانديگر ٺاھيو جيڪي موڙ وٺندا آھن. شروعات ۾، فيلڊ خالي آهي، ۽ هر هڪ خالي ميدان ۾ پهريون رانديگر هڪ ڪراس وجهي سگهي ٿو، ۽ ٻيو هڪ صفر. فاتح اهو آهي جيڪو پهريون ڀيرو ٽي ڪراس يا ٽي صفر گڏ ڪري هڪ قطار، هڪ ڪالمن يا ترڪي ۾ ترتيب ڏنل. لانگٽن جي چيلي اتي ھڪڙو خاص ميدان آھي، جيڪو سيلن ۾ ورهايل آھي (ھڪ ٻه-dimensional صف)، رنگيل ڪارو يا اڇو (ھڪ بي ترتيب واري فنڪشن سان سيٽ ڪري سگھجي ٿو). هڪ ”چين“ بي ترتيب طور تي ڪنهن هڪ خاني ۾ مادي ٿيندي آهي، ۽ هر قدم تي اها چئن طرفن مان ڪنهن هڪ ۾ ويجھي سيل ڏانهن، افقي يا عمودي طور تي منتقل ٿي سگهي ٿي. ڪتن جي حرڪت جا ضابطا:

• ڪارو چورس تي، چيٽي کي 90° کاٻي طرف ڦيرايو وڃي، ان جي سيل جو رنگ اڇي ۾ تبديل ڪريو، پوءِ ايندڙ چورس ڏانھن اڳتي وڌو.
• هڪ سفيد چورس تي، چيٽي 90° ساڄي طرف ڦري ٿي ۽ پنهنجي سيل جو رنگ ڪارا ڪري ٿي، پوءِ اڳتي هلي ايندڙ چورس ڏانهن.

ھڪڙو طريقو لکو جيڪو ڳڻپيوڪر جي قدم نمبر تي nاينٽي جي شروعاتي پوزيشن ڏني وئي آھي. فيلڊ کي بي ترتيب طور تي زيرو ۽ وارن سان ڀريو وڃي ٿو (يا اکر W۽ B، جيئن اسان شطرنج جي تختي جي مثال ۾ ڪيو آهي). اسان کي ٻه وڌيڪ پيرا ميٽرن جي ضرورت آهي - ڪتي جي افقي ۽ عمودي پوزيشن، انهي سان گڏ هن قدم تي ان جي هدايت (اتر، ڏکڻ، اولهه، اوڀر)، جڏهن ته ڊفالٽ طور تي اينٽي اتر ڏسڻ ۾ اچي ٿي. توھان ڪوشش ڪري سگھو ٿا ھڪڙي Rubik's cube کي ماڊل ڪرڻ لاءِ ٽي-dimensional arrays استعمال ڪندي. هڪ معياري Rubik's cube ۾ 6 منهن آهن، ۽ انهن مان هر هڪ رنگين چوڪن جي هڪ ٽي-dimensional صف آهي Color[][][] rubik = new Color[6][3][3]. بهرحال، هڪ Rubik جي ڪعب تي عمل ڪرڻ هڪ معمولي ڪم نه آهي.

صفن بابت مفيد مواد

JavaRush تي ڪيترائي آرٽيڪل صفن لاءِ وقف ٿيل آهن (خاص طور تي هڪ طرفي آهن، ڇاڪاڻ ته اهي گهڻو ڪري عملي طور تي استعمال ٿيندا آهن). انهن تي ڌيان ڏيو.

1. جاوا ۾ صفون - مثالن سان شروعات ڪندڙن لاءِ صفن بابت
2. Arrays بابت ڪجھ - arrays تي سٺو تفصيلي مضمون
3. Arrays ڪلاس ۽ ان جو استعمال - مضمون ڪلاس جا ڪجھ طريقا بيان ڪري ٿوArray
4. Arrays پهريون JavaRush ليڪچر آهي جيڪو arrays لاءِ وقف ڪيو ويو آهي.
5. صفر-لمبائي واري صف کي واپس ڏيو، خالي نه - اثرائتو پروگرامنگ ليکڪ جوشوا بلوچ انهي بابت ڳالهائي ٿو ته ڪيئن بهتر طور تي خالي صفن کي واپس ڪجي