Rekursive Funktion: Fakultät

Teil des Abschnitts Logik & Ablauf der Dart-Journey von Coddy — Lektion 49 von 65.

Die Fakultät einer Zahl ist eine klassische mathematische Operation, die sich perfekt zur Demonstration von Rekursion eignet. Die Fakultät einer positiven Ganzzahl n (geschrieben als n!) ist das Produkt aller positiven Ganzzahlen von 1 bis n. Zum Beispiel ist 5! = 5 × 4 × 3 × 2 × 1 = 120.

Was die Fakultät ideal für die Rekursion macht, ist, dass sie sich natürlich in kleinere, identische Probleme zerlegen lässt. Um 5! zu berechnen, kann man es sich als 5 × 4! vorstellen. Und 4! ist einfach 4 × 3!, und so weiter. Dieses Muster setzt sich fort, bis man 1! erreicht, was gleich 1 ist.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Basisfall
  }
  
  return n * factorial(n - 1); // Rekursionsschritt
}

Der Basisfall stoppt die Rekursion, wenn n <= 1, und gibt 1 zurück. Der Rekursionsschritt multipliziert die aktuelle Zahl mit der Fakultät der nächstkleineren Zahl. Wenn Sie factorial(5) aufrufen, gibt sie 5 * factorial(4) zurück, was wiederum 5 * 4 * factorial(3) zurückgibt, und so weiter, bis der Basisfall erreicht ist.

Dieser Ansatz zeigt, wie Rekursion Probleme elegant löst, indem sie diese auf einfachere Versionen desselben Problems reduziert, wodurch sich komplexe Berechnungen natürlich und intuitiv anfühlen.

Aufgabe

Einfach

Erstellen Sie ein Programm, das Fakultäten für mehrere Zahlen mithilfe von Rekursion berechnet. Ihr Programm wird die rekursive Fakultätsfunktion demonstrieren, indem es eine Liste von Zahlen verarbeitet und deren Fakultäten berechnet.

Lesen Sie eine String-Eingabe ein, die durch Kommas getrennte Zahlen enthält (z. B. "3,5,0,7")
Teilen Sie den Eingabestring in einzelne Zahlen auf und konvertieren Sie jede in eine Ganzzahl
Erstellen Sie eine rekursive Funktion namens factorial, die einen Ganzzahl-Parameter n entgegennimmt
Die factorial-Funktion sollte die folgende Logik implementieren:

Basisfall: Wenn n kleiner oder gleich 1 ist, geben Sie 1 zurück
Rekursionsschritt: Geben Sie n multipliziert mit factorial(n - 1) zurück

Berechnen Sie für jede Zahl in der Eingabeliste deren Fakultät mit Ihrer rekursiven Funktion
Zeigen Sie die Ergebnisse an, wobei jede Zahl und ihre entsprechende Fakultät aufgeführt werden
Berechnen und zeigen Sie die Summe aller Fakultätsergebnisse an

Wenn die Eingabe beispielsweise "4,3,2" lautet, sollte Ihr Programm Folgendes ausgeben:

Factorial Calculator
====================
Processing numbers: [4, 3, 2]
====================
Factorial Results:
4! = 24
3! = 6
2! = 2
====================
Sum of all factorials: 32
Calculation completed successfully

Wenn die Eingabe "5,0,1" lautet, sollte Ihr Programm Folgendes ausgeben:

Factorial Calculator
====================
Processing numbers: [5, 0, 1]
====================
Factorial Results:
5! = 120
0! = 1
1! = 1
====================
Sum of all factorials: 122
Calculation completed successfully

Wenn die Eingabe "6" lautet, sollte Ihr Programm Folgendes ausgeben:

Factorial Calculator
====================
Processing numbers: [6]
====================
Factorial Results:
6! = 720
====================
Sum of all factorials: 720
Calculation completed successfully

Ihr Programm muss die rekursive factorial-Funktion implementieren, die sich selbst mit dekrementierten Werten aufruft, bis sie den Basisfall erreicht. Die Funktion soll demonstrieren, wie Rekursion die Fakultätsberechnung in kleinere, identische Teilprobleme zerlegt. Verwenden Sie String-Interpolation, um die Fakultätsergebnisse als "$n! = $result" zu formatieren. Denken Sie daran, dass 0! nach mathematischer Definition gleich 1 ist, was Ihr Basisfall korrekt behandeln sollte.

Spickzettel

Die Fakultät einer positiven Ganzzahl n (geschrieben als n!) ist das Produkt aller positiven Ganzzahlen von 1 bis n. Zum Beispiel ist 5! = 5 × 4 × 3 × 2 × 1 = 120.

Die Fakultät ist ideal für Rekursion, da sie sich in kleinere, identische Probleme zerlegen lässt: 5! = 5 × 4! und 4! = 4 × 3!, bis schließlich 1! = 1 erreicht wird.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Basisfall
  }
  
  return n * factorial(n - 1); // Rekursionsschritt
}

Der Basisfall stoppt die Rekursion, wenn n <= 1 ist, und gibt 1 zurück. Der Rekursionsschritt multipliziert die aktuelle Zahl mit der Fakultät der nächstkleineren Zahl.

Probier es selbst

import 'dart:io';

// TODO: Erstellen Sie hier Ihre rekursive Fakultätsfunktion

void main() {
  // Eingabestring lesen, der durch Kommata getrennte Zahlen enthält
  String? input = stdin.readLineSync();
  
  // Die Eingabe aufteilen und in Ganzzahlen umwandeln
  List<int> numbers = input!.split(',').map((str) => int.parse(str.trim())).toList();
  
  // TODO: Schreiben Sie Ihren Code unten, um:
  // 1. Jede Zahl mit Ihrer Fakultätsfunktion zu verarbeiten
  // 2. Die Summe aller Fakultäten zu berechnen
  // 3. Die Ergebnisse im erforderlichen Format anzuzeigen
  
  print("Factorial Calculator");
  print("====================");
  print("Processing numbers: $numbers");
  print("====================");
  print("Factorial Results:");
  
  // TODO: Fakultätsergebnisse hier berechnen und anzeigen
  
  print("====================");
  // TODO: Summe aller Fakultäten anzeigen
  print("Calculation completed successfully");
}