CodeGym /جاوا بلاگ /Random-UR /جبکہ بیان
John Squirrels
سطح
San Francisco

جبکہ بیان

گروپ میں شائع ہوا۔
ہمارے پہلے ہی پروگرام ہدایات کا ایک سلسلہ تھا جو یکے بعد دیگرے عمل میں لایا جاتا ہے۔ کوئی کانٹے نہیں۔ اس میں HelloWorld شامل ہے، جو ایک سلام دکھاتا ہے۔ اس میں ریاضی کے حسابات شامل ہیں۔ اپنے پہلے پروگراموں کے بعد، ہم نے سیکھا کہ کس طرح برانچ کرنا ہے، یعنی کسی پروگرام کو مخصوص حالات کے لحاظ سے مختلف اعمال انجام دینے کا طریقہ۔ مرکزی حرارتی اور ایئر کنڈیشنگ سسٹم کو کنٹرول کرنے کا کوڈ یہ ہے:
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فرض کریں کہ آپ کے پاس دس سیب، دو ہاتھ اور ایک چاقو ہے۔ حقیقی زندگی میں، آپ ترتیب وار ہر ایک سیب کے لیے ایک ہی الگورتھم پر عمل کرتے ہوئے پوری درجن کو چھیلتے ہیں۔ لیکن ہم ایک پروگرام کو ہر ایک سیب کے لیے دہرانے والا عمل کیسے کر سکتے ہیں؟
  • ہم اپنے آپ کو سیبوں کی تعداد کے ساتھ باندھتے ہیں، لیکن اگر ہمارے پاس ان میں سے کافی نہیں ہے، تو پھر کچھ کمانڈز بغیر کسی "پے لوڈ" کے عمل میں لائی جائیں گی (اور ہم ایک غیر موجود سیب کو چھیلنے کی کوشش کرتے ہوئے خود کو کاٹ سکتے ہیں)۔
  • اگر چھیلنے کے حکم سے زیادہ سیب موجود ہیں، تو کچھ سیبوں کو بغیر چھلکے چھوڑ دیا جائے گا۔
  • اس طرح کے کوڈ کو پڑھنا مشکل ہے۔ اس میں بہت ساری تکرار ہیں اور اس میں ترمیم کرنا مشکل ہے۔

لوپس وہ بیانات ہیں جو اعمال کو بار بار انجام دینے کی اجازت دیتے ہیں۔

جاوا کا while لوپ ہمارے معاملے میں اچھی طرح کام کرے گا۔ یہ تعمیر متعدد اعمال کو ایک جامع اور قابل فہم ڈھانچے میں رکھتا ہے۔ تھوڑی دیر کے لوپ کا استعمال کرتے ہوئے ، پائی کے لیے ایپل سلائسنگ الگورتھم جاوا میں اس طرح نظر آسکتا ہے:
while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    arrangeInPie(apple.peel().slice());
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
}
System.out.println("The apples for the pie have been processed.");

کمانڈ نحو

دوران بیان کی پہلی قسم اس طرح ہے:
while (Boolean expression) {
	// Loop body — the statement(s) that are repeatedly executed
}
یہاں ایک مرحلہ وار وضاحت ہے کہ جب اس کوڈ کو عمل میں لایا جاتا ہے تو کیا ہوتا ہے:
  1. ہم while کلیدی لفظ کے بعد قوسین میں پائے جانے والے بولین اظہار کا جائزہ لیتے ہیں ۔
  2. اگر بولین ایکسپریشن درست پر تشخیص کرتا ہے، تو لوپ باڈی میں بیانات کو انجام دیا جاتا ہے۔ لوپ باڈی میں آخری بیان پر عمل درآمد کے بعد، پھر ہم مرحلہ 1 پر جاتے ہیں۔
  3. اگر بولین ایکسپریشن غلط پر تشخیص کرتا ہے، تو ہم while لوپ کے بعد پہلے بیان پر جائیں گے ۔

ایک پیشگی شرط کے ساتھ لوپ

چونکہ ہم لوپ باڈی کو انجام دینے سے پہلے ہمیشہ بولین ایکسپریشن (لوپ میں داخل ہونے کی شرط) کا جائزہ لیتے ہیں ، اس لیے جب لوپ کی اس شکل کو اکثر شرط کے ساتھ لوپ کہا جاتا ہے ۔ آئیے ایک عدد کی پہلی دس طاقتوں کا جدول بنائیں:
public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (exponent <= 10) { // The condition for entering the loop
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
    }
}
کنسول آؤٹ پٹ:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

پوسٹ کنڈیشن کے ساتھ لوپ کریں۔

