Methode zur Berechnung der Fakultät in Java

1. Get Factorial mit der iterativen Methode in Java
2. Faktorielle Bestimmung mit der rekursiven Methode in Java
3. Finden Sie die Fakultät mit dem dynamischen Ansatz in Java
4. Faktorielle Berechnung mit Apache Commons in Java
5. Faktorielle Berechnung mit Java 8 Streams
6. Faktorielle Berechnung mit BigInteger in Java
7. Bestimmung des Faktors mit der BigIntegerMath-Bibliothek

Dieses Tutorial stellt die Methoden und Codebeispiele zur Berechnung der Fakultät in Java vor.

Die Fakultät einer Zahl n ist die Multiplikation aller natürlichen Zahlen zwischen 1 und n. In diesem Tutorial werden wir verschiedene Möglichkeiten sehen, die Fakultät einer Zahl zu berechnen.

Wir schauen uns zuerst an, wie die Fakultät von Zahlen kleiner und gleich 20 berechnet werden kann. Diese Trennung ist auf die begrenzte Auswahl an langen Datentypen in Java zurückzuführen.

Die Fakultäten von Zahlen über 20 sind zu gross, um in den Bereich der Longs zu passen.

Get Factorial mit der iterativen Methode in Java

In diesem Beispiel haben wir eine Variable store_fact vom Typ long erstellt und mit 1 initialisiert.

Wir durchlaufen dann alle ganzen Zahlen von 1 bis zu der Zahl, deren Fakultät berechnet wird, und multiplizieren den Wert der Schleifenvariablen mit dem Wert store_fact. Wir haben den berechneten Wert in der Variablen store_fact gespeichert und die Schleifenvariable aktualisiert.

Um den obigen Algorithmus klarer zu machen, können wir ihn so schreiben:

• n initialisieren
• store_fact = 1 initialisieren
• mache for i = 1 bis n
• store_fact = store_fact*n
• Inkrement i
• Rückgabe store_fact

Im obigen Algorithmus speichert die Variable store_fact die Fakultät von n wie folgt:

• Nach der ersten Iteration: store_value = 1 = 1!
• Nach der zweiten Iteration: store_value = 1 X 2 = 2!
• Nach der dritten Iteration: store_value = 1 X 2 X 3 = 3!
• Nach der n-ten Iteration: store_value = 1 X 2 X 3 X 4 ........ Xn = n!

Betrachten wir nun das Codebeispiel für den obigen Algorithmus.

