Schnellstes faktorielles Programm in JavaScript

1. Fakultätsprogramm mit Rekursion in JavaScript
2. Fakultätsprogramm mit Iteration in JavaScript
3. Schnellstes faktorielles Programm in JavaScript

Das Fakultätsprogramm wird verwendet, um die Faktoren einer bestimmten Zahl zu finden. Zum Beispiel sind die Faktoren der Zahl 8 1, 2, 4 und 8. Die Faktoren der Zahlen 0 und 1 sind immer 1. Ebenso hat jede Zahl einige Fakultätszahlen.

Es gibt zwei Möglichkeiten, ein faktorielles Programm in JavaScript zu schreiben, eine Möglichkeit ist die Rekursion und eine andere die Verwendung von Iteration. Wir werden beide Programme 1000 Mal mit der Schleife for() aufrufen und jedes Mal, wenn wir dieses Programm aufrufen, finden wir die Fakultät der Zahl 1000.

Sehen wir uns beide Wege im Detail an, und später werden wir sehen, welches das schnellste faktorielle Programm ist.

Fakultätsprogramm mit Rekursion in JavaScript

Die rekursive Methode ist eine Möglichkeit, das Fakultätsprogramm zu schreiben. Bei der Rekursion rufen wir dieselbe Funktion immer wieder mit einer Basisbedingung auf. Die Basisbedingung stellt sicher, dass wir nicht in eine Endlosschleife geraten.

Um die Zeit zu überprüfen, die für die Ausführung des rekursiven Programms benötigt wird, verwenden wir die Methode getItem() des Objekts Date. Die Variable start speichert die Zeit, zu der das Programm mit der Ausführung beginnt, und die Variable end speichert die Zeit, zu der das Programm seine Ausführung beendet.

Wie wir wissen, ist die Fakultät einer Zahl Null 1. Also machen wir dies zu unserer Basisbedingung, und sobald eine Zahl Null wird, wird 1 zurückgegeben. Andernfalls werden wir die Fakultät dieser Zahl immer wieder finden, indem wir dieselbe Fakultätsfunktion immer wieder aufrufen, bis wir 0 erreichen. Die Implementierung des Fakultätsprogramms mit Rekursion ist wie unten gezeigt.

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

Ausgabe:

1627808767415

Die oben gezeigte Ausgabe ist der Zeitpunkt, zu dem das rekursive Programm seine Ausführung beendet, die auch in der Variable end gespeichert wird. Die Zeit ist in Millisekunden angegeben und wird im Konsolenfenster des Browsers ausgegeben.

Fakultätsprogramm mit Iteration in JavaScript

Eine andere Möglichkeit, ein faktorielles Programm zu schreiben, ist die Iteration. In der Iteration verwenden wir Schleifen wie for-, while- oder do-while-Schleifen.

Auch hier überprüfen wir die Zeit, die für die Ausführung des iterativen Programms benötigt wird, indem wir die Methode getItem() des Date-Objekts verwenden. Die Variable start2 speichert die Zeit, zu der das Programm mit der Ausführung beginnt, und die Variable end2 speichert die Zeit, zu der das iterative Programm seine Ausführung beendet.

In der Funktion iterationFactorial() setzen wir den Zähler zunächst auf 1 und verwenden dann eine for-Schleife, um die Faktoren zu ermitteln, indem wir die Variable counter inkrementieren. Am Ende geben wir den Wert der Variable counter zurück.

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

Ausgabe:

1627808727136

Die oben gezeigte Ausgabe ist der Zeitpunkt, an dem das Programm endet, das Iterationsprogramm seine Ausführung beendet, die auch in der Variablen end2 gespeichert wird. Die Zeit ist in Millisekunden angegeben und wird im Konsolenfenster des Browsers ausgegeben.

Schnellstes faktorielles Programm in JavaScript

Jetzt haben wir sowohl das Rekursions- als auch das Iterationsprogramm zum Auffinden der Fakultät einer Zahl gesehen. Lassen Sie uns nun das Endergebnis (d. h. die Zeit, die für die Ausführung dieser beiden Programme benötigt wurde) überprüfen, um zu sehen, welches dieser beiden faktoriellen Programme schneller ist.

Die Start- und Endzeit für das Rekursionsprogramm haben wir bereits in den Variablen start und end und die Zeit für das Iterationsprogramm in den Variablen start2 und end2 hinterlegt. Jetzt müssen wir die Endzeit von der Startzeit abziehen, um die resultierende Zeit in Millisekunden zu erhalten.

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

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

Ausgabe:

res1: 1626 res2: 27

Die Endergebnisse zeigen, dass das Rekursionsprogramm viel mehr Zeit benötigt als das Iterationsprogramm. Daher ist in JavaScript das faktorielle Iterationsprogramm das schnellste. Diese Ausgabe kann je nach System variieren, auf dem Sie dieses Programm ausführen.