اس لوپ کی دوسری قسم یہ ہے:
do {
    // Loop body — the statement(s) that are repeatedly executed
} while (Boolean expression);
یہاں اس کی وضاحت ہے کہ جب اس کوڈ پر عمل درآمد ہوتا ہے تو کیا ہوتا ہے:
  1. لوپ باڈی کو عمل میں لایا جاتا ہے ( ڈو کی ورڈ کے فوراً بعد)۔
  2. ہم while کلیدی لفظ کے بعد قوسین میں پائے جانے والے بولین اظہار کا جائزہ لیتے ہیں ۔
  3. اگر بولین ایکسپریشن کا درست اندازہ ہوتا ہے، تو ہم مرحلہ 1 پر جائیں گے۔
  4. اگر بولین ایکسپریشن غلط پر تشخیص کرتا ہے، تو ہم while لوپ کے بعد پہلے بیان پر جائیں گے ۔
پچھلے لوپ سے دو اہم فرق یہ ہیں: 1) لوپ باڈی کو کم از کم ایک بار عمل میں لایا جاتا ہے اور 2) لوپ باڈی پر عمل درآمد کے بعد بولین ایکسپریشن کا جائزہ لیا جاتا ہے۔ اس کے مطابق، اس قسم کے while لوپ کو پوسٹ کنڈیشن والا لوپ کہا جاتا ہے ۔ اس بار ہم ایک عدد کی طاقتوں کا ایک جدول دکھائیں گے جو 10000 سے زیادہ نہیں ہے:
public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = base; // The result of exponentiation
    int exponent = 1; // The initial exponent
    do {
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        result = result * base;
    } while (result < 10000); // The condition for exiting the loop
}
کنسول آؤٹ پٹ:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
Process finished with exit code 0
کوڈ میں تبدیلیوں پر توجہ دیں۔ اس کا موازنہ پیشگی شرط کے ساتھ لوپ سے کریں۔

لوپس کے ساتھ کام کرنے کے بارے میں دلچسپ حقائق

لوپ باڈی کے اندر برانچنگ بیانات

دو بیانات ہیں جو ایک لوپ کے اندر عملدرآمد کو متاثر کرتے ہیں: وقفہ (جس پر ہم اگلے باب میں مزید تفصیل سے بات کریں گے) اور جاری رہے.
  • جاری رکھیں — موجودہ تکرار میں لوپ باڈی کے بقیہ حصے پر عمل درآمد کو چھوڑ دیتا ہے اور جب بیان کے بولین اظہار کی تشخیص پر چھلانگ لگاتا ہے۔ اگر اظہار درست ہونے کا اندازہ لگاتا ہے، تو لوپ جاری رہتا ہے۔
  • بریک - موجودہ تکرار کے عمل کو فوری طور پر ختم کرتا ہے اور لوپ کے بعد پہلے بیان میں کنٹرول منتقل کرتا ہے۔ اس طرح، یہ بیان موجودہ لوپ پر عمل درآمد کو ختم کرتا ہے۔ ہم اگلے مضمون میں اس پر مزید تفصیل سے غور کریں گے۔
ہمارے پھل کی مثال کو یاد کریں۔ اگر ہمیں سیب کے معیار کے بارے میں یقین نہیں ہے، تو ہم جاری بیان کا استعمال کرتے ہوئے کوڈ کو تبدیل کر سکتے ہیں:
while (numberOfApplesInBowl > 0) {
    apple = bowl.grabNextApple();
    numberOfApplesInBow--; // "--" is the decrement operator, which reduces the number of apples by one
    if (apple.isBad()) { // This method returns true for rotten apples
        apple.throwInGarbage();
        continue; // Continue the loop. Jump to evaluation of numberOfApplesInBowl > 0
    }
    arrangeInPie(apple.peel().slice());
}
جاری بیان اکثر اس وقت استعمال ہوتا ہے جب لوپ باڈی میں بیانات کو عمل میں لانے کی ضرورت ہوتی ہے اگر کوئی خاص شرط مطمئن ہو ۔ مثال کے طور پر، ہم ہارڈویئر سینسر کے متحرک ہونے پر کارروائیاں کرنا چاہتے ہیں (بصورت دیگر، صرف اس لوپ کو جاری رکھیں جس میں ہم سینسر ریڈنگ لیتے ہیں) یا ہم صرف ایک لوپ کے مخصوص تکرار پر اظہار کا حساب لگانا چاہتے ہیں۔ مؤخر الذکر صورت کی ایک مثال قدرتی اعداد کے کیوبز کے مجموعے کا حساب لگانے کے لیے a while loop کے استعمال میں دیکھی جا سکتی ہے جن کا مربع نمبروں کی تعداد سے کم ہے۔ الجھن میں؟ درج ذیل کوڈ کو چیک کریں:
public static void main(String[] args) {
    int sum = 0;  // Total amount
    int i = 0;  // Initial number in the series
    int count = 20;  // Number of numbers
    while (i <= count) {
        i++;  // Get the next number — "i++" is equivalent to "i = i + 1"
        if (i * i <= count)  // If the square of the number is less than
            continue;  // the number of numbers, then we won't calculate the sum
                            // Jump to the next number in the loop
        sum += i * i * i;  // Otherwise, we calculate the sum of the cubes of numbers
    }  // "sum += i * i * i" is notation that is equivalent to "sum = sum + i * i * i"
    System.out.println(sum);  // Print the result
}

