file pasta log

This commit is contained in:
englingvi103466 committed 2026-11-12 12:38:43 +01:00
1 parent a19247bf37
commit e4264d88fa
2 files changed
+85 -29

No files matched your search

+9
View File
@@ -0,0 +1,9 @@
2026-11-12 12:31:51,694 [INFO] Alice hat Hunger und versucht, die linke Gabel zu bekommen.
2026-11-12 12:31:51,694 [INFO] Alice hat die linke Gabel erhalten.
2026-11-12 12:31:51,695 [INFO] Bob hat Hunger und versucht, die linke Gabel zu bekommen.
2026-11-12 12:31:51,695 [INFO] Bob hat die linke Gabel erhalten.
2026-11-12 12:31:51,695 [INFO] Charlie hat Hunger und versucht, die linke Gabel zu bekommen.
2026-11-12 12:31:51,695 [INFO] Charlie hat die linke Gabel erhalten.
2026-11-12 12:31:51,975 [INFO] Bob versucht, die rechte Gabel zu bekommen.
2026-11-12 12:31:51,976 [INFO] Charlie versucht, die rechte Gabel zu bekommen.
2026-11-12 12:31:51,976 [INFO] Alice versucht, die rechte Gabel zu bekommen.
+76 -29
View File
@@ -1,36 +1,83 @@
from functools import lru_cache
from timing import timing
import functools
import time
def count_change_memoized(amount, coins=(1, 2, 5, 10, 20, 50)):
"""Münzwechsel-Problem mit LRU-Cache für Performanz-Optimierung."""
# ==========================================
# 1. TIMING-DECORATOR ZUR LAUFZEITMESSUNG
# ==========================================
def timing(func):
"""Ein Decorator, der die Ausführungszeit einer Funktion misst
# Der lru_cache speichert bereits berechnete Ergebnisse für bestimmte (n, coin_index)-Tupel,
# wodurch doppelte Berechnungen vermieden und die Laufzeit drastisch verbessert wird.
@lru_cache(maxsize=None)
def helper(n, coin_index):
# Basisfall 1: Der Betrag wurde exakt auf 0 reduziert -> gültige Kombination gefunden
if n == 0:
return 1
# Basisfall 2: Betrag ist negativ (ungültig) oder es sind keine Münzen mehr im Array übrig
if n < 0 or coin_index >= len(coins):
return 0
# Rekursiver Schritt (aufgeteilt in zwei Äste):
# 1. Aktuelle Münze verwenden: Wir subtrahieren den Münzwert vom Betrag ('n - coins[...]')
# und bleiben beim selben Index, da Münzen mehrfach verwendet werden dürfen.
# 2. Aktuelle Münze überspringen: Der Betrag 'n' bleibt gleich, aber wir gehen zum nächsten
# Münzindex über ('coin_index + 1').
return helper(n - coins[coin_index], coin_index) + helper(
n, coin_index + 1
und auf der Konsole ausgibt.
"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
result = func(*args, **kwargs)
end = time.perf_counter()
print(
f"{func.__name__}({args[0]}) dauerte {(end - start) * 1000:.4f}"
" Millisekunden."
)
return result
# Start der Rekursion mit dem Zielbetrag und dem ersten Münzindex (0)
return helper(amount, 0)
return wrapper
# Testen des Codes mit Zeitmessung über den @timing-Decorator
betrag = 100
anzahl = timing(count_change_memoized)(betrag)
print(f"Möglichkeiten für {betrag} Cent: {anzahl}")
# ==========================================
# 2. SOPHIAS URSPRÜNGLICHE REKURSIVE FUNKTION
# ==========================================
@timing
def coins(n):
"""Sophias rekursive Funktion zur Berechnung der Möglichkeiten
(bzw. geordneten Zerlegungen/Permutationen) für einen Betrag n.
Erklärung:
- Wenn n == 0: Genau 1 Möglichkeit (der Betrag wurde exakt erreicht).
- Wenn n < 0: 0 Möglichkeiten (der Betrag wurde überschritten).
- Andernfalls summiert sich die Anzahl der Möglichkeiten aus den
verbleibenden Beträgen nach Abzug einer 1er-, 2er- oder 5er-Münze.
"""
if n == 0:
return 1
if n < 0:
return 0
return coins(n - 1) + coins(n - 2) + coins(n - 5)
# ==========================================
# 3. OPTIMIERTE FUNKTION MIT MEMOIZATION
# ==========================================
@timing
@functools.lru_cache(maxsize=None)
def coins_memo(n):
"""Optimierte Variante mit @functools.lru_cache.
Warum das hilft (Memoization):
- Ohne Cache berechnet die reine Rekursion denselben Teilbaum
(z.B. coins(3)) tausendfach neu (exponentielles Wachstum O(3^n)).
- Der Cache merkt sich einmal berechnete Ergebnisse. Wird derselbe
Wert nochmal abgefragt, liefert Python ihn sofort in O(1)-Zeit
zurück. Die Laufzeit sinkt dadurch drastisch auf linear O(n).
"""
if n == 0:
return 1
if n < 0:
return 0
return coins_memo(n - 1) + coins_memo(n - 2) + coins_memo(n - 5)
# ==========================================
# AUSFÜHRUNG & VERGLEICH
# ==========================================
if __name__ == "__main__":
print("--- Ohne Memoization ---")
# Bei kleinen Werten läuft es noch schnell, bei höheren (ab ca. n=35)
# bricht die Performance ein, weil sich die Rekursion totläuft.
coins(15)
print("\n--- Mit Memoization ---")
# Selbst große Beträge wie n=100 werden dank des Caches
# in Bruchteilen einer Millisekunde gelöst.
coins_memo(100)