hausaufgaben als normalen Ordner einchecken, .venv entfernen

This commit is contained in:
wittmannzl103469 committed 2026-11-04 21:13:09 +01:00
1 parent d3389992aa
commit de41a02749
7 files changed
+274 -1

No files matched your search

Submodule aufgaben/einstellung/pr_aufgaben/hausaufgaben deleted from 728dd0b739.
@@ -0,0 +1,14 @@
1000
2000
3000
4000
5000
6000
7000
8000
9000
10000
@@ -0,0 +1,35 @@
from functools import reduce
def read_input(path):
# Einzige Funktion mit Seiteneffekt (Dateizugriff)
with open(path) as f:
return f.read()
def parse(data):
# Text -> Liste von Gruppen -> Liste von Zahlenlisten
# strip() entfernt den Zeilenumbruch am Dateiende
groups = data.strip().split("\n\n")
return list(map(lambda g: list(map(int, g.split("\n"))), groups))
def group_sums(data):
# Pro Gruppe die Summe bilden
return list(map(sum, parse(data)))
def max_calories(data):
# Maximum mit reduce: immer den größeren von zwei Werten behalten
return reduce(lambda a, b: a if a > b else b, group_sums(data))
def top_three(data):
# sorted erzeugt eine neue Liste, die Originalliste bleibt unverändert
return sum(sorted(group_sums(data), reverse=True)[:3])
if __name__ == "__main__":
data = read_input("beispiel.txt")
print(max_calories(data)) # Teil 1
print(top_three(data)) # Teil 2
@@ -0,0 +1,98 @@
"""Basisklasse ``Game`` für einfache pygame-Anwendungen."""
import pygame
class Game:
"""Basisklasse für pygame-Spiele.
Unterklassen passen das Verhalten durch Überschreiben von
:meth:`handle_event`, :meth:`update_game` und :meth:`draw_game` an.
"""
def __init__(
self,
title: str,
fps: int = 60,
size: tuple[int, int] = (640, 400),
) -> None:
"""Legt Fenstertitel, Bildrate und Fenstergröße fest.
Args:
title: Titel des Fensters.
fps: Maximale Bilder pro Sekunde.
size: Fenstergröße als (Breite, Höhe) in Pixeln.
"""
self.title: str = title
self.fps: int = fps
self.size: tuple[int, int] = size
self.clock: pygame.time.Clock = pygame.time.Clock()
self.dt: float = 0
self.screen: pygame.Surface | None = None
def init_game(self) -> None:
"""Initialisiert pygame und erzeugt das Fenster."""
pygame.init()
pygame.display.set_caption(self.title)
self.screen = pygame.display.set_mode(self.size)
def game_loop(self) -> None:
"""Führt die Hauptschleife aus, bis Events oder Update ``False`` liefern."""
while True:
# Berechnung der Zeitdifferenz seit dem letzten Frame
self.dt = self.clock.tick(self.fps) / 1000
if self.event_handling() == False:
break
if self.update_game() == False:
break
self.draw_game()
def exit_game(self) -> None:
"""Beendet pygame."""
pygame.quit()
def event_handling(self) -> bool:
"""Verteilt alle anstehenden Events an :meth:`handle_event`.
Bleibt in der Unterklasse unverändert.
Returns:
``False``, sobald ein Event das Spiel beenden soll, sonst ``True``.
"""
for event in pygame.event.get():
if not self.handle_event(event):
return False
return True
def handle_event(self, event: pygame.event.Event) -> bool:
"""Verarbeitet ein einzelnes Event.
Wird in der Unterklasse überschrieben.
Args:
event: Das zu verarbeitende pygame-Event.
Returns:
``False`` bei ``pygame.QUIT``, sonst ``True``.
"""
if event.type == pygame.QUIT:
return False
return True
def update_game(self) -> bool:
"""Aktualisiert den Spielzustand um einen Frame.
Returns:
``False``, wenn das Spiel beendet werden soll, sonst ``True``.
"""
return True
def draw_game(self) -> None:
"""Zeichnet den aktuellen Frame und bringt ihn zur Anzeige."""
pygame.display.flip()
def run(self) -> None:
"""Startet das Spiel: Initialisierung, Hauptschleife, Beenden."""
self.init_game()
self.game_loop()
self.exit_game()
@@ -0,0 +1,21 @@
from calorie_counting import parse, group_sums, max_calories, top_three
BEISPIEL = "1\n2\n\n5\n\n3\n4\n\n10\n\n6\n"
def test_parse():
# Drei Gruppen: zwei Zahlen, eine Zahl, zwei Zahlen usw.
assert parse("1\n2\n\n5") == [[1, 2], [5]]
def test_group_sums():
assert group_sums(BEISPIEL) == [3, 5, 7, 10, 6]
def test_max_calories():
assert max_calories(BEISPIEL) == 10
def test_top_three():
# 10 + 7 + 6
assert top_three(BEISPIEL) == 23
@@ -0,0 +1,28 @@
from undo_doodle import start_stroke, extend_stroke, push_history, undo, MAX_HISTORY
def test_strich_erzeugt_neuen_zustand():
s0 = []
s1 = start_stroke(s0, (1, 1))
s2 = extend_stroke(s1, (2, 2))
assert s0 == [] # alter Zustand unverändert
assert s1 == [[(1, 1)]] # s1 auch unverändert nach extend
assert s2 == [[(1, 1), (2, 2)]]
def test_undo_stellt_vorzustand_wieder_her():
s0 = []
history = push_history([], s0)
s1 = start_stroke(s0, (1, 1))
state, history = undo(s1, history)
assert state == []
assert history == []
def test_historie_ist_begrenzt():
history = []
for i in range(10):
history = push_history(history, [i])
assert len(history) == MAX_HISTORY
@@ -0,0 +1,78 @@
import pygame
from game import Game
MAX_HISTORY = 5
# --- Reine Funktionen: verändern nichts, sondern erzeugen neue Objekte ---
def start_stroke(state, pos):
"""Neuer Strich mit einem Startpunkt: neue Liste von Strichen."""
return state + [[pos]]
def extend_stroke(state, pos):
"""Letzten Strich um einen Punkt erweitern: neue Liste, alte bleibt."""
if not state:
return state
new_last = state[-1] + [pos] # neuer Strich (neue Liste)
return state[:-1] + [new_last] # neuer Zustand (neue Liste)
def push_history(history, state):
"""Zustand in die Historie legen, nur die letzten MAX_HISTORY behalten."""
return (history + [state])[-MAX_HISTORY:]
def undo(state, history):
"""Letzten Zustand aus der Historie holen. Liefert (state, history)."""
if not history:
return state, history
return history[-1], history[:-1]
class Doodle(Game):
def __init__(self):
super().__init__("Undo Doodle", fps=60, size=(640, 400))
self.state = [] # Liste von Strichen, jeder Strich = Liste von Punkten
self.history = [] # Liste früherer Zustände (max. 5)
self.pen_down = False # Stift abgesenkt?
def handle_event(self, event):
# QUIT wird von der Basisklasse behandelt
if not super().handle_event(event):
return False
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
# Stift absenken: alten Zustand merken, neuen Strich beginnen
self.history = push_history(self.history, self.state)
self.state = start_stroke(self.state, event.pos)
self.pen_down = True
elif event.type == pygame.MOUSEMOTION and self.pen_down:
# Bei abgesenktem Stift: Mausposition an den letzten Strich hängen
self.state = extend_stroke(self.state, event.pos)
elif event.type == pygame.MOUSEBUTTONUP and event.button == 1:
# Stift anheben: Strich ist beendet
self.pen_down = False
elif event.type == pygame.KEYDOWN and event.key == pygame.K_BACKSPACE:
# Letzten Strich rückgängig machen
self.state, self.history = undo(self.state, self.history)
return True
def draw_game(self):
self.screen.fill("white")
for stroke in self.state:
if len(stroke) == 1:
# Klick ohne Bewegung: kleiner Punkt
pygame.draw.circle(self.screen, "black", stroke[0], 2)
else:
pygame.draw.lines(self.screen, "black", False, stroke, 2)
super().draw_game() # display.flip()
if __name__ == "__main__":
Doodle().run()