لامحدود لوپ

یہ برانچنگ اسٹیٹمنٹ اکثر لامحدود لوپس میں استعمال ہوتے ہیں۔ ہم لوپ کو لامحدود کہتے ہیں اگر لوپ سے باہر نکلنے کی بولین شرط کبھی مطمئن نہیں ہوتی ہے۔ کوڈ میں، یہ کچھ اس طرح لگتا ہے:
while (true) {
    // Loop body
}
اس صورت میں، ایک وقفہ بیان ہمیں لوپ سے باہر نکلنے میں مدد کرتا ہے۔ اس قسم کا لوپ موزوں ہے جب لوپ کے جسم سے باہر طے شدہ بیرونی حالات کا انتظار کیا جائے۔ مثال کے طور پر، آپریٹنگ سسٹمز یا گیمز میں (لوپ سے باہر نکلنے کا مطلب ہے گیم سے باہر نکلنا)۔ یا الگورتھم استعمال کرتے وقت جو کوشش کرتے ہیں، لوپ کے ہر تکرار کے ساتھ، کچھ نتیجہ کو بہتر بنانے کے لیے، لیکن گزرے ہوئے وقت یا کسی بیرونی واقعے کی موجودگی کی بنیاد پر تکرار کی تعداد کو محدود کرتے ہیں (جیسے چیکرز، شطرنج، یا موسم کی پیشن گوئی)۔ یاد رکھیں کہ عام حالات میں لامحدود لوپس مطلوبہ نہیں ہیں۔ ظاہر کرنے کے لیے، آئیے وضاحت پر واپس آتے ہیں:
public static void main(String[] args) {
    int base = 3; // The number that will be exponentiated
    int result = 1; // The result of exponentiation
    int exponent = 1; // The initial exponent
    while (true) {
        result = result * base;
        System.out.println(base + " raised to the power of " + exponent + " = " + result);
        exponent++;
        if (exponent > 10)
            break; // Exit the loop
    }
}
کنسول آؤٹ پٹ:
3 raised to the power of 1 = 3
3 raised to the power of 2 = 9
3 raised to the power of 3 = 27
3 raised to the power of 4 = 81
3 raised to the power of 5 = 243
3 raised to the power of 6 = 729
3 raised to the power of 7 = 2187
3 raised to the power of 8 = 6561
3 raised to the power of 9 = 19683
3 raised to the power of 10 = 59049
Process finished with exit code 0

نیسٹڈ لوپس

اور اب ہم آتے ہیں اپنے آخری موضوع پر لوپس پر۔ اس ایپل پائی کو یاد کریں (مجھے امید ہے کہ آپ اس وقت بھوکے نہیں ہوں گے) اور ہماری سیب چھیلنے والی لوپ:
  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 پر واپس جائیں۔
اب ہمارے پاس ایک لوپ کے اندر ایک لوپ ہے۔ اس طرح کی تعمیرات بہت عام ہیں۔ ایک آخری مثال کے طور پر، آئیے ضرب کی میزوں میں سے ایک بنائیں جسے ہم نے ابتدائی اسکول میں پیار کرنا سیکھا تھا۔
public static void main(String[] args) {
    // Print the second factors in a row
    System.out.println("    2  3  4  5  6  7  8  9");
    int i = 2;  // Assign the first factor to the variable
    while (i < 10) {  // First loop: execute as long as the first factor is less than 10
        System.out.print(i + " | ");  // Print the first factor at the beginning of the line
        int j = 2;  // The starting value of the second factor
        while (j < 10) { // Second loop: execute as long as the second factor is less than 10
            int product = i * j;  // Calculate the product of the factors
            if (product < 10)  // If the product is a single digit, then we print two spaces after the product
                System.out.print(product + "  ");
            else  // Otherwise, print the product and one space after it
                System.out.print(product + " ");
            j++;  // Increment the second factor by one
        }  // Go to the beginning of the second loop, i.e. "while (j < 10)"
        System.out.println();  // Move to the next line on the console
        i++;  // Increment the first factor by one
    } // Go to the beginning of the first loop, i.e. "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
لوپس (خاص طور پر، جبکہ بیان) سافٹ ویئر کے بنیادی تعمیراتی بلاکس میں سے ایک ہیں۔ CodeGym پر کاموں کو حل کرنے سے، آپ تمام مختلف قسم کے لوپس سیکھیں گے، ان کی پیچیدگیوں کو سمجھیں گے، اور انہیں استعمال کرنے میں عملی مہارت حاصل کریں گے۔
تبصرے
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION