جاوا پروگرام فيڪٽري لاء

اڄ اسان حقيقتن جي باري ۾ ڳالهائڻ وارا آهيون ۽ حقيقت کي ڳولڻ جا سڀ کان وڌيڪ عام طريقا. اهو سڀ کان وڌيڪ بنيادي ڪمن مان هڪ آهي جيڪو هڪ پروگرامر ٻنهي کي ڄاڻڻ ۽ ڪم ڪرڻ جي قابل هوندو. خير، اچو ته شروع ڪريون. 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.

بار بار حل

Recursion ٿئي ٿو جڏهن هڪ طريقو پاڻ کي سڏي ٿو. اهڙي طريقي کي ٻيهر ورجائيندڙ طريقو سڏيو ويندو آهي. ضابطي جي طور تي، اهو ٻن حصن تي مشتمل آهي:

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 آهي، ۽ ضرب() استعمال ڪيو ويندو آهي پوئين فڪري قدر ۽ موجوده نمبر کي ضرب ڪرڻ لاءِ.

بار بار حل

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 ۾ تبديل ڪرڻ لاءِ ته پوءِ انهن کي ضرب ڪرڻ جو طريقو استعمال ڪندي پاڻ سان ضرب ڪيو (۽ حاصل () اختياري ريپر مان اعتراض حاصل ڪرڻ لاءِ شامل ڪيو ويو ). جيڪڏهن اسان انهن ٽن طريقن مان ڪنهن کي 100 جي دليل سان هلون ٿا، ته پوءِ اسان هڪ اسٽيڪ اوور فلو کان پاسو ڪنداسين ۽ صحيح نتيجو حاصل ڪنداسين: