मुझे यह नहीं मिला, फिर भी। क्या मैं कुछ भुल गया? मुझे पता है कि एक भाज्य विधि शुरुआती लोगों के लिए एक सामान्य उदाहरण कार्यक्रम है। लेकिन फिर से उपयोग के लिए एक मानक कार्यान्वयन के लिए यह उपयोगी नहीं होगा? मैं मानक प्रकारों (जैसे। int, long ...) और BigInteger / BigDecimal के साथ भी इस तरह की विधि का उपयोग कर सकता हूं।
जवाबों:
मुझे नहीं लगता कि फैक्टरियल के लिए लाइब्रेरी फंक्शन होना उपयोगी होगा। कुशल तथ्यात्मक कार्यान्वयन में अनुसंधान का एक अच्छा सौदा है। यहाँ कुछ मुट्ठी भर कार्यान्वयन है।
Apache Commons Math की MathUtils वर्ग में कुछ गुटबाजी के तरीके हैं ।
public class UsefulMethods {
public static long factorial(int number) {
long result = 1;
for (int factor = 2; factor <= number; factor++) {
result *= factor;
}
return result;
}
}होल्डऑफ़हंगर द्वारा बिग नंबर संस्करण :
public static BigInteger factorial(BigInteger number) {
BigInteger result = BigInteger.valueOf(1);
for (long factor = 2; factor <= number.longValue(); factor++) {
result = result.multiply(BigInteger.valueOf(factor));
}
return result;
}व्यवहार में नंगे नग्न गुटों की शायद ही कभी आवश्यकता होती है। सबसे अधिक बार आपको निम्नलिखित में से एक की आवश्यकता होगी:
1) एक गुट को दूसरे द्वारा विभाजित करें, या
2) अनुमानित फ्लोटिंग-पॉइंट उत्तर।
दोनों ही मामलों में, आप सरल कस्टम समाधानों के साथ बेहतर होंगे।
मामले में (1), कहो, अगर x = 90! / 85!, तब आप परिणाम को x = 86 * 87 * 88 * 89 * 90 के रूप में गणना करेंगे, बिना 90 की आवश्यकता के! याद में :)
मामले में (2), "स्टर्लिंग के सन्निकटन" के लिए Google।
अमरूद का उपयोग BigIntegerMathइस प्रकार करें:
BigInteger factorial = BigIntegerMath.factorial(n);(के लिए इसी तरह की कार्यक्षमता intऔर longमें उपलब्ध है IntMathऔर LongMathक्रमशः।)
हालांकि factorials शुरुआत प्रोग्रामर के लिए एक अच्छा व्यायाम करते हैं, वे ज्यादातर मामलों में बहुत उपयोगी नहीं होते हैं , और सभी जानते हैं कि एक factorial फ़ंक्शन कैसे लिखना है, इसलिए वे आमतौर पर औसत पुस्तकालय में नहीं होते हैं।
मेरा मानना है कि लुकअप टेबल द्वारा यह सबसे तेज़ तरीका होगा:
private static final long[] FACTORIAL_TABLE = initFactorialTable();
private static long[] initFactorialTable() {
final long[] factorialTable = new long[21];
factorialTable[0] = 1;
for (int i=1; i<factorialTable.length; i++)
factorialTable[i] = factorialTable[i-1] * i;
return factorialTable;
}
/**
* Actually, even for {@code long}, it works only until 20 inclusively.
*/
public static long factorial(final int n) {
if ((n < 0) || (n > 20))
throw new OutOfRangeException("n", 0, 20);
return FACTORIAL_TABLE[n];
}देशी प्रकार long(8 बाइट्स) के लिए, यह केवल पकड़ कर सकता है20!
20! = 2432902008176640000(10) = 0x 21C3 677C 82B4 0000जाहिर है, 21!अतिप्रवाह का कारण होगा।
इसलिए, मूल प्रकार के लिए long, केवल अधिकतम की 20!अनुमति है, सार्थक है, और सही है।
क्योंकि factorial इतनी जल्दी बढ़ता है, अगर आप recursion का उपयोग करते हैं तो स्टैक ओवरफ़्लो कोई समस्या नहीं है। वास्तव में, 20 का मूल्य! एक जावा लंबे समय में सबसे बड़ा प्रतिनिधित्व कर सकता है। तो निम्न विधि या तो भाज्य (n) की गणना करेगी या यदि कोई बहुत बड़ी है, तो एक अवैध संबंध को फेंक दें।
public long factorial(int n) {
if (n > 20) throw new IllegalArgumentException(n + " is out of range");
return (1 > n) ? 1 : n * factorial(n - 1);
}एक और सामान करने का एक और (कूलर) तरीका यह है कि इस तरह से जावा 8 की स्ट्रीम लाइब्रेरी का उपयोग करें:
public long factorial(int n) {
if (n > 20) throw new IllegalArgumentException(n + " is out of range");
return LongStream.rangeClosed(1, n).reduce(1, (a, b) -> a * b);
}जावा 8 की धाराओं का उपयोग करते हुए Factorials पर अधिक पढ़ें
अपाचे कॉमन्स मैथ पैकेज में एक गुटीय विधि है , मुझे लगता है कि आप इसका उपयोग कर सकते हैं।
संक्षिप्त उत्तर है: पुनरावृत्ति का उपयोग करें।
आप एक विधि बना सकते हैं और उस पद्धति को पुन: उसी विधि के अंदर कॉल कर सकते हैं:
public class factorial {
public static void main(String[] args) {
System.out.println(calc(10));
}
public static long calc(long n) {
if (n <= 1)
return 1;
else
return n * calc(n - 1);
}
}System.out.println(calc(10));करने की कोशिश करें, System.out.println(calc(Long.MAX_VALUE));आपको बहुत लंबा स्टैक्ट्रेस मिलना चाहिए :)
BigInteger। मैंने उस संख्या के तथ्यात्मक की गणना करने की कोशिश की 8020जिसने मुझे परिणाम दिया 613578884952214809325384...जिसमें 27831दशमलव स्थान हैं। तो संख्याओं के साथ काम करते हुए भी, विशाल संख्या को Stackoverflowफेंका नहीं जाएगा। Ofcourse youre सही है, लेकिन मुझे संदेह है कि संख्याएँ हैं जो एक व्यावहारिक उपयोग के साथ बड़ी हैं :-)
इसे इस्तेमाल करे
public static BigInteger factorial(int value){
if(value < 0){
throw new IllegalArgumentException("Value must be positive");
}
BigInteger result = BigInteger.ONE;
for (int i = 2; i <= value; i++) {
result = result.multiply(BigInteger.valueOf(i));
}
return result;
}i <= value। फॉर-लूप को थोड़ा अनुकूलित किया जा सकता है (int i = 2; i <= value; i++)।
मुझे वास्तविक आधे हिस्से में फैक्टरियल खोजने के लिए एक अद्भुत चाल मिली।
कृपया धैर्य रखें क्योंकि यह एक लंबी पोस्ट का एक छोटा सा है।
सम संख्याओं के लिए: सम संख्याओं के गुणन को आधा करने के लिए, आप n / 2 कारकों को समाप्त करेंगे। पहला कारक वह संख्या होगी जिस पर आप की फैक्ट्री ले रहे हैं, फिर अगला नंबर माइनस दो होगा। अगला नंबर पिछली संख्या और अंतिम जोड़ी गई संख्या माइनस दो होगा। आपको तब किया जाता है जब आपने जो अंतिम संख्या जोड़ी थी, वह दो थी (यानी 2) । शायद इससे ज्यादा मतलब नहीं था, इसलिए मैं आपको एक उदाहरण देता हूं।
8! = 8 * (8 + 6 = 14) * (14 + 4 = 18) * (18 + 2 = 20)
8! = 8 * 14 * 18 * 20 which is **40320** ध्यान दें कि मैंने 8 से शुरू किया था, फिर मैंने जो पहली संख्या जोड़ी थी वह 6 थी, फिर 4, फिर 2, प्रत्येक संख्या को दो से कम जोड़ा जा रहा था, फिर इससे पहले की गयी संख्या। यह विधि सबसे बड़ी संख्या के साथ सबसे कम संख्या को गुणा करने के बराबर है, बस कम गुणा के साथ, जैसे:
8! = 1 * 2 * 3 * 4 * 5 * 6 * 7 *
8! = (1 * 8) * (2 * 7) * (3 * 6) * (4 * 5)
8! = 8 * 14 * 18 * 20सरल है ना :)
अब विषम संख्याओं के लिए: यदि संख्या विषम है, तो जोड़ना समान है, जैसा कि आप दो बार घटाते हैं, लेकिन आप तीन पर रुक जाते हैं। हालांकि कारकों की संख्या में परिवर्तन होता है। यदि आप संख्या को दो से विभाजित करते हैं, तो आप कुछ संख्या को 5 में समाप्त कर देंगे। कारण यह है कि अगर हम छोरों को एक साथ गुणा करते हैं, कि हम मध्य संख्या के साथ बचे हैं। मूल रूप से, यह दो द्वारा विभाजित संख्या के बराबर कई कारकों के लिए हल करके, हल किया जा सकता है। यह शायद गणितीय पृष्ठभूमि के बिना दिमाग के लिए बहुत मायने नहीं रखता था, इसलिए मुझे एक उदाहरण दें:
9! = 9 * (9 + 7 = 16) * (16 + 5 = 21) * (21 + 3 = 24) * (roundUp(9/2) = 5)
9! = 9 * 16 * 21 * 24 * 5 = **362880**नोट: यदि आपको यह विधि पसंद नहीं है, तो आप विषम (इस मामले में आठ) से पहले सम संख्या के भाज्य को भी ले सकते हैं और इसे विषम संख्या से गुणा कर सकते हैं (अर्थात ९! = *! * ९)।
अब इसे जावा में लागू करते हैं:
public static int getFactorial(int num)
{
int factorial=1;
int diffrennceFromActualNum=0;
int previousSum=num;
if(num==0) //Returning 1 as factorial if number is 0
return 1;
if(num%2==0)// Checking if Number is odd or even
{
while(num-diffrennceFromActualNum>=2)
{
if(!isFirst)
{
previousSum=previousSum+(num-diffrennceFromActualNum);
}
isFirst=false;
factorial*=previousSum;
diffrennceFromActualNum+=2;
}
}
else // In Odd Case (Number * getFactorial(Number-1))
{
factorial=num*getFactorial(num-1);
}
return factorial;
}isFirstएक बूलियन चर स्थिर के रूप में घोषित किया गया है; इसका उपयोग 1 मामले के लिए किया जाता है जहां हम पिछली राशि को बदलना नहीं चाहते हैं।
विषम संख्या के लिए भी प्रयास करें।
आप पुनरावर्तन का उपयोग कर सकते हैं।
public static int factorial(int n){
if (n == 0)
return 1;
else
return(n * factorial(n-1));
}और उसके बाद आप ऊपर विधि (कार्य) बनाएँ:
System.out.println(factorial(number of your choice));
//direct example
System.out.println(factorial(3));एक फैक्टरियल के लिए एकमात्र व्यावसायिक उपयोग जो मैं सोच सकता हूं कि एर्लांग बी और एर्लांग सी फॉर्मूला हैं, और हर कोई कॉल सेंटर या फोन कंपनी के लिए काम नहीं करता है। व्यवसाय के लिए एक सुविधा की उपयोगिता अक्सर यह तय करती है कि भाषा में क्या दिखाई देता है - सभी डेटा हैंडलिंग, एक्सएमएल और प्रमुख भाषाओं में वेब फ़ंक्शन देखें।
इस तरह के आसपास कुछ के लिए एक फैक्ट्री स्निपेट या लाइब्रेरी फ़ंक्शन रखना आसान है।
भाज्य गणना के लिए एक बहुत ही सरल विधि:
private double FACT(double n) {
double num = n;
double total = 1;
if(num != 0 | num != 1){
total = num;
}else if(num == 1 | num == 0){
total = 1;
}
double num2;
while(num > 1){
num2 = num - 1;
total = total * num2;
num = num - 1;
}
return total;
}मैंने डबल का उपयोग किया है क्योंकि वे बड़े पैमाने पर संख्या पकड़ सकते हैं, लेकिन आप किसी अन्य प्रकार जैसे इंट, लॉन्ग, फ्लोट आदि का उपयोग कर सकते हैं।
PS यह सबसे अच्छा समाधान नहीं हो सकता है, लेकिन मैं कोडिंग के लिए नया हूं और मुझे एक सरल कोड खोजने में उम्र लग गई, जिससे मैं तथ्यात्मक गणना कर सकता हूं इसलिए मुझे स्वयं विधि लिखनी थी लेकिन मैं इसे यहां डाल रहा हूं ताकि यह मेरे जैसे अन्य लोगों की मदद कर सके ।
आप पुनरावर्ती संस्करण का भी उपयोग कर सकते हैं।
static int myFactorial(int i) {
if(i == 1)
return;
else
System.out.prinln(i * (myFactorial(--i)));
}पुश और पॉप रिकर्स होने के कारण रिकर्सियन आमतौर पर कम कुशल होता है, इसलिए पुनरावृत्ति तेज होती है। दूसरी ओर, पुनरावर्ती संस्करण कम या कोई स्थानीय चर का उपयोग नहीं करते हैं जो कि लाभकारी है।
फैक्टरटायर अत्यधिक असतत कार्य कर रहा है। मुझे लगता है कि BigInteger का उपयोग करना int का उपयोग करने से बेहतर है। मैंने गैर-नकारात्मक पूर्णांक के भाज्य की गणना के लिए निम्नलिखित कोड लागू किया है। मैंने लूप का उपयोग करने के स्थान पर पुनरावर्तन का उपयोग किया है।
public BigInteger factorial(BigInteger x){
if(x.compareTo(new BigInteger("1"))==0||x.compareTo(new BigInteger("0"))==0)
return new BigInteger("1");
else return x.multiply(factorial(x.subtract(new BigInteger("1"))));
}यहाँ बड़े पूर्णांक की श्रेणी है
-2^Integer.MAX_VALUE (exclusive) to +2^Integer.MAX_VALUE,
where Integer.MAX_VALUE=2^31.हालाँकि, ऊपर दी गई फैक्टोरियल विधि की सीमा को अहस्ताक्षरित BigInteger का उपयोग करके दो बार तक बढ़ाया जा सकता है।
इसकी गणना करने के लिए हमारे पास एक पंक्ति है:
Long factorialNumber = LongStream.rangeClosed(2, N).reduce(1, Math::multiplyExact);एक काफी सरल विधि
for ( int i = 1; i < n ; i++ )
{
answer = answer * i;
} /**
import java liberary class
*/
import java.util.Scanner;
/* class to find factorial of a number
*/
public class factorial
{
public static void main(String[] args)
{
// scanner method for read keayboard values
Scanner factor= new Scanner(System.in);
int n;
double total = 1;
double sum= 1;
System.out.println("\nPlease enter an integer: ");
n = factor.nextInt();
// evaluvate the integer is greater than zero and calculate factorial
if(n==0)
{
System.out.println(" Factorial of 0 is 1");
}
else if (n>0)
{
System.out.println("\nThe factorial of " + n + " is " );
System.out.print(n);
for(int i=1;i<n;i++)
{
do // do while loop for display each integer in the factorial
{
System.out.print("*"+(n-i) );
}
while ( n == 1);
total = total * i;
}
// calculate factorial
sum= total * n;
// display sum of factorial
System.out.println("\n\nThe "+ n +" Factorial is : "+" "+ sum);
}
// display invalid entry, if enter a value less than zero
else
{
System.out.println("\nInvalid entry!!");
}System.exit(0);
}
}public static int fact(int i){
if(i==0)
return 0;
if(i>1){
i = i * fact(--i);
}
return i;
}हमें पुनरावृति को लागू करने की आवश्यकता है। यदि हम पुनरावर्ती रूप से लागू करते हैं, तो यह StackOverflow का कारण होगा यदि इनपुट बहुत बड़ा हो जाता है (अर्थात 2 बिलियन)। और हमें एक अनियंत्रित अतिप्रवाह से बचने के लिए बिगइंटर जैसे अनबाउंड आकार संख्या का उपयोग करने की आवश्यकता होती है, जब एक फैक्टरियल संख्या किसी दिए गए प्रकार की अधिकतम संख्या (यानी इंट के लिए 2 बिलियन) से बड़ी हो जाती है। आप अधिकतम 14 फैक्टरियल के लिए int का उपयोग कर सकते हैं और ओवरफ्लो से पहले अधिकतम 20 फैक्टरियल के लिए लंबे समय तक कर सकते हैं।
public BigInteger getFactorialIteratively(BigInteger input) {
if (input.compareTo(BigInteger.ZERO) <= 0) {
throw new IllegalArgumentException("zero or negatives are not allowed");
}
BigInteger result = BigInteger.ONE;
for (BigInteger i = BigInteger.ONE; i.compareTo(input) <= 0; i = i.add(BigInteger.ONE)) {
result = result.multiply(i);
}
return result;
}यदि आप BigInteger का उपयोग नहीं कर सकते हैं, तो एक त्रुटि जाँच जोड़ें।
public long getFactorialIteratively(long input) {
if (input <= 0) {
throw new IllegalArgumentException("zero or negatives are not allowed");
} else if (input == 1) {
return 1;
}
long prev = 1;
long result = 0;
for (long i = 2; i <= input; i++) {
result = prev * i;
if (result / prev != i) { // check if result holds the definition of factorial
// arithmatic overflow, error out
throw new RuntimeException("value "+i+" is too big to calculate a factorial, prev:"+prev+", current:"+result);
}
prev = result;
}
return result;
}जबकि लूप (छोटी संख्या के लिए)
public class factorial {
public static void main(String[] args) {
int counter=1, sum=1;
while (counter<=10) {
sum=sum*counter;
counter++;
}
System.out.println("Factorial of 10 is " +sum);
}
}पुनरावृत्ति के साथ:
public static int factorial(int n)
{
if(n == 1)
{
return 1;
}
return n * factorial(n-1);
}लूप के साथ:
public static int factorial1(int n)
{
int fact=1;
while(n>=1)
{
fact=fact*n;
n--;
}
return fact;
}प्रभावी बनाने के लिए गतिशील कार्यक्रम का उपयोग करना
यदि आप इसे बार-बार गणना करने के लिए उपयोग करना चाहते हैं (जैसे कैशिंग)
जावा कोड:
int fact[]=new int[n+1]; //n is the required number you want to find factorial for.
int factorial(int num)
{
if(num==0){
fact[num]=1;
return fact[num];
}
else
fact[num]=(num)*factorial(num-1);
return fact[num];
}पुनरावृत्ति का उपयोग करना सबसे सरल तरीका है। अगर हम एन के फैब्रिक को ढूंढना चाहते हैं, तो हमें उन दो मामलों पर विचार करना होगा जहां एन = 1 और एन> 1 है क्योंकि फैक्टरियल में हम एन, एन -1, एन -2, ,,,,, 1. तक गुणा करते रहते हैं यदि हम N = 0 पर जाएं, हमें उत्तर के लिए 0 मिलेगा। फैक्टरियल को शून्य तक पहुंचने से रोकने के लिए, निम्न पुनरावर्ती विधि का उपयोग किया जाता है। फैक्टोरियल फ़ंक्शन के अंदर, जबकि N> 1, रिटर्न वैल्यू को फैक्टोरियल फ़ंक्शन के एक और दीक्षा के साथ गुणा किया जाता है। यह कोड को पुनरावर्ती रूप से फैक्टरियल () तक रखता है जब तक कि यह N = 1 तक नहीं पहुंचता है। N = 1 केस के लिए, यह N (= 1) को स्वयं लौटाता है और गुणा किए गए रिटर्न के सभी पूर्व निर्मित परिणाम N के साथ गुणा हो जाते हैं। = 1। इस प्रकार तथ्यात्मक परिणाम देता है।
static int factorial(int N) {
if(N > 1) {
return n * factorial(N - 1);
}
// Base Case N = 1
else {
return N;
}