جاوا پروگرامنگ میں فیکٹریل

آج ہم فیکٹریل کے بارے میں بات کریں گے۔ یہ سب سے بنیادی افعال میں سے ایک ہے جو ایک پروگرامر کو جاننے کی ضرورت ہے، اور ساتھ ہی ساتھ اس کے ساتھ کام کرنے کے قابل بھی ہے۔ تو آئیے شروع کرتے ہیں۔ n کا فیکٹوریل 1 سے n تک کے تمام قدرتی اعداد کی مصنوع (ضرب) کی قدر ہے، جسے n کے طور پر ظاہر کیا جاتا ہے! یہ کیسا لگتا ہے:

1! =  1
2! =  1 * 2 = 2
3! =  1 * 2 * 3 = 6
4! =  1 * 2 * 3 * 4 = 24
5! =  1 * 2 * 3 * 4 * 5  = 120

اور ایک اور چھوٹا اصول، 0 کے لیے:

!0  = 1

اگر ہم چاہتے ہیں، مثال کے طور پر، فیکٹریل فرق 6 حاصل کرنا! اور 4!:

6!-4! = 1⋅2⋅3⋅4⋅5⋅6 - 1⋅2⋅3⋅4 = 720 - 24 = 696

آئیے اس پر ایک نظر ڈالیں کہ یہ جاوا میں کیسا نظر آئے گا اور کئی طریقوں کو سمجھیں جن میں فیکٹریل کا حساب لگایا جا سکتا ہے۔

معمول کا حل

public static int getFactorial(int f) {
  int result = 1;
  for (int i = 1; i <= f; i++) {
     result = result * i;
  }
  return result;
}

کچھ بھی پیچیدہ نہیں: ہم موصولہ نمبر کو اپنے سائیکل کے سائز کے طور پر استعمال کرتے ہیں، جس میں ہم تمام پچھلے نمبروں سے اس وقت تک ضرب کرتے ہیں جب تک کہ ہم f تک نہ پہنچ جائیں۔ اور بنیادی طور پر:

System.out.println(getFactorial(6) - getFactorial(4));

ہم چیک کرتے ہیں اور مطلوبہ نتیجہ حاصل کرتے ہیں: 696۔

تکراری حل

Recursion اپنے آپ پر ایک طریقہ کو بلا کر کچھ منطق کر رہا ہے۔ اس طریقہ کو تکراری کہا جاتا ہے۔ عام طور پر یہ دو حصوں پر مشتمل ہوتا ہے:

1. طریقہ سے باہر نکلنے کی حالت، جس تک پہنچنے پر طریقہ کو خود کو کال کرنا بند کر دینا چاہیے اور اقدار کو اوپر کرنا شروع کر دینا چاہیے۔ بصورت دیگر، ہمیں اپنے طور پر ایک طریقہ کو کال کرنے سے ایک لامحدود لوپ ملے گا اور اس کے نتیجے میں، StackOverflowError ۔

2. کسی مخصوص صورتحال میں کچھ پروسیسنگ (منطق) ضروری ہے + خود کو کال کرنا، لیکن آنے والی مختلف قدر کے ساتھ۔

آج کی تکرار کے لیے ہماری مثالی مثال فیکٹریل تلاش کر رہی ہے:

public static int getFactorial(int f) {
  if (f <= 1) {
     return 1;
  }
  else {
     return f * getFactorial(f - 1);
  }
}

ہم تکرار سے باہر نکلنے کی شرط اس وقت مقرر کرتے ہیں جب یہ 1 تک پہنچ جاتا ہے۔ اگر دلیل 1 نہیں ہے، تو ہم موجودہ قیمت کو اس طریقہ کے اگلے کال کے نتیجے سے ضرب دیتے ہیں (جہاں ہم موجودہ قدر -1 بھیجتے ہیں)۔

اسٹریم کے ساتھ حل

ان لوگوں کے لیے جو اسٹریم کی فعالیت کو نہیں جانتے یا ان لوگوں کے لیے جو اپنی یادداشت کو تازہ کرنا چاہتے ہیں، یہ پڑھنا مفید ہوگا ۔