import java.util.Scanner;
public class SimpleTesting {
  static long factCalculator(int n) {
    long store_fact = 1;
    int i = 1;
    while (i <= n) {
      store_fact = store_fact * i;
      i++;
    }
    return store_fact;
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

Ausgabe:

Enter a number: 
4
24

Faktorielle Bestimmung mit der rekursiven Methode in Java

Das obige iterative Verfahren kann in ein rekursives Verfahren umgewandelt werden, um Fakultäten einer beliebigen Zahl zu finden. Bei dieser Methode nehmen wir den Basisfall als:

if (n == 0 || n == 1) {
  return 1;
}

Wenn die Grundbedingung nicht erfüllt ist, wird zurückgegeben:

n* factCalculator(n - 1);

Sehen wir uns das Codebeispiel unten an. Wir haben eine rekursive Methode, factCalculator(), verwendet, um die Fakultät zu finden.

import java.util.*;
public class SimpleTesting {
  static long factCalculator(int n) {
    if (n == 0 || n == 1) {
      return 1;
    } else {
      return n * factCalculator(n - 1);
    }
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

Ausgabe:

Enter a number:
4
24

Finden Sie die Fakultät mit dem dynamischen Ansatz in Java

Wir können auch die Fakultät einer Zahl berechnen, indem wir den Ansatz der dynamischen Programmierung verwenden. Diese Methode ist schneller als andere Methoden, da sie die Fakultäten kleinerer Zahlen speichert und die Fakultäten größerer Zahlen unter Verwendung dieser Fakultäten berechnet.

Beispielsweise:

• 5! = 5 x 4!
• 4! = 4 x 3!
• 3! = 3 x 2!
• 2! = 2 x 1!
• 1! = 1 X 0!
• 0! = 1

In dieser Methode erstellen wir eine Nachschlagetabelle. Diese Tabelle speichert die Fakultäten von Zahlen von 0 bis 20.

Wir haben die Nachschlagetabelle nur bis 20 erstellt, weil es die größte Zahl ist, deren Fakultät lang speichern kann. Wir initialisierten 0! als 1.

Wir haben dann den Wert 0! um 1! zu berechnen, den Wert von 1! um 2! zu berechnen und so weiter. Sehen Sie sich den folgenden Code an:

import java.util.*;
public class SimpleTesting {
  static long[] factCalculator() {
    long[] fact_table = new long[21];
    fact_table[0] = 1;
    for (int i = 1; i < fact_table.length; i++) {
      fact_table[i] = fact_table[i - 1] * i;
    }
    return fact_table;
  }
  public static void main(String args[]) {
    long[] table = factCalculator();
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(table[number]);
  }
}

Ausgabe:

Enter a number: 
5
120

Faktorielle Berechnung mit Apache Commons in Java

Wenn Sie mit der Apache Commons Math-Bibliothek arbeiten, verwenden Sie die Klasse CombinatoricsUtils mit einer factorial()-Methode. Es ist eine integrierte Methode zur Berechnung der Fakultät einer beliebigen Zahl.

Der von dieser Methode zurückgegebene Wert ist vom Typ long; Daher können wir keine Fakultät von Zahlen größer als 20 berechnen. Siehe das Beispiel unten.

import java.util.Scanner;
import org.apache.commons.math3.util.CombinatoricsUtils;
public class SimpleTesting {
  static long factCalculator(int n) {
    return CombinatoricsUtils.factorial(n);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

Ausgabe:

Enter a number: 
5
120

Faktorielle Berechnung mit Java 8 Streams

Wir können auch die Java 8-Stream-API verwenden, um die Fakultät einer Zahl zu berechnen. Wir erstellen zuerst einen Zahlenstrom von 1 bis n, wobei n die Zahl ist, deren Fakultät berechnet wird.

Wir verwenden dann die Reduce-Methode, um die Reduktionsoperation an den Elementen durchzuführen. Wir haben die 1 als Identitätselement und die Multiplikation als assoziative Akkumulationsfunktion übergeben.

Sehen Sie sich den folgenden Code an:

import java.util.*;
import java.util.stream.LongStream;
public class SimpleTesting {
  static long factCalculator(int n) {
    return LongStream.rangeClosed(1, n).reduce(1, (long num1, long num2) -> num1 * num2);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

Ausgabe:

Enter a number: 
5
120

Die Verwendung der Funktion reduce() hat gegenüber der iterativen oder rekursiven Methode einen grossen Vorteil. Die Operation reduce() ist parallelisierbar, wenn die zur Verarbeitung der Elemente verwendete Funktion assoziativ ist.

Jetzt berechnen wir die Fakultät von Zahlen über 20.

Faktorielle Berechnung mit BigInteger in Java

Die Klasse BigInteger wird verwendet, um sehr große Zahlen zu behandeln, die über den Bereich primitiver Datentypen hinausgehen. Wir können BigInteger verwenden, um den Wert von Fakultäten von Zahlen über 20 zu speichern.

Siehe das Beispiel unten.

import java.math.BigInteger;
import java.util.Scanner;

public class SimpleTesting {
  static BigInteger factCalculator(int n) {
    BigInteger store_fact = BigInteger.ONE;
    for (int i1 = 2; i1 <= n; i1++) {
      store_fact = store_fact.multiply(BigInteger.valueOf(i1));
    }
    return store_fact;
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
    scan.close();
  }
}

Ausgabe:

Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000

Da wir BigInteger nicht mit dem Operator * multiplizieren können, verwenden wir die Funktion multiply(). Diese Methode ist genau wie die iterative Methode, außer dass wir BigInteger anstelle von long verwenden.

Bestimmung des Faktors mit der BigIntegerMath-Bibliothek

Die BigIntegerMath-Bibliothek hat eine eingebaute factorial()-Methode, mit der die Fakultät einer Zahl berechnet werden kann. Es ist eine statische Methode und gibt einen Wert vom Typ long zurück.

Siehe das Beispiel unten.

import com.google.common.math.BigIntegerMath;
import java.util.*;
public class SimpleTesting {
  static long factCalculator(int n) {
    return BigIntegerMath.factorial(n);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

Ausgabe:

Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000