Gibt es eine Methode, die eine Fakultät in Java berechnet?

Ich habe es noch nicht gefunden. Habe ich etwas verpasst? Ich weiß, dass eine faktorielle Methode ein gängiges Beispielprogramm für Anfänger ist. Aber wäre es nicht sinnvoll, eine Standardimplementierung für diese wiederzuverwenden? Ich könnte eine solche Methode auch mit Standardtypen (zB int, long ...) und mit BigInteger / BigDecimal verwenden.

Ich denke nicht, dass es nützlich wäre, eine Bibliotheksfunktion für Fakultät zu haben. Es wird viel über effiziente faktorielle Implementierungen geforscht. Hier sind einige Implementierungen.

Apache Commons Math verfügt über einige faktorielle Methoden in der MathUtils- Klasse.

public class UsefulMethods {
    public static long factorial(int number) {
        long result = 1;

        for (int factor = 2; factor <= number; factor++) {
            result *= factor;
        }

        return result;
    }
}

Big Numbers Version von HoldOffHunger :

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

Nackte nackte Fakultäten werden in der Praxis selten benötigt. Am häufigsten benötigen Sie eine der folgenden Möglichkeiten:

1) Teilen Sie eine Fakultät durch eine andere, oder

2) ungefähre Gleitkommaantwort.

In beiden Fällen sind einfache benutzerdefinierte Lösungen besser geeignet.

In Fall (1) sagen wir, wenn x = 90! / 85!, Dann berechnen Sie das Ergebnis genauso wie x = 86 * 87 * 88 * 89 * 90, ohne 90 halten zu müssen! in Erinnerung :)

In Fall (2) googeln Sie nach "Stirlings Annäherung".

Verwenden Sie Guaven BigIntegerMathwie folgt:

BigInteger factorial = BigIntegerMath.factorial(n);

(Ähnliche Funktionen für intund longsind in IntMathund verfügbarLongMath angezeigt .)

Obwohl Fakultäten eine gute Übung für den Anfänger sind, sind sie in den meisten Fällen nicht sehr nützlich , und jeder weiß, wie man eine Fakultätsfunktion schreibt, sodass sie normalerweise nicht in der durchschnittlichen Bibliothek enthalten sind.

Ich glaube, dies wäre der schnellste Weg durch eine Nachschlagetabelle:

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];
}

Für den nativen Typ long(8 Bytes) kann er nur bis halten20!

20! = 2432902008176640000(10) = 0x 21C3 677C 82B4 0000

Offensichtlich 21!wird es zu einem Überlauf kommen.

Daher ist für den nativen Typ longnur ein Maximum von 20!zulässig, sinnvoll und korrekt.

Da die Fakultät so schnell wächst, ist der Stapelüberlauf kein Problem, wenn Sie die Rekursion verwenden. In der Tat ist der Wert von 20! ist die größte, die man in einem Java Long darstellen kann. Die folgende Methode berechnet also entweder Fakultät (n) oder löst eine IllegalArgumentException aus, wenn n zu groß ist.

public long factorial(int n) {
    if (n > 20) throw new IllegalArgumentException(n + " is out of range");
    return (1 > n) ? 1 : n * factorial(n - 1);
}

Eine andere (coolere) Möglichkeit, dasselbe zu tun, besteht darin, die Stream-Bibliothek von Java 8 wie folgt zu verwenden:

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

Lesen Sie mehr darüber Factorials mit Java 8-Streams

Das Apache Commons Math-Paket hat eine faktorielle Methode , ich denke, Sie könnten diese verwenden.

Kurze Antwort lautet: Rekursion verwenden.

Sie können eine Methode erstellen und diese Methode direkt innerhalb derselben Methode rekursiv aufrufen:

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

Versuche dies

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

Ich habe einen erstaunlichen Trick gefunden, um Fakultäten in nur der Hälfte der tatsächlichen Multiplikationen zu finden.

Bitte haben Sie etwas Geduld, da dies ein etwas langer Beitrag ist.

