JavaRush /جاوا بلاگ /Random-SD /جڏهن ته جاوا ۾ لوپ

جڏهن ته جاوا ۾ لوپ

گروپ ۾ شايع ٿيل

تعارف

اسان جا پھريون پروگرام ھدايتن جو ھڪڙو سلسلو ھو، جن تي ھڪ ٻئي پٺيان عمل ڪيو ويو. نه ڪانٽو. هي هيلو ورلڊ آهي، جيڪو ڪنسول ڏانهن هڪ سلامي جملي ۽ رياضي جي حسابن کي ڪڍي ٿو. پھرين پروگرامن کان پوءِ، اسان برانچ ڪرڻ سيکاريو، يعني پروگرام حالتن جي لحاظ کان ڪجھ ڪم سرانجام ڏيندو ھو. ھتي آھي توھان ڪيئن ڪوڊ ڪري سگھوٿا ايئر ڪنڊيشنر کي گرم ڪرڻ ۽ کولڻ لاءِ آن ڪرڻ لاءِ:
if (tempRoom>tempComfort)
    airConditionerOn();
if (tempRoom<tempComfort
    heaterOn();
اچو ته ايندڙ قدم کڻون. روزمره جي زندگي ۾، اسان اڪثر ڪري هڪ غير معمولي، بار بار ڪارناما ڪندا آهيون، مثال طور، هڪ پائي لاء سيب کي ڇڪڻ. هن دلچسپ عمل کي بيان ڪري سگهجي ٿو:
  1. جيڪڏهن بيسن ۾ سيب آهن، ته پوءِ 1.1 کان 1.4 تائين عمل ڪريو:

    1. 1.1. هڪ انب وٺو
    2. 1.2. صاف ڪريو ۽ ان کي سلائسن ۾ ڪٽيو
    3. 1.3. هڪ فرائينگ پين ۾ پيسٽري پائي جي بنياد تي رکو
    4. 1.4. اچو ته واپس قدم 1 ڏانھن وڃو.
آپريٽر جڏهن - 2
اچو ته توهان وٽ 10 انب، 2 هٿ ۽ هڪ چاقو آهي. زندگي ۾، توهان مسلسل سڄي ڏهن کي صاف ڪيو، ساڳئي الگورتھم جي هدايت ڪئي وئي. توهان پروگرام کي ڪيئن ٺاهي سگهو ٿا هر ايپل سان ٻيهر ورجائي عمل؟
  • اچو ته پاڻ کي انب جي تعداد تي پابند ڪريون، پر جيڪڏهن اسان وٽ انهن مان ٿورڙا آهن، ته ڪجهه حڪمن تي عمل ڪيو ويندو بغير ڪنهن "پيلوڊ" (۽، شايد، اسان پاڻ کي ڪٽي ڇڏيندا آهيون جڏهن غير موجود انب کي ڇڪيندا آهيون).
  • جيڪڏهن اسان جي پروسيسنگ ٽيمن کان وڌيڪ سيب آهن، ڪجهه پراڊڪٽس اڻ پروسيس ٿي ويندا.
  • اهڙو ”ڪوڊ“ پڙهڻ ڏکيو آهي، ان ۾ ڪيترائي ورجايل آهن، ۽ تبديل ڪرڻ ڏکيو آهي.

لوپ آپريٽر آهن ڪيترن ئي ڀيرا ڪم ڪرڻ لاءِ.

جاوا جڏهن لوپ (وائل لوپ) اسان جي صورت ۾ سٺو ڪم ڪري ٿو. هي ڊزائن ڪيترن ئي ڪارناما کي هڪ جامع ۽ سمجھڻ واري جوڙجڪ ۾ منظم ڪري ٿو. جاوا ۾ پائي لاءِ ايپل سلائينگ ڪرڻ لاءِ ڪجهه وقت الورورٿم هن طرح نظر اچي سگهي ٿو:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    положитьВПирог(яблоко.чистить().нарезать());
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
}
System.out.println('Apples for the pie are processed.');

حڪم نحو

