Fakultät Rechner

🔢 Grundlegende Eigenschaften

Wichtige mathematische Eigenschaften der Fakultät:

\[\text{Definition: } n! = \prod_{k=1}^{n} k = 1 \times 2 \times 3 \times \cdots \times n\] \[\text{Rekursion: } n! = n \times (n-1)! \text{ für } n \geq 1\] \[\text{Basis: } 0! = 1 \text{ (per Definition)}\] \[\text{Stirling-Näherung: } n! \approx \sqrt{2\pi n} \left(\frac{n}{e}\right)^n \text{ für große } n\] \[\text{Wachstumsrate: } \lim_{n \to \infty} \frac{(n+1)!}{n!} = \lim_{n \to \infty} (n+1) = \infty\]

🔄 Verbindung zur Gamma-Funktion

Erweiterung auf reelle Zahlen:

\[\text{Gamma-Funktion: } \Gamma(n) = (n-1)! \text{ für natürliche Zahlen } n\] \[\text{Allgemein: } \Gamma(z) = \int_0^{\infty} t^{z-1} e^{-t} \, dt\] \[\text{Rekursion: } \Gamma(z+1) = z \cdot \Gamma(z)\] \[\text{Spezialwerte: } \Gamma(1) = 0! = 1, \quad \Gamma\left(\frac{1}{2}\right) = \sqrt{\pi}\]

📊 Wichtige Werte

Häufig verwendete Fakultäten:

\[0! = 1\] \[1! = 1\] \[2! = 2\] \[3! = 6\] \[4! = 24\] \[5! = 120\] \[10! = 3{.}628{.}800\] \[13! = 6{.}227{.}020{.}800\]

📝 Beispiel 1: Wettbewerb mit 6 Teilnehmern

Aufgabe: Anzahl möglicher Zieleinläufe
Gegeben: 6 unterscheidbare Teilnehmer
Berechnung:

\[\text{Anzahl Permutationen} = 6!\] \[6! = 6 \times 5 \times 4 \times 3 \times 2 \times 1 = 720\] \[\text{Schritt für Schritt:}\] \[\text{1. Platz: } 6 \text{ Möglichkeiten}\] \[\text{2. Platz: } 5 \text{ Möglichkeiten}\] \[\text{3. Platz: } 4 \text{ Möglichkeiten}\] \[\text{...und so weiter}\]

Interpretation: Es gibt 720 verschiedene Möglichkeiten für den Zieleinlauf

📝 Beispiel 2: Anordnung von Büchern

Aufgabe: Anordnungen von 5 verschiedenen Büchern im Regal
Szenario: Alle Bücher sind unterscheidbar
Berechnung:

\[\text{Anzahl Anordnungen} = 5! = 5 \times 4 \times 3 \times 2 \times 1 = 120\] \[\text{Wenn 2 Bücher identisch wären: } \frac{5!}{2!} = \frac{120}{2} = 60\] \[\text{Bei 3 identischen Büchern: } \frac{5!}{3!} = \frac{120}{6} = 20\]

Anwendung: Permutationen mit Wiederholungen

📝 Beispiel 3: Passwort-Sicherheit

Aufgabe: Anzahl möglicher Passwortkombinationen
Gegeben: 8-stelliges Passwort aus 8 verschiedenen Zeichen
Berechnung:

\[\text{Bei 8 verschiedenen Zeichen: } 8! = 40{.}320\] \[\text{Bei 26 Buchstaben (ohne Wiederholung): } \frac{26!}{(26-8)!} = \frac{26!}{18!}\] \[= 26 \times 25 \times 24 \times 23 \times 22 \times 21 \times 20 \times 19\] \[= 62{.}990{.}928{.}000\]

Bedeutung: Permutationen vs. Variationen bei der Passwort-Generierung

💻 Code-Implementierungen

Effiziente Implementierung der Fakultät:

Python:
import math

# Built-in Fakultät
result = math.factorial(n)

# Iterative Implementierung
def factorial_iterative(n):
  if n < 0:
    raise ValueError("Fakultät nur für n >= 0 definiert")
  result = 1
  for i in range(1, n + 1):
    result *= i
  return result

# Rekursive Implementierung
def factorial_recursive(n):
  if n < 0:
    raise ValueError("Fakultät nur für n >= 0 definiert")
  if n <= 1:
    return 1
  return n * factorial_recursive(n - 1)

# Stirling-Näherung
def stirling_approximation(n):
  if n == 0:
    return 1
  return math.sqrt(2 * math.pi * n) * (n / math.e) ** n

JavaScript:
function factorial(n) {
  if (n < 0) throw new Error("Fakultät nur für n >= 0");
  let result = 1;
  for (let i = 2; i <= n; i++) {
    result *= i;
  }
  return result;
}

C++:
#include <iostream>
unsigned long long factorial(int n) {
  if (n < 0) throw std::invalid_argument("n must be >= 0");
  unsigned long long result = 1;
  for (int i = 2; i <= n; ++i) {
    result *= i;
  }
  return result;
}

🎯 Kombinatorik-Toolkit

Werkzeuge für kombinatorische Berechnungen:

Python Kombinatorik-Klasse:
import math

class Combinatorics:
  @staticmethod
  def factorial(n):
    """Fakultät n!"""
    return math.factorial(n)
  
  @staticmethod
  def permutations(n, r=None):
    """Permutationen P(n,r) = n!/(n-r)!"""
    if r is None:
      r = n
    return math.factorial(n) // math.factorial(n - r)
  
  @staticmethod
  def combinations(n, r):
    """Kombinationen C(n,r) = n!/(r!(n-r)!)"""
    return math.factorial(n) // (math.factorial(r) * math.factorial(n - r))
  
  @staticmethod
  def double_factorial(n):
    """Doppelfakultät n!!"""
    if n <= 0:
      return 1
    result = 1
    while n > 0:
      result *= n
      n -= 2
    return result

# Beispiele
comb = Combinatorics()
print(f"5! = {comb.factorial(5)}") # 120
print(f"P(6,3) = {comb.permutations(6, 3)}") # 120
print(f"C(6,3) = {comb.combinations(6, 3)}") # 20
print(f"5!! = {comb.double_factorial(5)}") # 15

🎯 Große Fakultäten

Umgang mit sehr großen Fakultäten:

Python mit Decimal für hohe Präzision:
from decimal import Decimal, getcontext
import math

# Präzision erhöhen
getcontext().prec = 100

def big_factorial(n):
  """Fakultät mit hoher Präzision"""
  if n < 0:
    raise ValueError("n must be >= 0")
  result = Decimal(1)
  for i in range(2, n + 1):
    result *= Decimal(i)
  return result

def log_factorial(n):
  """Logarithmus der Fakultät (vermeidet Overflow)"""
  if n < 0:
    raise ValueError("n must be >= 0")
  return math.lgamma(n + 1) # log(n!)

def stirling_log_factorial(n):
  """Stirling-Näherung für log(n!)"""
  if n == 0:
    return 0
  return n * math.log(n) - n + 0.5 * math.log(2 * math.pi * n)

# Vergleich für große n
n = 100
exact = log_factorial(n)
approx = stirling_log_factorial(n)
error = abs(exact - approx) / exact
print(f"log({n}!) exakt: {exact:.6f}")
print(f"Stirling: {approx:.6f}")
print(f"Relativer Fehler: {error:.2e}")