جاوا پروگرامنگ ۾ فيڪٽري

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

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

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000