फैक्टोरियल के लिए जावा प्रोग्राम

आज हम फैक्टोरियल्स और फैक्टोरियल खोजने के सबसे सामान्य तरीकों के बारे में बात करने जा रहे हैं। यह सबसे बुनियादी कार्यों में से एक है जिसे एक प्रोग्रामर को जानना और उसके साथ काम करने में सक्षम होना चाहिए। खैर, चलिए शुरू करते हैं। संख्या 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;
}

यहां कुछ भी मुश्किल नहीं है: हम पारित संख्या का उपयोग अपने पाश के आकार के रूप में करते हैं, जिसमें हम पिछली सभी संख्याओं से गुणा करते हैं जब तक कि हम एफ तक नहीं पहुंच जाते। और मुख्य में:

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();
  }
}

यहां हम विशेष इंटस्ट्रीम वर्ग का उपयोग करते हैं, जो हमें इंट मूल्यों की धारा के साथ काम करते समय अतिरिक्त क्षमता प्रदान करता है। इस तरह की एक स्ट्रीम बनाने के लिए, हम इसकी स्टैटिक रेंजक्लोज्ड विधि का उपयोग करते हैं, जो 2 से f तक के मान उत्पन्न करती है, जिसमें 1 की वृद्धि शामिल है। इसके बाद, हम सभी मानों को संयोजित करने के लिए कम करने की विधि का उपयोग करते हैं। अधिक विशेष रूप से, हम यह दिखाते हैं कि हम मूल्यों को कैसे संयोजित करना चाहते हैं। अंत में, हम टर्मिनल getAsInt विधि का उपयोग करके परिणामी मान प्राप्त करते हैं।

बिगइंटीजर का उपयोग करना

जावा में, BigInteger वर्ग का उपयोग अक्सर संख्याओं को संभालने के लिए किया जाता है, विशेष रूप से BIG संख्याओं के लिए। दरअसल, अगर हम int का उपयोग करते हैं , तो अधिकतम फैक्टोरियल जिसे हम डेटा हानि के बिना संभाल सकते हैं, वह 31 है। लंबे डेटा प्रकार के लिए, अधिकतम फैक्टोरियल 39 है। लेकिन क्या होगा अगर हमें 100 के फैक्टोरियल की आवश्यकता है? आइए पिछले समाधानों को BigInteger के अनुकूल बनाएं।

साधारण उपाय

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 में कन्वर्ट करने के लिए करते हैं ताकि मल्टीप्लाई मेथड का उपयोग करके उन्हें खुद से मल्टीप्लाय किया जा सके (और get() ऑप्शनल रैपर से ऑब्जेक्ट प्राप्त करने के लिए जोड़ा गया था )। यदि हम इन तीन विधियों में से कोई भी 100 के तर्क के साथ चलाते हैं, तो हम स्टैक ओवरफ़्लो से बचेंगे और सही परिणाम प्राप्त करेंगे: