Le programme factoriel le plus rapide en JavaScript

  1. Programme factoriel utilisant la récursivité en JavaScript
  2. Programme factoriel utilisant l’itération en JavaScript
  3. Le programme factoriel le plus rapide en JavaScript

Le programme factoriel est utilisé pour trouver les facteurs d’un nombre donné. Par exemple, les facteurs du nombre 8 sont 1, 2, 4 et 8. Les facteurs des nombres 0 et 1 sont toujours 1. De même, chaque nombre a des nombres factoriels.

Il existe deux manières d’écrire un programme factoriel en JavaScript, l’une consiste à utiliser la récursivité et l’autre à utiliser l’itération. Nous appellerons ces deux programmes 1000 fois en utilisant la boucle for(), et à chaque fois que nous appellerons ce programme, nous trouverons la factorielle du nombre 1000.

Voyons les deux manières en détail, et plus tard nous verrons laquelle est le programme factoriel le plus rapide.

Programme factoriel utilisant la récursivité en JavaScript

La méthode récursive est une façon d’écrire le programme factoriel. En récursivité, nous appelons la même fonction encore et encore avec une condition de base. La condition de base garantit que nous n’entrons pas dans une boucle infinie.

Pour vérifier le temps d’exécution du programme récursif, on utilise la méthode getItem() de l’objet Date. La variable start mémorisera l’heure à laquelle le programme commence son exécution, et la variable end mémorisera l’heure à laquelle le programme termine son exécution.

Comme on le sait, la factorielle d’un nombre zéro est 1. Donc, nous allons en faire notre condition de base, et dès qu’un nombre devient zéro, il retournera 1. Sinon, nous continuerons à trouver la factorielle de ce nombre en appelant la même fonction factorielle encore et encore jusqu’à ce que nous atteignions 0. L’implémentation du programme factoriel utilisant la récursivité est illustrée ci-dessous.

let start, end;
start = new Date().getTime();

for (var i = 0; i < 10000; i++)
    recursionFactorial(1000)

function recursionFactorial(num){
    if (num === 0)
        return 1;
    else
        return num * recursionFactorial( num - 1 );
}

end = new Date().getTime();

console.log(end);

Production:

1627808767415

La sortie montrée ci-dessus est l’heure à laquelle le programme récursif termine son exécution qui est également stockée dans la variable end. Le temps est en millisecondes et est imprimé dans la fenêtre de console du navigateur.

Programme factoriel utilisant l’itération en JavaScript

Une autre façon d’écrire un programme factoriel consiste à utiliser l’itération. Dans l’itération, nous utilisons des boucles telles que les boucles for, while ou do-while.

Ici aussi nous vérifierons le temps d’exécution du programme itératif en utilisant la méthode getItem() de l’objet Date. La variable start2 stockera l’heure à laquelle le programme commence son exécution, et la variable end2 stockera l’heure à laquelle le programme itératif termine son exécution.

Dans la fonction iterationFactorial(), on met d’abord le compteur à 1 puis on utilise une boucle for pour trouver les facteurs en incrémentant la variable counter. Au final, on retourne la valeur de la variable counter.

let start2, end2;
start2 = new Date().getTime();

for (var i = 0; i < 10000; i++)
    iterationFactorial(1000);

function iterationFactorial(num){
    var counter = 1;
    for (var i = 2; i <= num; i++)
        counter = counter * i;
    return counter;
}

end2 = new Date().getTime();

console.log(end2);

Production:

1627808727136

La sortie indiquée ci-dessus est l’heure à laquelle le programme se termine, le programme d’itération termine son exécution qui est également stockée dans la variable end2. Le temps est en millisecondes et est imprimé dans la fenêtre de console du navigateur.

Le programme factoriel le plus rapide en JavaScript

Maintenant que nous avons vu à la fois le programme de récursivité et d’itération pour trouver la factorielle d’un nombre. Vérifions maintenant le résultat final (c’est-à-dire le temps pris pour exécuter ces deux programmes) pour voir lequel de ces deux programmes factoriels est le plus rapide.

Nous avons déjà stocké l’heure de début et de fin du programme de récursivité dans les variables start et end et l’heure du programme d’itération à l’intérieur des variables start2 et end2. Maintenant, nous devons soustraire l’heure de fin de l’heure de début pour obtenir le temps résultant en millisecondes.

let res1 = end - start;
let res2 = end2 - start2;

console.log("res1: " + res1 + " res2: " + res2 )

Production:

res1: 1626 res2: 27

Les résultats finaux montrent que le programme de récursivité prend beaucoup plus de temps que le programme d’itération. Par conséquent, en JavaScript, le programme factoriel d’itération est le plus rapide. Cette sortie peut varier en fonction du système sur lequel vous exécuterez ce programme.