फॅक्टोरियलसाठी जावा प्रोग्राम

आज आपण फॅक्टोरियल आणि फॅक्टोरियल शोधण्याच्या सर्वात सामान्य मार्गांबद्दल बोलणार आहोत. हे सर्वात मूलभूत कार्यांपैकी एक आहे जे प्रोग्रामरला माहित असणे आणि कार्य करण्यास सक्षम असणे आवश्यक आहे. बरं, चला सुरुवात करूया. 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 पास करतो).

एक प्रवाह सह उपाय

Java च्या स्ट्रीम कार्यक्षमतेशी अपरिचित असलेले कोणीही, किंवा ज्याला त्यांची मेमरी रीफ्रेश करायची आहे, त्यांना येथे वाचून फायदा होईल .

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 वर्ग वापरतो, जे इंट मूल्यांच्या प्रवाहासह कार्य करताना आम्हाला अतिरिक्त क्षमता देते. असा प्रवाह तयार करण्यासाठी, आम्ही त्याची स्थिर श्रेणी बंद पद्धत वापरतो, जी 2 ते f, समावेशक, 1 च्या वाढीमध्ये मूल्ये निर्माण करते. पुढे, आम्ही सर्व मूल्ये एकत्र करण्यासाठी कमी पद्धत वापरतो. अधिक विशिष्‍टपणे, आम्‍हाला मूल्ये कशी एकत्र करायची आहेत ते आम्ही दाखवतो. शेवटी, टर्मिनल getAsInt पद्धत वापरून आम्हाला परिणामी मूल्य मिळते.

BigInteger वापरणे

Java मध्ये, 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 आहे, आणि 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 सह. स्ट्रीम क्लास आम्हाला mapToObj पद्धत देतो, जी आम्ही int व्हॅल्यूजला BigInteger मध्ये रूपांतरित करण्यासाठी वापरतो आणि नंतर गुणाकार पद्धतीचा वापर करून गुणाकार करतो (आणि पर्यायी रॅपरमधून ऑब्जेक्ट मिळवण्यासाठी get() जोडले होते ). जर आपण या तीन पद्धतींपैकी कोणतीही 100 च्या युक्तिवादाने चालवली, तर आपण स्टॅक ओव्हरफ्लो टाळू आणि योग्य परिणाम मिळवू: