جاوا ۾ ورجائي

سمجھڻ لاءِ ته ورجائي ڇا آھي، توھان کي سمجھڻ جي ضرورت آھي ته ورجائي ڇا آھي. حقيقت ۾، اهڙن ڪمن کي سمجهڻ ۾ ڪا به ڏکيائي ناهي؛ توهان کي صرف هڪ ڀيرو چڱي طرح سمجهڻ جي ضرورت آهي. ۽ مشق ڪريو جڏهن اهو پروگرامنگ جي اچي ٿي. ورجائي نه رڳو پروگرامنگ ۾، پر حقيقي زندگي ۾ پڻ. پنهنجي هٿن ۾ هڪ آئينو وٺو ۽ ٻئي آئيني جي سامهون بيٺو. انعڪاس ۾ به عڪاسي ۽ ان جي ابتڙ. توھان ڏسندؤ ته لامحدود تعداد جي عڪاسي لاتعداد ۾ وڃي ٿي. توهان مضمون ۾ "حقيقي" ورهاڱي بابت وڌيڪ ڳولي سگهو ٿا " گرائونڊ هوگ ڊي لاءِ وقف ٿيل... " اچو ته حقيقي دنيا مان موٽون هڪ پروگرامر جي روزاني زندگي ڏانهن. سادي وصف: جاوا ۾ ٻيهر ورجائيندڙ افعال اهي فنڪشن آهن جيڪي پاڻ کي سڏين ٿا. مان توهان کي هڪ تمام سادو ۽ تمام نقصانڪار مثال ڏيان ٿو:

public void recursionFucn() {
    System.out.println("Привет, JavaRush!");
    recursionFucn();
}

اهو نقصانڪار ڇو آهي؟ مان صلاح ڏيان ٿو ته توهان پاڻ کي چيڪ ڪريو! جيڪڏهن توهان هن ايڊونچر کي کڻڻ جو فيصلو ڪيو (۽ توهان گهڻو ڪري سگهو ٿا، توهان پروگرامر!)، تبصرن ۾ لکو ته JVM ڪهڙي غلطي ڪندو =) اهو مثال، ۽ ٻيا ڪيترائي، اهو ظاهر ڪن ٿا ته جاوا ۾ ريٽرنشن جي استعمال کي احتياط سان رابطو ڪيو وڃي. . توهان کي اهو سمجهڻ جي ضرورت آهي ته ڪٿي، ڪڏهن ۽ ڇو اهڙي طريقي سان مسئلو حل ڪرڻ جو جواز آهي، ۽ پڪ ڪريو ته توهان جو فنڪشن پروگرام جي عمل کي "گرائونڊ هوگ ڊي" ۾ تبديل نه ڪري. ورهاڱي کي سمجهڻ لاءِ ٻه وڌيڪ اهم معنائون آهن:

• ورهاڱي جو بنياد - بار بار ڪالن جي بلاڪ مان نڪرڻ جي شرط - مسئلي جو بنيادي حل، حالتن جي تحت جڏهن ٻيهر ڪال ڪرڻ جي ضرورت ناهي.
• ورهاڱي وارو قدم اهو آهي جڏهن هڪ فنڪشن پاڻ کي سڏيندو آهي جڏهن پيٽرول تبديل ڪندي.

ريٽورسو فنڪشن استعمال ڪرڻ جو هڪ شاندار مثال هڪ عدد جي فڪري حساب سان آهي. جيڪڏهن توهان وساري ڇڏيو، مون کي توهان کي ياد ڏيارڻ ڏيو: هڪ مثبت عدد جو فڪري N(N جي طور تي ظاهر ڪيو ويو آهي!) انگن جي پيداوار آهي 1 до N: N! = 1 * 2 * 3 * … (N - 1) * N. اهڙي طرح، وصف جي لحاظ کان صفر جو فيڪٽري 1 جي برابر آهي. تنهن ڪري فيڪٽري ڪنهن به مثبت عدد ۽ صفر لاءِ ڳولي سگهجي ٿو (رياضي جي ٻولي ۾ - غير منفي عددن جي سيٽ لاءِ يا قدرتي انگن جي سيٽ لاءِ ۽ ٻُڙي). منهنجو خيال آهي ته توهان سمجھو ٿا ته توهان لوپ استعمال ڪندي فيڪٽري پروگرام ڪري سگهو ٿا. دراصل، هتي هن مسئلي کي حل ڪرڻ لاء هڪ غير ورهاست وارو طريقو آهي:

