file pasta log
This commit is contained in:
1 parent
a19247bf37
commit
e4264d88fa
2 files changed
+85
-29
No files matched your search
@@ -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
@@ -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)
|
||||
Reference in new issue
Block a user