public static int getFactorial(int f) {
  if (f <= 1) {
     return 1;
  }
  else {
     return IntStream.rangeClosed(2, f).reduce((x, y) -> x * y).getAsInt();
  }
}

یہاں ہم ایک خاص کلاس IntStream استعمال کرتے ہیں، جو int اقدار سے سلسلہ کے ساتھ کام کرتے وقت اضافی صلاحیتیں فراہم کرتا ہے۔ اس طرح کے سلسلے کو بنانے کے لیے، ہم اس کا جامد طریقہ رینج کلوزڈ استعمال کرتے ہیں، جو 1 کے قدم کے ساتھ 2 سے f تک کی قدریں بناتا ہے۔ اس کے بعد، ہم تمام اقدار کو کم کرنے کا طریقہ استعمال کرتے ہوئے یکجا کرتے ہیں، یعنی ہم اس میں دکھاتے ہیں کہ کیسے ہم ان کو جوڑنا چاہتے ہیں۔ آخر میں، ہمیں getAsInt ٹرمینل طریقہ کا استعمال کرتے ہوئے نتیجے کی قدر ملتی ہے۔

BigInteger استعمال کرنا

جاوا میں، BigInteger کلاس اکثر نمبروں کو ہینڈل کرنے کے لیے استعمال ہوتی ہے، خاص طور پر BIG نمبرز ۔ سب کے بعد، اگر ہم int استعمال کرتے ہیں، تو زیادہ سے زیادہ فیکٹوریل جو ہم ڈیٹا کو کھونے کے بغیر لے سکتے ہیں 31، طویل عرصے کے لیے - 39۔ لیکن اگر ہمیں 100 کے فیکٹریل کی ضرورت ہو تو کیا ہوگا؟ آئیے پچھلے حلوں کو دیکھتے ہیں، لیکن BigInteger کا استعمال کرتے ہوئے.

معمول کا حل

public static BigInteger getFactorial(int f) {
  BigInteger result = BigInteger.ONE;
  for (int i = 1; i <= f; i++)
     result = result.multiply(BigInteger.valueOf(i));
  return result;
}

گنتی کا الگورتھم بنیادی طور پر ایک جیسا ہے، لیکن یہاں ہم BigInteger کی صلاحیتوں کو استعمال کرتے ہیں: BigInteger.ONE - ابتدائی قدر کو 1 پر سیٹ کرنے کے لیے۔ ضرب - سابقہ ​​فیکٹوریل ویلیو اور موجودہ نمبر کے درمیان ضرب۔

تکراری حل

public static BigInteger getFactorial(int f) {
  if (f <= 1) {
     return BigInteger.valueOf(1);
  }
  else {
     return BigInteger.valueOf(f).multiply(getFactorial(f - 1));
  }
}

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

اسٹریم کے ساتھ حل

public static BigInteger getFactorial(int f) {
  if (f < 2) {
     return BigInteger.valueOf(1);
  }
  else {
     return IntStream.rangeClosed(2, f).mapToObj(BigInteger::valueOf).reduce(BigInteger::multiply).get();
  }
}

بنیادی طور پر سب کچھ ایک جیسا ہے، لیکن BigInteger کے ساتھ۔ سٹریم میں اب ہمارے پاس mapToObj طریقہ ہے، جس کی مدد سے ہم int ویلیوز کو BigInteger میں تبدیل کرتے ہیں تاکہ بعد میں multiply کا استعمال کرتے ہوئے ان کو ایک ساتھ ضرب کیا جا سکے (اچھی طرح سے، ہم نے اختیاری ریپر سے کسی چیز کو حاصل کرنے کے لیے شامل کیا ہے )۔ اگر ہم دلیل 100 کے ساتھ ان تین طریقوں میں سے کسی کو چلاتے ہیں، تو ہمارے پاس اوور فلو نہیں ہوگا اور ہمیں ملے گا:

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000