Fonction récursive : Factorielle

Fait partie de la section Logique & Flux du Journey Dart de Coddy — leçon 49 sur 65.

La factorielle d'un nombre est une opération mathématique classique qui est parfaite pour démontrer la récursivité. La factorielle d'un entier positif n (notée n!) est le produit de tous les entiers positifs de 1 à n. Par exemple, 5! = 5 × 4 × 3 × 2 × 1 = 120.

Ce qui rend la factorielle idéale pour la récursion, c'est qu'elle se décompose naturellement en problèmes plus petits et identiques. Pour calculer 5!, vous pouvez le voir comme 5 × 4!. Et 4! n'est autre que 4 × 3!, et ainsi de suite. Ce schéma continue jusqu'à ce que vous atteigniez 1!, qui est égal à 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Cas de base
  }
  
  return n * factorial(n - 1); // Étape récursive
}

Le cas de base arrête la récursion lorsque n <= 1, en retournant 1. L'étape récursive multiplie le nombre actuel par la factorielle du nombre immédiatement inférieur. Lorsque vous appelez factorial(5), il renvoie 5 * factorial(4), qui renvoie 5 * 4 * factorial(3), et ainsi de suite jusqu'à ce qu'il atteigne le cas de base.

Cette approche démontre comment la récursivité résout élégamment les problèmes en les réduisant à des versions plus simples du même problème, rendant les calculs complexes naturels et intuitifs.

Défi

Facile

Créez un programme qui calcule les factorielles de plusieurs nombres en utilisant la récursion. Votre programme démontrera la fonction factorielle récursive en traitant une liste de nombres et en calculant leurs factorielles.

Lisez une chaîne de caractères en entrée contenant des nombres séparés par des virgules (par exemple, "3,5,0,7")
Divisez la chaîne d'entrée en nombres individuels et convertissez chacun en un entier
Créez une fonction récursive appelée factorial qui prend un paramètre entier n
La fonction factorial doit implémenter la logique suivante :

Cas de base : Si n est inférieur ou égal à 1, retournez 1
Étape récursive : Retournez n multiplié par factorial(n - 1)

Pour chaque nombre de la liste d'entrée, calculez sa factorielle à l'aide de votre fonction récursive
Affichez les résultats montrant chaque nombre et sa factorielle correspondante
Calculez et affichez la somme de tous les résultats factoriels

Par exemple, si l'entrée est "4,3,2", votre programme doit afficher :

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

Si l'entrée est "5,0,1", votre programme doit afficher :

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

Si l'entrée est "6", votre programme doit afficher :

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

Votre programme doit implémenter la fonction récursive factorial qui s'appelle elle-même avec des valeurs décrémentées jusqu'à ce qu'elle atteigne le cas de base. La fonction doit démontrer comment la récursion décompose le calcul de la factorielle en sous-problèmes plus petits et identiques. Utilisez l'interpolation de chaîne pour formater les résultats factoriels comme "$n! = $result". N'oubliez pas que 0! est égal à 1 par définition mathématique, ce que votre cas de base doit gérer correctement.

Aide-mémoire

La factorielle d'un entier positif n (notée n!) est le produit de tous les entiers positifs de 1 à n. Par exemple, 5! = 5 × 4 × 3 × 2 × 1 = 120.

La factorielle est idéale pour la récursion car elle se décompose en problèmes plus petits et identiques : 5! = 5 × 4!, et 4! = 4 × 3!, en continuant jusqu'à atteindre 1! = 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Cas de base
  }
  
  return n * factorial(n - 1); // Étape récursive
}

Le cas de base arrête la récursion quand n <= 1, en retournant 1. L'étape récursive multiplie le nombre actuel par la factorielle du nombre immédiatement inférieur.

Essayez vous-même

import 'dart:io';

// TODO: Créez votre fonction factorielle récursive ici

void main() {
  // Lire la chaîne d'entrée contenant des nombres séparés par des virgules
  String? input = stdin.readLineSync();
  
  // Diviser l'entrée et convertir en entiers
  List<int> numbers = input!.split(',').map((str) => int.parse(str.trim())).toList();
  
  // TODO: Écrivez votre code ci-dessous pour :
  // 1. Traiter chaque nombre en utilisant votre fonction factorielle
  // 2. Calculer la somme de toutes les factorielles
  // 3. Afficher les résultats dans le format requis
  
  print("Factorial Calculator");
  print("====================");
  print("Processing numbers: $numbers");
  print("====================");
  print("Factorial Results:");
  
  // TODO: Calculez et affichez les résultats des factorielles ici
  
  print("====================");
  // TODO: Afficher la somme de toutes les factorielles
  print("Calculation completed successfully");
}