private int fact(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result = result * i;
    }
    return result;
}

اچو ته هڪ چيڪ شامل ڪريو ته نمبر مثبت آهي ۽ هڪ عدد، ۽ صفر لاءِ الڳ چيڪ.

private int fact(int n) {
    if (n < 0) {
        System.out.println("Зачем тебе факториал из отрицательного числа?");
         return null;
    }
    int result = 1;
    if (n == 0) {
        return result;
    }
    for (int i = 1; i <= n; i++) {
        result = result * i;
    }
    return result;
}

هاڻي آئون هن مسئلي کي ٻيهر حل ڪرڻ لاءِ طريقو ڪوڊ ڏيندس:

private int factorial(int n) {
    int result = 1;
    if (n == 1 || n == 0) {
        return result;
    }
    result = n * factorial(n-1);
    return result;
}

اچو ته ڪالن جي نتيجن کي ڏسو:

System.out.println(factorial(0));
System.out.println(factorial(1));
System.out.println(factorial(2));
System.out.println(factorial(3));
System.out.println(factorial(4));
System.out.println(factorial(5));
System.out.println(factorial(6));

اسان کي متوقع قدر ملن ٿا:

1
1
2
6
24
120
720

اچو ته هڪ سٺي پيداوار شامل ڪريون ۽ وڏي انگ لاءِ فيڪٽري جي حساب ڪريون:

private int factorial(int n) {
    int result = 1;

    if (n == 0) {
        System.out.print(" = ");
        return result;
    }
    if (n == 1) {
        System.out.print(" * 1 = ");
        return result;
    }

    System.out.print(n);
    if (n != 2) {
        System.out.print(" * ");
    }

    result = n * factorial(n-1);
    return result;
}


System.out.println(factorial(15) + "!");

اسان حاصل ڪريون ٿا: 15 * 14 * 13 * 12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1 = 1 307 674 368 000! هن صورت ۾، هڪ ورجائيندڙ فنڪشن جو استعمال جائز ۽ محفوظ آهي. اسان واضح طور تي بيان ڪيو آهي ته ريٽرننگ بلاڪ مان نڪرڻ جي شرط، ۽ اسان کي يقين آهي ته اهو حاصل ڪري سگهجي ٿو: اسان هڪ غير منفي عدد نمبر داخل ڪيو، جيڪڏهن اهو نمبر صفر يا هڪ جي برابر آهي، اسان نتيجو واپس آڻينداسين، جيڪڏهن نمبر وڏو آهي. ، اسان نتيجو کي ضرب ڪريون ٿا عدد جي فنڪشن سان n-1. ٽن جي حقيقت کي استعمال ڪندي مثال طور:

factorial(3) внутри себя выполнит следующее:
	result = 3 * factorial(2); (рекурсивный вызов)

	factorial(2) внутри себя выполнит следующее:
		result = 2 * factorial(1); (рекурсивный вызов)

		factorial(1) вернет 1 (базис рекурсии)

	factorial(2) вернет 2 * 1

factorial(3) вернет 3 * 2 * 1

استعمال ۾ احتياط جي حوالي سان: هن فنڪشن جي ڪمزوري ڇا آهي؟ جيڪڏهن توهان هڪ طريقو ڏيو هڪ منفي نمبر هڪ پيٽرولر جي طور تي، پوء چيڪ ڪريو

if (n == 1 || n == 0) {
    return result;
}

ڪو به احساس نه آهي ۽ اسان پاڻ کي سڏڻ جي لامحدود چڪر ۾ ختم ٿي وينداسين. اهو غير منفي لاء چيڪ شامل ڪرڻ جي قابل آهي:

if (n < 0) {
	System.out.println(«Зачем тебе факториал отрицательного числа?»);
	return null;
}

