Lösungen: Bonus - Fortgeschrittene Übungen

String-Manipulation

Lösung Bonus 7: String umkehren

def string_umkehren(text):
    """Kehrt einen String um."""
    return text[::-1]

Alternative (mit Schleife):

def string_umkehren(text):
    """Kehrt einen String um."""
    ergebnis = ""
    for zeichen in text:
        ergebnis = zeichen + ergebnis  # Zeichen vor die bisherigen setzen
    return ergebnis

Alternative (mit reversed):

def string_umkehren(text):
    """Kehrt einen String um."""
    return "".join(reversed(text))

Erklärung:

• [::-1] ist Slicing mit Schritt -1 (rückwärts)
• "Hallo" → "ollaH"
• "Python" → "nohtyP"

---

Lösung Bonus 8: Wörter zählen

def woerter_zaehlen(text):
    """Zählt die Anzahl der Wörter in einem String."""
    return len(text.split())

Erklärung:

• split() teilt den String an Leerzeichen und gibt eine Liste von Wörtern zurück
• len() zählt die Anzahl der Elemente in der Liste
• Beispiele:
  • "Hallo Welt" → split() → ["Hallo", "Welt"] → len() → 2
  • "Python ist toll" → split() → ["Python", "ist", "toll"] → len() → 3

---

Lösung Bonus 9: Palindrom-Checker

def ist_palindrom(wort):
    """Prüft, ob ein Wort ein Palindrom ist."""
    return wort == wort[::-1]

Alternative (mit Schleife):

def ist_palindrom(wort):
    """Prüft, ob ein Wort ein Palindrom ist."""
    umgekehrt = ""
    for zeichen in wort:
        umgekehrt = zeichen + umgekehrt
    return wort == umgekehrt

Erklärung:

• Ein Palindrom liest sich vorwärts und rückwärts gleich
• Wir vergleichen das Wort mit seiner umgekehrten Version
• Beispiele:
  • "anna" → "anna" (gleich) → True
  • "rentner" → "rentner" (gleich) → True
  • "hallo" → "ollah" (unterschiedlich) → False

---

Lösung Bonus 17: Anagramm-Checker

def sind_anagramme(wort1, wort2):
    """Prüft, ob zwei Wörter Anagramme sind."""
    return sorted(wort1) == sorted(wort2)

Alternative (mit Counter):

from collections import Counter

def sind_anagramme(wort1, wort2):
    """Prüft, ob zwei Wörter Anagramme sind."""
    return Counter(wort1) == Counter(wort2)

Alternative (manuell):

def sind_anagramme(wort1, wort2):
    """Prüft, ob zwei Wörter Anagramme sind."""
    # Länge muss gleich sein
    if len(wort1) != len(wort2):
        return False

    # Jeder Buchstabe muss gleich oft vorkommen
    for buchstabe in wort1:
        if wort1.count(buchstabe) != wort2.count(buchstabe):
            return False

    return True

Erklärung:

• Anagramme enthalten die gleichen Buchstaben in anderer Reihenfolge
• sorted() sortiert die Buchstaben alphabetisch
• Wenn die sortierten Buchstaben gleich sind, sind es Anagramme
• Beispiele:
  • "listen" → sorted → ['e', 'i', 'l', 'n', 's', 't']
  • "silent" → sorted → ['e', 'i', 'l', 'n', 's', 't']
  • Listen sind gleich → True

---

Datenstrukturen (Dictionaries)

Lösung Bonus 12: Häufigkeiten zählen

def haeufigkeit_zaehlen(liste):
    """Zählt die Häufigkeit jedes Elements."""
    haeufigkeit = {}

    for element in liste:
        if element in haeufigkeit:
            haeufigkeit[element] += 1
        else:
            haeufigkeit[element] = 1

    return haeufigkeit

Alternative (mit get):

def haeufigkeit_zaehlen(liste):
    """Zählt die Häufigkeit jedes Elements."""
    haeufigkeit = {}

    for element in liste:
        haeufigkeit[element] = haeufigkeit.get(element, 0) + 1

    return haeufigkeit

Alternative (mit Counter):

from collections import Counter

def haeufigkeit_zaehlen(liste):
    """Zählt die Häufigkeit jedes Elements."""
    return dict(Counter(liste))

Erklärung:

• Wir iterieren über alle Elemente
• Für jedes Element erhöhen wir den Zähler im Dictionary
• get(element, 0) gibt den aktuellen Wert zurück oder 0, wenn der Key nicht existiert
• Beispiel: ["a", "b", "a"] →

---

Lösung Bonus 16: Dictionaries zusammenführen

def dictionaries_zusammenfuehren(dict1, dict2):
    """Führt zwei Dictionaries zusammen."""
    ergebnis = dict1.copy()  # Kopie von dict1 erstellen

    for key, value in dict2.items():
        ergebnis[key] = value  # Werte von dict2 überschreiben

    return ergebnis

Alternative (mit update):

def dictionaries_zusammenfuehren(dict1, dict2):
    """Führt zwei Dictionaries zusammen."""
    ergebnis = dict1.copy()
    ergebnis.update(dict2)
    return ergebnis

Alternative (Python 3.9+):

def dictionaries_zusammenfuehren(dict1, dict2):
    """Führt zwei Dictionaries zusammen."""
    return dict1 | dict2

Alternative (Dictionary Unpacking):

def dictionaries_zusammenfuehren(dict1, dict2):
    """Führt zwei Dictionaries zusammen."""
    return {**dict1, **dict2}

Erklärung:

• Wir starten mit einer Kopie von dict1
• Dann fügen wir alle Einträge von dict2 hinzu
• Bei doppelten Keys wird der Wert aus dict2 verwendet
• Beispiele:
  • {"a": 1} + {"b": 2} → {"a": 1, "b": 2}
  • {"a": 1} + {"a": 2} → {"a": 2} (Überschreiben)