Für gerade Zahlen: Um die Multiplikation mit geraden Zahlen zu halbieren, erhalten Sie n / 2 Faktoren. Der erste Faktor ist die Zahl, von der Sie die Fakultät nehmen, der nächste ist diese Zahl plus diese Zahl minus zwei. Die nächste Nummer ist die vorherige Nummer plus die zuletzt hinzugefügte Nummer minus zwei. Sie sind fertig, wenn die letzte Zahl, die Sie hinzugefügt haben, zwei war (dh 2) . Das hat wahrscheinlich nicht viel Sinn gemacht, also lassen Sie mich Ihnen ein Beispiel geben.

8! = 8 * (8 + 6 = 14) * (14 + 4 = 18) * (18 + 2 = 20)

8! = 8 * 14 * 18 * 20 which is **40320** 

Beachten Sie, dass ich mit 8 angefangen habe, dann war die erste Zahl, die ich hinzugefügt habe, 6, dann 4, dann 2, wobei jede hinzugefügte Zahl zwei weniger ist als die zuvor hinzugefügte Zahl. Diese Methode entspricht dem Multiplizieren der kleinsten Zahlen mit den größten Zahlen, nur mit weniger Multiplikation, wie folgt:

8! = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 
8! = (1 * 8) * (2 * 7) * (3 * 6) * (4 * 5)
8! = 8 * 14 * 18 * 20

Einfach ist es nicht :)

Jetzt für ungerade Zahlen: Wenn die Zahl ungerade ist, ist das Addieren dasselbe, da Sie jedes Mal zwei subtrahieren, aber bei drei aufhören. Die Anzahl der Faktoren ändert sich jedoch. Wenn Sie die Zahl durch zwei teilen, erhalten Sie eine Zahl, die auf .5 endet. Der Grund ist, dass, wenn wir die Enden miteinander multiplizieren, die mittlere Zahl übrig bleibt. Grundsätzlich kann dies alles gelöst werden, indem nach einer Anzahl von Faktoren gesucht wird, die gleich der durch zwei geteilten Zahl sind, aufgerundet. Für Köpfe ohne mathematischen Hintergrund ergab dies wahrscheinlich auch keinen Sinn. Lassen Sie mich ein Beispiel geben:

9! = 9 * (9 + 7 = 16) * (16 + 5 = 21) * (21 + 3 = 24) * (roundUp(9/2) = 5)

9! = 9 * 16 * 21 * 24 * 5 = **362880**

Hinweis: Wenn Ihnen diese Methode nicht gefällt, können Sie auch einfach die Fakultät der geraden Zahl vor der ungeraden Zahl (in diesem Fall acht) nehmen und mit der ungeraden Zahl multiplizieren (dh 9! = 8! * 9).

Jetzt implementieren wir es in Java:

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

isFirstist eine als statisch deklarierte boolesche Variable; Es wird für den ersten Fall verwendet, in dem wir die vorherige Summe nicht ändern möchten.

Versuchen Sie es mit geraden und ungeraden Zahlen.

Sie können die Rekursion verwenden.

public static int factorial(int n){    
      if (n == 0)    
        return 1;    
      else    
        return(n * factorial(n-1));    
     }

und dann, nachdem Sie die obige Methode (Funktion) erstellt haben:

System.out.println(factorial(number of your choice));  
    //direct example
    System.out.println(factorial(3));

Die einzige geschäftliche Verwendung für eine Fakultät, an die ich denken kann, sind die Erlang B- und Erlang C-Formeln, und nicht jeder arbeitet in einem Callcenter oder für die Telefongesellschaft. Die Nützlichkeit einer Funktion für Unternehmen scheint häufig zu bestimmen, was in einer Sprache angezeigt wird - sehen Sie sich alle Datenverarbeitungs-, XML- und Webfunktionen in den wichtigsten Sprachen an.

Es ist einfach, ein faktorielles Snippet oder eine Bibliotheksfunktion für so etwas beizubehalten.

Eine sehr einfache Methode zur Berechnung von Fakultäten:

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

Ich habe double verwendet, weil sie massive Zahlen enthalten können, aber Sie können jeden anderen Typ wie int, long, float usw. verwenden.

PS Dies ist möglicherweise nicht die beste Lösung, aber ich bin neu in der Codierung und es hat ewig gedauert, bis ich einen einfachen Code gefunden habe, der Fakultäten berechnen kann. Deshalb musste ich die Methode selbst schreiben, aber ich setze sie hier ein, damit sie anderen Leuten wie mir hilft .