۽ سڀ ٺيڪ ٿي ويندو. هڪ طريقي جو ٻيو فائدو ڇا آهي؟ ائين نه ٿو لڳي ته ڪو وڏو فرق آهي، پر حقيقت ۾، ڪيترن ئي ريٽرسي ڪالز جو ڪارڪردگي ۽ ميموري جي استعمال تي منفي اثر پوندو: ڪال اسٽيڪ هڪ لڳ ڀڳ اڻ ڪنٽرول وسيلو آهي ۽ مختلف حالتن ۾ ساڳئي ريٽرسو فنڪشن کي ڪال ڪرڻ لاءِ، اسان شايد هن وسيلن سان لاڳاپيل مسئلا حاصل ڪري سگهون ٿا يا نه. تقريباً سڀئي مسئلا حل ڪيا ويا استعمال ڪندي استعمال ڪندي (چڪر وانگر for-each) پڻ حل ڪري سگھجن ٿا بار بار. ورهاڱي جو فائدو پڙهڻ جي قابليت ۽ لکڻ ۾ آساني آهي، اسان مٿي ڄاڻايل نقصانن بابت ڳالهايو آهي: ”پنهنجي پيرن ۾ گولي هڻڻ“ جو موقعو غلط ناهي. توهان کي اڃا به وڌيڪ محتاط رهڻ جي ضرورت آهي جڏهن نام نهاد ”پيچيده ورهاڱي“ استعمال ڪيو وڃي ٿو: هڪ فنڪشن A()هڪ فنڪشن کي سڏيندو B()جيڪو هڪ فنڪشن کي سڏيندو آهي A(). اهڙن مسئلن کي حل ڪرڻ لاء مڪمل سمجھڻ جي ضرورت آهي ته ريٽرنيشن ڪيئن ڪم ڪري ٿو. اهڙي ڪم جو هڪ مثال: جي قدر جي حساب سان x^n/(n!). فڪري، جيئن اسان مٿي ذڪر ڪيو، غير منفي عددن جي سيٽ تي بيان ڪيو ويو آهي. آخرڪار، آئون حل ڪوڊ ڏيندس. ڪمپليڪس ورجائي ٻن طريقن تي مشتمل هوندي:

private double calculate(int x, int n) {
    return power(x, n) / n;
}
private double power(int x, int n) {
    if (n == 1) return x;
    return x * calculate(x, n - 1);
}

recursion داخل ڪرڻ لاء، هڪ طريقو استعمال ڪيو ويندو آهي calculate، جيڪو هڪ طريقو سڏيندو آهي power، جنهن جي نتيجي ۾ هڪ طريقو سڏيندو آهي calculate. اسان طاقت جي طريقي ۾ ورهاڱي جي بنياد کي بيان ڪيو:

if (n == 1) return x;

ورهاڱي وارو قدم به اتي بيان ڪيو ويو آهي:

return x * calculate(x, n - 1);

ان پٽ ڊيٽا جي صحيحيت لاءِ چيڪ شامل ڪرڻ باقي رهي ٿو:

• صفر کان سواءِ ٻيو ڪو به عدد صفر جي طاقت جي برابر آهي 1. جيڪڏهن n = 0، پوء n! = 1. ان کي واپس ڪرڻ جي ضرورت آهي 1.
• ڪنهن به طاقت لاءِ صفر صفر جي برابر آهي.
• اسان قسم جي غير يقيني صورتحال تي غور نه ڪنداسين 0^0۽ اهڙي ان پٽ ڊيٽا کي غلط طور تي قبول ڪنداسين.

سڀني چيڪن سان، طريقا هن طرح نظر ايندا:

private double calculate(int x, int n) throws ArithmeticException {
    if (x == 0 && n == 0) {
        throw new ArithmeticException("Невалидные входные данные: Неопределенность типа 0^0");
    }

    if (n < 0) {
        throw new ArithmeticException("Невалидные входные данные: Факториал из отрицательного числа!");
    }

    if (n == 0) {
        return 1;
    }

    if (x == 0) {
        return 0;
    }

    if (x == 0) {
        return 0;
    }
    return power(x, n) / n;
}

private double power(int x, int n) {
    if (n == 1) return x;
    return x * calculate(x, n - 1);
}

خير، جڏهن هڪ فنڪشن کي سڏيندي، توهان کي ياد رکڻ گهرجي ته غلطي کي پڪڙڻ لاء:

try {
    System.out.println(calculate(x, n));
} catch (ArithmeticException e) {
    System.out.println(e.getMessage());
}