جڏهن ته بيان بيان ڪرڻ جو پهريون طريقو هن ريت آهي:
while(Логическое выражение) {
	// Loop body - periodically executed statement(s)
}
اهو هن ريت ڪيو ويو آهي (قدم سان):
  1. اسان Boolean حالت جو جائزو وٺون ٿا جيڪو بعد ۾ قوس ۾.
  2. جيڪڏهن منطقي حالت صحيح آهي، ته پوءِ لوپ باڊي ۾ آپريٽرز تي عمل ڪيو ويندو آهي، لوپ باڊي ۾ آخري آپريٽر تي عمل ڪرڻ کان پوءِ، قدم 1 ڏانهن وڃو
  3. جيڪڏهن منطقي حالت غلط آهي، ته پوء پهرين بيان ڏانهن وڃو جڏهن لوپ کان ٻاهر.

اڳڪٿي سان لوپ

جيئن ته لوپ جي جسم تي عمل ڪرڻ کان اڳ، اسان هميشه هڪ منطقي اظهار (لوپ ۾ داخل ٿيڻ جي شرط) جي اڳڪٿي ڪندا آهيون، هن قسم جي وقت کي اڪثر ڪري لوپ سڏيو ويندو آهي هڪ شرط سان. اچو ته پھرين ڏھن عددن جي جدول ٺاھيون، ھڪڙي عدد جي مثبت طاقت:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(power <= 10) { // loop entry condition
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
    }
}
ڪنسول ٻاھر نڪرڻ جو نتيجو:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

پوسٽ جي حالت سان لوپ

سائيڪل جو ٻيو قسم:
do {
    // Loop body - periodically executed statement(s)
}while (Логическое выражение);
ھيٺ ڏنل طريقي سان انجام ڏنو ويو آھي (قدم):
  1. لوپ جي جسم تي عمل ڪيو ويو آهي (فوري طور تي do keyword کان پوء).
  2. اسان Boolean حالت جو جائزو وٺون ٿا جيڪو بعد ۾ قوس ۾.
  3. جيڪڏهن منطقي حالت صحيح آهي، پوء قدم 1 ڏانهن وڃو
  4. جيڪڏهن منطقي حالت غلط آهي، ته پوء پهرين بيان ڏانهن وڃو جڏهن لوپ کان ٻاهر.
