Função Recursiva: Fatorial

Parte da seção Lógica & Fluxo do Journey de Dart da Coddy — lição 49 de 65.

O fatorial de um número é uma operação matemática clássica que é perfeita para demonstrar a recursão. O fatorial de um número inteiro positivo n (escrito como n!) é o produto de todos os números inteiros positivos de 1 a n. Por exemplo, 5! = 5 × 4 × 3 × 2 × 1 = 120.

O que torna o fatorial ideal para a recursão é que ele se divide naturalmente em problemas menores e idênticos. Para calcular 5!, você pode pensar nisso como 5 × 4!. E 4! é apenas 4 × 3!, e assim por diante. Esse padrão continua até você chegar a 1!, que é igual a 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Caso base
  }
  
  return n * factorial(n - 1); // Passo recursivo
}

O caso base interrompe a recursão quando n <= 1, retornando 1. O passo recursivo multiplica o número atual pelo fatorial do próximo número menor. Quando você chama factorial(5), ele retorna 5 * factorial(4), que retorna 5 * 4 * factorial(3), e assim por diante até atingir o caso base.

Esta abordagem demonstra como a recursão resolve problemas de forma elegante ao reduzi-los a versões mais simples do mesmo problema, tornando cálculos complexos naturais e intuitivos.

Desafio

Fácil

Crie um programa que calcule fatoriais para múltiplos números usando recursão. Seu programa demonstrará a função fatorial recursiva processando uma lista de números e computando seus fatoriais.

Leia uma entrada de string contendo números separados por vírgulas (ex: "3,5,0,7")
Divida a string de entrada em números individuais e converta cada um para um número inteiro
Crie uma função recursiva chamada factorial que recebe um parâmetro inteiro n
A função factorial deve implementar a seguinte lógica:

Caso base: Se n for menor ou igual a 1, retorne 1
Passo recursivo: Retorne n multiplicado por factorial(n - 1)

Para cada número na lista de entrada, calcule seu fatorial usando sua função recursiva
Exiba os resultados mostrando cada número e seu fatorial correspondente
Calcule e exiba a soma de todos os resultados fatoriais

Por exemplo, se a entrada for "4,3,2", seu programa deve exibir:

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

Se a entrada for "5,0,1", seu programa deve exibir:

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

Se a entrada for "6", seu programa deve exibir:

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

Seu programa deve implementar a função recursiva factorial que chama a si mesma com valores decrementados até atingir o caso base. A função deve demonstrar como a recursão decompõe o cálculo do fatorial em subproblemas menores e idênticos. Use interpolação de string para formatar os resultados do fatorial como "$n! = $result". Lembre-se que 0! é igual a 1 por definição matemática, o que seu caso base deve tratar corretamente.

Folha de consulta

O fatorial de um número inteiro positivo n (escrito como n!) é o produto de todos os números inteiros positivos de 1 a n. Por exemplo, 5! = 5 × 4 × 3 × 2 × 1 = 120.

O fatorial é ideal para recursão porque se divide em problemas menores e idênticos: 5! = 5 × 4!, e 4! = 4 × 3!, continuando até chegar a 1! = 1.

int factorial(int n) {
  if (n <= 1) {
    return 1; // Caso base
  }
  
  return n * factorial(n - 1); // Passo recursivo
}

O caso base interrompe a recursão quando n <= 1, retornando 1. O passo recursivo multiplica o número atual pelo fatorial do próximo número menor.

Experimente você mesmo

import 'dart:io';

// TODO: Crie sua função fatorial recursiva aqui

void main() {
  // Lê a string de entrada contendo números separados por vírgula
  String? input = stdin.readLineSync();
  
  // Divide a entrada e converte para inteiros
  List<int> numbers = input!.split(',').map((str) => int.parse(str.trim())).toList();
  
  // TODO: Escreva seu código abaixo para:
  // 1. Processar cada número usando sua função fatorial
  // 2. Calcular a soma de todos os fatoriais
  // 3. Exibir os resultados no formato exigido
  
  print("Factorial Calculator");
  print("====================");
  print("Processing numbers: $numbers");
  print("====================");
  print("Factorial Results:");
  
  // TODO: Calcule e exiba os resultados do fatorial aqui
  
  print("====================");
  // TODO: Exibir a soma de todos os fatoriais
  print("Calculation completed successfully");
}