Sie können auch die Rekursionsversion verwenden.

static int myFactorial(int i) {
    if(i == 1)
        return;
    else
        System.out.prinln(i * (myFactorial(--i)));
}

Rekursion ist normalerweise weniger effizient, da Rekursionen verschoben und verschoben werden müssen, sodass die Iteration schneller erfolgt. Andererseits verwenden rekursive Versionen weniger oder keine lokalen Variablen, was von Vorteil ist.

Factorial ist eine stark zunehmende diskrete Funktion. Ich denke also, dass die Verwendung von BigInteger besser ist als die Verwendung von int. Ich habe den folgenden Code zur Berechnung der Fakultät für nicht negative ganze Zahlen implementiert. Ich habe die Rekursion anstelle der Verwendung einer Schleife verwendet.

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

Hier ist der Bereich der großen ganzen Zahl

-2^Integer.MAX_VALUE (exclusive) to +2^Integer.MAX_VALUE,
where Integer.MAX_VALUE=2^31.

Der Bereich der oben angegebenen faktoriellen Methode kann jedoch durch Verwendung von BigInteger ohne Vorzeichen auf das Doppelte erweitert werden.

Wir haben eine einzige Zeile, um es zu berechnen:

Long factorialNumber = LongStream.rangeClosed(2, N).reduce(1, Math::multiplyExact);

Eine ziemlich einfache Methode

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

Wir müssen iterativ implementieren. Wenn wir rekursiv implementieren, wird StackOverflow verursacht, wenn die Eingabe sehr groß wird (dh 2 Milliarden). Und wir müssen eine ungebundene Größenzahl wie BigInteger verwenden, um einen arithmatischen Überlauf zu vermeiden, wenn eine Fakultätszahl größer als die maximale Anzahl eines bestimmten Typs wird (dh 2 Milliarden für int). Sie können int für maximal 14 Fakultäten und long für maximal 20 Fakultäten vor dem Überlauf verwenden.

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

Wenn Sie BigInteger nicht verwenden können, fügen Sie eine Fehlerprüfung hinzu.

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 int factorial(int num) {
        if (num == 1) return 1;
        return num * factorial(num - 1);
}

while-Schleife (für kleine Zahlen)

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

Ich habe das von EDX bekommen, benutze es! Es heißt Rekursion

   public static int factorial(int n) {
    if (n == 1) {
        return 1;
    } else {
        return n * factorial(n-1);
    }
}

mit Rekursion:

public static int factorial(int n)
{
    if(n == 1)
    {
        return 1;
    }               
    return n * factorial(n-1);
}

mit while-Schleife:

public static int factorial1(int n)
{
    int fact=1;
    while(n>=1)
    {
        fact=fact*n;
        n--;
    }
    return fact;
}

DIE VERWENDUNG VON DYNAMISCHER PROGRAMMIERUNG IST EFFIZIENT

wenn Sie es verwenden möchten, um immer wieder zu berechnen (wie Caching)

Java-Code:

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];
 }

Die Verwendung der Rekursion ist die einfachste Methode. Wenn wir die Fakultät von N finden wollen, müssen wir die beiden Fälle betrachten, in denen N = 1 und N> 1 ist, da wir in der Fakultät N, N-1, N-2 ,,,,, bis 1 multiplizieren, wenn wir gehe zu N = 0, wir bekommen 0 für die Antwort. Um zu verhindern, dass die Fakultät Null erreicht, wird die folgende rekursive Methode verwendet. Innerhalb der Fakultätsfunktion wird der Rückgabewert mit einer weiteren Initiierung der Fakultätsfunktion multipliziert, während N> 1 ist. Dadurch bleibt der Code so, dass er die Fakultät () rekursiv aufruft, bis er N = 1 erreicht. Für den Fall N = 1 gibt er N (= 1) selbst zurück und alle zuvor aufgebauten Ergebnisse der multiplizierten Rückgabe N s werden mit N multipliziert = 1. Somit ergibt sich das faktorielle Ergebnis.

static int factorial(int N) {
    if(N > 1) { 
    return n * factorial(N - 1);
    }
    // Base Case N = 1
    else { 
    return N;
    }