Méthode pour calculer la factorielle en Java
- Obtenir factoriel à l’aide de la méthode itérative en Java
- Trouver un factoriel à l’aide de la méthode récursive en Java
- Trouver factoriel en utilisant l’approche dynamique en Java
- Trouver factoriel à l’aide d’Apache Commons en Java
- Trouver une factorielle à l’aide de flux Java 8
-
Trouver factoriel en utilisant
BigIntegeren Java -
Trouver un factoriel à l’aide de la bibliothèque
BigIntegerMath
Ce didacticiel présente les méthodes et les exemples de code pour calculer la factorielle en Java.
La factorielle d’un nombre n est la multiplication de tous les nombres naturels entre 1 et n. Dans ce tutoriel, nous verrons différentes manières de calculer la factorielle d’un nombre.
Nous verrons d’abord comment la factorielle des nombres inférieurs et égaux à 20 peut être calculée. Cette ségrégation est due à la gamme limitée de types de données longs de Java.
Les factorielles des nombres supérieurs à 20 sont trop grandes pour tenir dans la plage des longs.
Obtenir factoriel à l’aide de la méthode itérative en Java
Dans cet exemple, nous avons créé une variable, store_fact, de type long et l’avons initialisée avec 1.
Nous parcourons ensuite tous les entiers de 1 au nombre dont la factorielle est calculée et multiplions la valeur de la variable de boucle par la valeur store_fact. Nous avons stocké la valeur calculée dans la variable store_fact et mis à jour la variable de boucle.
Pour rendre l’algorithme ci-dessus plus clair, nous pouvons l’écrire comme ceci :
- initialiser
n - initialiser
store_fact = 1 - faire
for i = 1àn store_fact = store_fact*n- incrémenter
i - retourner
store_fact
Dans l’algorithme ci-dessus, la variable store_fact stocke la factorielle du n comme suit :
- Après la première itération :
store_value = 1 = 1! - Après la deuxième itération :
store_value = 1 X 2 = 2! - Après la troisième itération :
store_value = 1 X 2 X 3 = 3! - Après la nième itération :
store_value = 1 X 2 X 3 X 4 ........ Xn = n!
Examinons maintenant l’exemple de code de l’algorithme ci-dessus.
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));
}
}
Production :
Enter a number:
4
24
Trouver un factoriel à l’aide de la méthode récursive en Java
La méthode itérative ci-dessus peut être transformée en une méthode récursive pour trouver la factorielle de n’importe quel nombre. Dans cette méthode, nous prenons le cas de base comme suit :
if (n == 0 || n == 1) {
return 1;
}
Si la condition de base n’est pas remplie, elle renvoie :
n* factCalculator(n - 1);
Voyons l’exemple de code ci-dessous. Nous avons utilisé une méthode récursive, factCalculator(), pour trouver la factorielle.
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));
}
}
Production :
Enter a number:
4
24
Trouver factoriel en utilisant l’approche dynamique en Java
Nous pouvons également calculer la factorielle d’un nombre en utilisant l’approche de programmation dynamique. Cette méthode est plus rapide que les autres méthodes car elle stocke la factorielle des petits nombres et calcule les factorielles des grands nombres à l’aide de ces factorielles.
Par example:
- 5! = 5 X 4!
- 4! = 4 X 3!
- 3! = 3 X 2!
- 2! = 2 X 1!
- 1! = 1 X 0!
- 0! = 1
Dans cette méthode, nous créons une table de recherche. Cette table stocke les factorielles des nombres de 0 à 20.
Nous avons créé la table de recherche jusqu’à 20 uniquement parce que c’est le plus grand nombre dont la factorielle longue peut stocker. Nous avons initialisé 0! comme 1.
Nous avons ensuite utilisé la valeur 0! pour calculer 1!, la valeur de 1! pour calculer 2! etc. Regardez le code ci-dessous :
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]);
}
}
Production :
Enter a number:
5
120
Trouver factoriel à l’aide d’Apache Commons en Java
Si vous travaillez avec la librairie Apache Commons Math, utilisez la classe CombinatoricsUtils avec une méthode factorial(). C’est une méthode intégrée pour calculer la factorielle de n’importe quel nombre.
La valeur renvoyée par cette méthode est de type long ; par conséquent, nous ne pouvons pas calculer la factorielle des nombres supérieurs à 20. Voir l’exemple ci-dessous.
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));
}
}
Production :
Enter a number:
5
120
Trouver une factorielle à l’aide de flux Java 8
Nous pouvons également utiliser l’API de flux Java 8 pour calculer la factorielle d’un nombre. Nous allons d’abord créer un flux de nombres de 1 à n, où n est le nombre dont la factorielle est calculée.
Nous utilisons ensuite la méthode reduce pour effectuer l’opération de réduction sur les éléments. Nous avons passé 1 comme élément d’identité et la multiplication comme fonction d’accumulation associative.
Regardez le code ci-dessous :
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));
}
}
Production :
Enter a number:
5
120
Il y a un grand avantage à utiliser la fonction reduce() par rapport à la méthode itérative ou récursive. L’opération reduce() est parallélisable si la fonction utilisée pour traiter les éléments est associative.
Maintenant, nous allons calculer la factorielle des nombres supérieurs à 20.
Trouver factoriel en utilisant BigInteger en Java
La classe BigInteger est utilisée pour gérer de très grands nombres au-delà de la plage des types de données primitifs. Nous pouvons utiliser BigInteger pour stocker la valeur des factorielles des nombres supérieurs à 20.
Voir l’exemple ci-dessous.
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();
}
}
Production :
Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000
Comme nous ne pouvons pas multiplier BigInteger à l’aide de l’opérateur *, nous utilisons la fonction multiply(). Cette méthode est comme la méthode itérative, sauf que nous utilisons BigInteger au lieu de long.
Trouver un factoriel à l’aide de la bibliothèque BigIntegerMath
La bibliothèque BigIntegerMath possède une méthode intégrée factorial(), qui peut être utilisée pour calculer la factorielle d’un nombre. C’est une méthode statique et renvoie une valeur de type long.
Voir l’exemple ci-dessous.
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));
}
}
Production :
Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000