پوئين قسم جي لوپ کان ٻه مکيه فرق: لوپ جي جسم کي گهٽ ۾ گهٽ هڪ ڀيرو عمل ڪيو ويندو آهي ۽ لوپ جي جسم تي عمل ڪرڻ کان پوء منطقي حالت جي جانچ ڪئي ويندي آهي. تنهن ڪري، هن قسم جي لوپ کي پوسٽ ڪنڊيشن لوپ سڏيو ويندو آهي. هن ڀيري اسان 10000 کان وڌيڪ تعداد جي طاقتن جي جدول کي ڏيکارينداسين:
public static void main(String[] args) {
    int number = 3;// Number to be raised to a power
    int result = number;// Result of exponentiation
    int power = 1;// Initial exponent
    do {
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        result = result * number;
    }while (result < 10000); // loop exit condition
ڪنسول ٻاھر نڪرڻ جو نتيجو:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
Process finished with exit code 0
ڪوڊ ۾ تبديلين تي ڌيان ڏيو، ان جي مقابلي ۾ لوپ جي نسخي سان اڳوڻي شرط سان.

لوپ سان ڪم ڪرڻ بابت دلچسپ حقيقتون

لوپ جي جسم ۾ ڪنٽرول حڪم

اتي ٻه حڪم آھن جيڪي لوپ جي ترقي کي متاثر ڪن ٿا: وقف، خاصيتون جن کي اسين ايندڙ باب ۾ ڏيکارينداسين، ۽ جاري رکڻ.
  • جاري رکو - موجوده لوپ جي جسم جي عمل کي روڪي ٿو ۽ وقت آپريٽر جي منطقي اظهار ڏانهن منتقل ڪري ٿو. جيڪڏهن ڳڻپيوڪر اظهار صحيح آهي، لوپ جو عمل جاري رهندو.
  • وقفو - فوري طور تي موجوده لوپ جي عمل کي روڪي ٿو ۽ ان کان ٻاهر پهرين حڪم تي ٽپو ڏئي ٿو. اهڙيء طرح، موجوده لوپ جي عمل ۾ مداخلت ڪئي وئي آهي. اسان ان تي وڌيڪ تفصيل سان ايندڙ مضمون ۾ ڏسنداسين.
اچو ته اسان جي ميوو مثال کي ياد رکون. جيڪڏهن اسان کي پيش ڪيل سيب جي معيار جي باري ۾ پڪ ناهي، اسان حڪم استعمال ڪندي ڪوڊ تبديل ڪري سگهون ٿا continue:
while(числоЯблокВТазике>0) {
    яблоко = тазик.взятьОчередноеЯблоко();
    числоЯблокВТазике--;//-- this is a decrement, reduces the number of apples by one
    if (яблоко.плохое()) {  // method will return true for rotten, etc. apples
        яблоко.выкинутьВМусор();
        continue; // continue the loop, go to the condition number ofApplesIn the Basin>0
    }
    положитьВПирог(яблоко.чистить().нарезать());
}
تعمير continueاڪثر ڪري استعمال ڪيو ويندو آهي جڏهن لوپ جي جسم ۾ اهو ضروري آهي ته حڪمن تي عمل ڪرڻ لاء جڏهن هڪ خاص حالت ٿئي ٿي، مثال طور، ڪم ڪرڻ لاء جڏهن سامان ۾ هڪ سينسر شروع ٿئي ٿو (ٻي صورت ۾ صرف ان جي اشارن کي پڙهڻ جي چڪر کي جاري رکو) يا صرف چڪر جي ڪجهه مرحلن تي هڪ اظهار جي حساب ڪرڻ لاء. آخري صورت لاءِ هڪ مثال قدرتي انگن جي ڪعبن جي مجموعن جي ٿوري وقت جي لوپ ۾ حساب آهي جن جي چورس انهن جي تعداد کان گهٽ آهي:
public static void main(String[] args) {
    int sum = 0;    // total amount
    int i = 0;      // starting number of the row
    int count = 20; // amount of numbers
    while(i<=count) {
        i++;        // take the next number, i++ is equivalent to i=i+1
        if (i*i<=count)  // if the square of the number is less
            continue;   // number of numbers - do not count the sum
                        // move on to the next number in the loop
        sum += i*i*i; // otherwise, we calculate the sum of cubes of numbers
    } // sum += i*i*i - notation similar to sum = sum + i*i*i
    System.out.println(sum);// print result
}

لاتعداد چڪر

اهي ڪنٽرول حڪم اڪثر ڪري هڪ لامحدود لوپ ۾ استعمال ٿيندا آهن. ان کي سڏيو ويندو آهي ڇاڪاڻ ته منطقي نڪرڻ واري حالت ڪڏهن به مطمئن نه آهي. ڪوڊ ۾ اهو ڪجهه ڏسڻ جهڙو آهي:
while(true) {
    // Loop body
}
breakانهي حالت ۾، هڪ حڪم استعمال ڪندي ان مان نڪرڻ کي منظم ڪرڻ لاء ڪارائتو ٿيندو . هن قسم جو لوپ تڏهن ٿئي ٿو جڏهن ٻاهرين حالتن جو انتظار ڪيو وڃي جيڪي لوپ جي جسم جي منطق کان ٻاهر ٺهيل آهن. مثال طور، راندين ۾ جيڪي هيرو جي چوڌاري مجازي دنيا کي نقل ڪن ٿا (لوپ مان نڪرڻ = راند مان نڪرڻ)، آپريٽنگ سسٽم. يا جڏهن الورورٿم استعمال ڪري رهيا آهيو، شايد نتيجن کي بهتر ڪرڻ سان هر ايندڙ ڪال سان لوپ ۾، پر انهن کي وقت تائين محدود ڪري يا ڪنهن ٻاهرين واقعي جي واقعن (چيڪر، شطرنج يا موسم جي اڳڪٿي). اهو ياد رکڻ گهرجي ته عام حالتن ۾، لامحدود لوپ پروگرام جي عدم استحڪام جي مسئلن مان هڪ آهي. ظاھر ڪرڻ لاء، اچو ته انگن جي طاقت ڏانھن موٽون:
public static void main(String[] args) {
    int number = 3; // Number to be raised to a power
    int result = 1; // Result of exponentiation
    int power = 1; // Initial exponent
    while(true) {
        result = result * number;
        System.out.println(number + "to the extent" + power + " = " + result);
        power++;
        if (power>10)
            break; // exit from the loop
    }
}
ڪنسول ٻاھر نڪرڻ جو نتيجو:
3 в степени 1 = 3
3 в степени 2 = 9
3 в степени 3 = 27
3 в степени 4 = 81
3 в степени 5 = 243
3 в степени 6 = 729
3 в степени 7 = 2187
3 в степени 8 = 6561
3 в степени 9 = 19683
3 в степени 10 = 59049
Process finished with exit code 0

Nested Loops

هتي اسان پنهنجي سائيڪلن جي آخري موضوع تي اچون ٿا. اچو ته ايپل پائي بابت سوچيو (اميد آهي ته توهان هن وقت بکيو نه آهيو) ۽ اسان جي "لوپ":
  1. جيڪڏهن بيسن ۾ سيب آهن، قدمن تي عمل ڪريو 1.1 کان 1.4:

    1. 1.1. هڪ انب وٺو
    2. 1.2. صاف ڪريو ۽ ان کي سلائسن ۾ ڪٽيو
    3. 1.3. هڪ فرائينگ پين ۾ پيسٽري پائي جي بنياد تي رکو
    4. 1.4. اچو ته واپس قدم 1 ڏانھن وڃو.
اچو ته وڌيڪ تفصيل سان بيان ڪريون ته سلائسن ۾ ڪٽڻ جي عمل:
  1. سلائسن جو تعداد = 0
  2. جڏهن ته سلائسن جو تعداد <12 آهي، قدمن تي عمل ڪريو 2.1 کان 2.3 تائين

    1. 2.1. هڪ انب مان ٻيو ٽڪرو ڪٽيو
    2. 2.2. سلائسن جو تعداد ++
    3. 2.3. قدم 2 ڏانھن واپس وڃو
۽ ان کي اسان جي ڪنفيڪشنري الگورتھم ۾ داخل ڪريو:
  1. جيڪڏهن بيسن ۾ سيب آهن، ته پوءِ 1.1 کان 1.6 تائين عمل ڪريو:

    1. 1.1. هڪ انب وٺو
    2. 1.2. ان کي ڇڪيو
    3. 1.3. سلائسن جو تعداد = 0
    4. 1.4. Пока число долек < 12, выполнить шаги с 1.4.1 по 1.4.3
      1. 1.4.1. Отрезать очередную дольку от яблока
      2. 1.4.2. Кол-во долек ++
      3. 1.4.3. Возвращаемся на шаг 1.4
    5. 1.5. Помещаем дольки на тестовое основание пирога из теста на сковороде
    6. 1.6. Возвращаемся на шаг 1.
Получor цикл в цикле. Подобные конструкции весьма частые. Для завершающего примера построим таблицу умножения, которые школьники 90-х видели на обложках тетрадей в младших классах.
آپريٽر جڏهن ته - 3
public static void main(String[] args) {
    // Display the values ​​of the second multiplier in the line
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;      // first multiplier, assign starting value
    while(i<10) {   // First loop, execute while the first multiplier is less than 10
        System.out.print(i + " | ");// Display the first multiplier at the beginning of the string
        int j = 2;                  // second multiplier, starting value
        while (j<10) { // Second loop, execute while the second multiplier is less than 10
            int mul=i*j; // Calculate the product of factors
            if (mul<10)  // If it contains one digit, print two spaces after it
                System.out.print(mul + "  ");
            else   // otherwise output the product and after it - one space
                System.out.print(mul + " ");
            j++;     // Increase the second multiplier by one,
        }            // Go to the beginning of the second loop (while (j<10 ).... )
        System.out.println(); // Move to the next line of output
        i++;                  // Increase the first multiplier by one,
    }                         // Go to the beginning of the first loop (while ( i<10 ) ....
}
Результат вывода на консоль:
2  3  4  5  6  7  8  9
2 | 4 6 8 10 12 14 16 18
3 | 6 9 12 15 18 21 24 27
4 | 8 12 16 20 24 28 32 36
5 | 10 15 20 25 30 35 40 45
6 | 12 18 24 30 36 42 48 54
7 | 14 21 28 35 42 49 56 63
8 | 16 24 32 40 48 56 64 72
9 | 18 27 36 45 54 63 72 81
Process finished with exit code 0
Циклы (в частности, оператор while) – один из фундаментальных кирпичиков построения программ. Решая задачи на JavaRush, вы изучите все их разнообразие, разберёте тонкости функционирования и получите практические навыки их применения.
تبصرا
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION