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

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

فیکٹریل پروگرام میں عام حل

لوپ کا استعمال کرتے ہوئے یہاں ایک سادہ فیکٹریل پروگرام ہے:

class FactorialExample{
 public static void main(String args[]){
  int i,fact=1;
  int number=7;// our number to do the necessary calculations in class Factorial
  for(i=1;i<=number;i++){
      fact=fact*i;
  }
  System.out.println("Factorial of "+number+" is: "+fact);
 }
}

کنسول پر ہماری آؤٹ پٹ ہوگی: اور چیزوں کو ترتیب دینے کے لیے ایک اور مثال:

public static int getFactorial(int f) {
  int result = 1;
  for (int i = 1; i <= f; i++) {
     result = result * i; // finding factorial of number using loops
  }
  return result;
}

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

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

کوڈ کی جانچ کرتے ہوئے، ہم دیکھتے ہیں کہ ہمیں مطلوبہ نتیجہ ملتا ہے: 696۔

تکراری حل

تکرار اس وقت ہوتی ہے جب کوئی طریقہ خود کو کال کرتا ہے۔ اس طرح کے طریقہ کار کو تکراری طریقہ کہا جاتا ہے۔ ایک اصول کے طور پر، یہ دو حصوں پر مشتمل ہے:

1. ختم ہونے والی شرط — جب ختم ہونے والی شرط مطمئن ہو جاتی ہے، تو طریقہ کو خود کو کال کرنا بند کر دینا چاہیے اور اقدار کو بڑھانا شروع کر دینا چاہیے۔ آخر کار، اگر کوئی ختم ہونے والی شرط نہیں ہے، تو ہمارے پاس ایک لامحدود لوپ ہوگا، طریقہ کار خود کو بار بار کال کرتا ہے جب تک کہ ہمیں StackOverflowError حاصل نہ ہو جائے ۔
2. صورتحال کے لیے جو بھی منطق درکار ہے اس کے علاوہ ایک بار بار آنے والی کال، لیکن ایک مختلف ان پٹ ویلیو کے ساتھ۔

جاوا میں فیکٹریل تلاش کرنا اس بات کی ایک بہترین مثال ہے کہ تکرار کا استعمال کب کرنا ہے:

public static int getFactorial(int f) { // finding factorial of number using recursive solution
  if (f <= 1) {
     return 1;
  }
  else {
     return f * getFactorial(f - 1);
  }
}

ہماری تکرار ختم ہونے والی حالت تب ہو گی جب ہم 1 تک پہنچ جائیں گے۔ اگر پیرامیٹر 1 نہیں ہے، تو ہم موجودہ قیمت کو اگلے ریکسریو کال کے نتیجے کے طریقہ کار سے ضرب دیتے ہیں (جس سے ہم موجودہ قدر مائنس 1 کو پاس کرتے ہیں)۔

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

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

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

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

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

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

عام حل

public static BigInteger getFactorial(int f) { // finding factorial of number using BigInteger
  BigInteger result = BigInteger.ONE;
  for (int i = 1; i <= f; i++)
     result = result.multiply(BigInteger.valueOf(i));
  return result;
}

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

تکراری حل

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 کے ساتھ۔ Stream کلاس ہمیں mapToObj طریقہ فراہم کرتی ہے، جسے ہم int ویلیوز کو BigInteger میں تبدیل کرنے کے لیے استعمال کرتے ہیں تاکہ ضرب کا طریقہ استعمال کرتے ہوئے انہیں اپنے ساتھ ضرب کر سکیں (اور اختیاری ریپر سے کسی چیز کو حاصل کرنے کے لیے get() کو شامل کیا گیا تھا)۔ اگر ہم ان تین طریقوں میں سے کسی کو 100 کی دلیل کے ساتھ چلاتے ہیں، تو ہم اسٹیک اوور فلو سے بچیں گے اور صحیح نتیجہ حاصل کریں گے: