Seminar - Exam.pdf

Aufgabe 1)

Betrachte die folgende formale Sprache L = {a^n b^n | n ≥ 0}. Diese Sprache besteht aus Strings, die aus einer beliebigen Anzahl von 'a'-Zeichen gefolgt von der gleichen Anzahl von 'b'-Zeichen bestehen.

a)

Zeige, dass die Sprache L nicht regulär ist. Verwende dazu das Pumping-Lemma für reguläre Sprachen. Beschreibe die Schritte und Argumentation detailliert.

Lösung:

Um zu zeigen, dass die Sprache L = {aⁿbⁿ | n ≥ 0} nicht regulär ist, werden wir das Pumping-Lemma für reguläre Sprachen verwenden. Das Pumping-Lemma besagt, dass für jede reguläre Sprache L ein „Pumping-Length“ p existiert, so dass jeder String w in L mit der Länge mindestens p in drei Teile w = xyz zerlegt werden kann, wobei folgende Bedingungen gelten:

• 1. xyⁱz ist für alle i ≥ 0 in L.
• 2. |y| > 0.
• 3. |xy| ≤ p.

Nun erfolgen die detaillierten Schritte der Argumentation:

• 1. Angenommen, die Sprache L ist regulär. Das bedeutet, dass es eine Pumping-Length p gibt, die das Pumping-Lemma erfüllt.
• 2. Betrachte nun den String w = a^pb^p. Dieser String gehört zur Sprache L und hat eine Länge von 2p, die größer oder gleich p ist.
• 3. Gemäß dem Pumping-Lemma kann man w in drei Teile w = xyz zerlegen, wobei |xy| ≤ p und |y| > 0. Das bedeutet, dass der Teil y nur aus 'a'-Zeichen besteht, da die ersten p Zeichen von w nur 'a' sind.
• 4. Da y nicht leer ist, muss y = a^k für ein k > 0 sein.
• 5. Betrachte nun den String w' = xy²z. Das bedeutet, dass wir y doppelt pumpen und erhalten w' = a^p+kb^p.
• 6. Dieser String hat p + k 'a'-Zeichen gefolgt von p 'b'-Zeichen. Aber dieser String gehört nicht zur Sprache L, da die Anzahl der 'a'-Zeichen nicht gleich der Anzahl der 'b'-Zeichen ist.
• 7. Dies widerspricht der Annahme, dass L regulär ist.

Da unsere Annahme zur Annahme führt, dass es einen Widerspruch gibt, muss die Sprache L nicht regulär sein.

b)

Definiere eine kontextfreie Grammatik, die die Sprache L erzeugt. Schreibe die Produktionsregeln der Grammatik hin.

Lösung:

Um eine kontextfreie Grammatik (CFG) zu definieren, die die Sprache L = {aⁿbⁿ | n ≥ 0} erzeugt, benötigen wir Regeln, die sicherstellen, dass jede Anzahl von 'a'-Zeichen von der gleichen Anzahl von 'b'-Zeichen gefolgt wird.

Die kontextfreie Grammatik G kann durch die folgende Produktionsregeln definiert werden:

• G = (V, Σ, R, S)
• V (Menge der Nichtterminalzeichen): {S}
• Σ (Menge der Terminalzeichen): {a, b}
• R (Menge der Produktionsregeln):
• 1. S → aSb
• 2. S → ε (das leere Wort)
• S (Startsymbol): S

Die Produktionsregeln können wie folgt erläutert werden:

• 1. Die Regel S → aSb fügt sicher die gleiche Anzahl von 'a' und 'b' hinzu und stellt sicher, dass jedes 'a' von einem entsprechenden 'b' gefolgt wird.
• 2. Die Regel S → ε erlaubt die Generierung des leeren Wortes, das in der Sprache enthalten ist, da n auch 0 sein kann.

Diese Produktionsregeln gewährleisten, dass jeder String in der Sprache L durch eine Folge von Produktionsschritten aus dem Startsymbol S erzeugt werden kann.

c)

Entwirf einen Kellerautomaten (Pushdown Automaton, PDA), der die Sprache L akzeptiert. Beschreibe die Zustände, Übergänge und das Verhalten des Kellerautomaten.

Lösung:

Ein Kellerautomat (Pushdown Automaton, PDA) für die Sprache L = {aⁿbⁿ | n ≥ 0} kann wie folgt entworfen werden. Der PDA nutzt den Keller, um die Anzahl der 'a'-Zeichen zu zählen und überprüft danach, ob die Anzahl der 'b'-Zeichen übereinstimmt.

Ein formaler PDA P kann als P = (Q, Σ, Γ, δ, q₀, Z₀, F) definiert werden, wobei:

• Q: Menge der Zustände
• Σ: Eingabealphabet {a, b}
• Γ: Kelleralphabet {A, Z₀}
• δ: Übergangsfunktion
• q₀: Startzustand
• Z₀: Anfangssymbol im Keller
• F: Menge der akzeptierenden Zustände

Der PDA kann wie folgt definiert werden:

• Q = {q₀, q₁, q₂, q_f}
• Σ = {a, b}
• Γ = {A, Z₀}
• q₀ (Startzustand)
• Z₀ (Anfangssymbol im Keller)
• F = {q_f}

Übergangsfunktion δ:

• 1. δ(q₀, ε, Z₀) = {(q_f, Z₀)}
• 2. δ(q₀, a, Z₀) = {(q₁, AZ₀)}
• 3. δ(q₁, a, A) = {(q₁, AA)}
• 4. δ(q₁, b, A) = {(q₂, ε)}
• 5. δ(q₂, b, A) = {(q₂, ε)}
• 6. δ(q₂, ε, Z₀) = {(q_f, Z₀)}

Beschreibung des Verhaltens:

• 1. Der Automat startet im Zustand q₀ mit dem Anfangssymbol Z₀ im Keller.
• 2. Im Zustand q₀ kann er entweder direkt in den akzeptierenden Zustand q_f (durch ε-Übergang) wechseln, um den leeren String zu akzeptieren, oder er wechselt in den Zustand q₁, wenn er ein 'a' liest und legt ein 'A' in den Keller.
• 3. Im Zustand q₁ liest der Automat jedes weitere 'a' und legt für jedes 'a' ein 'A' auf den Keller.
• 4. Wenn der Automat ein 'b' im Zustand q₁ liest, wechselt er in den Zustand q₂ und entfernt ein 'A' aus dem Keller.
• 5. Im Zustand q₂ liest der Automat jedes weitere 'b' und entfernt für jedes 'b' ein 'A' aus dem Keller.
• 6. Wenn der Keller im Zustand q₂ leer ist (wenn er auf Z₀ trifft), wechselt der Automat in den akzeptierenden Zustand q_f.

Auf diese Weise akzeptiert der Kellerautomat die Sprache L.

Aufgabe 2)

Untersuchung der Effizienz von Algorithmen: In dieser Aufgabe wirst Du die Effizienz von Algorithmen in Bezug auf ihre benötigten Ressourcen wie Zeit und Speicher untersuchen. Du wirst die Komplexitätsklassen P, NP, NP-komplett und NP-schwer, die Zeitkomplexität und die Raumkomplexität beachten. Zudem werden wir Reduktionen und ihre Rolle in der Komplexitätstheorie untersuchen sowie die Polynomialzeitreduktion anwenden.

a)

Angenommen, Du hast einen Algorithmus, der das Problem des kürzesten Pfades in einem gewichteten Graphen löst.

• Beschreibe, in welcher Komplexitätsklasse (P, NP, NP-komplett, NP-schwer) sich dieses Problem befindet und warum.

Lösung:

Untersuchung der Effizienz von Algorithmen: In dieser Aufgabe wirst Du die Effizienz von Algorithmen in Bezug auf ihre benötigten Ressourcen wie Zeit und Speicher untersuchen. Du wirst die Komplexitätsklassen P, NP, NP-komplett und NP-schwer, die Zeitkomplexität und die Raumkomplexität beachten. Zudem werden wir Reduktionen und ihre Rolle in der Komplexitätstheorie untersuchen sowie die Polynomialzeitreduktion anwenden.Subexercise:Angenommen, Du hast einen Algorithmus, der das Problem des kürzesten Pfades in einem gewichteten Graphen löst.

• Beschreibe, in welcher Komplexitätsklasse (P, NP, NP-komplett, NP-schwer) sich dieses Problem befindet und warum.

• Das Problem des kürzesten Pfades in einem gewichteten Graphen befindet sich in der Komplexitätsklasse P.

• Die Komplexitätsklasse P umfasst Probleme, für die es bekannte Algorithmen gibt, die in polynomialer Zeit hinsichtlich der Grösse der Eingabe gelöst werden können.

• Ein bekanntes Beispiel für einen solchen Algorithmus ist der Dijkstra-Algorithmus, der in O(V^2) Zeit arbeitet, wobei V die Anzahl der Knoten im Graphen ist. Mit geeigneten Datenstrukturen wie dem Fibonacci-Heap kann die Laufzeit auf O(V log V + E) verbessert werden, wobei E die Anzahl der Kanten ist.

• Ein weiteres Beispiel ist der Bellman-Ford-Algorithmus, der für Graphen mit negativen Gewichtungen geeignet ist und eine Laufzeit von O(V * E) hat.

• Da es also effiziente Algorithmen gibt, die das Problem des kürzesten Pfades in polynomialer Zeit lösen können, gehört dieses Problem zur Klasse P.

c)

Erkläre die Bedeutung der Polynomialzeitreduktion in der Komplexitätstheorie.

• Wähle ein Beispielproblem, das NP-vollständig ist, und skizziere, wie man ein anderes NP-Problem (Dein Beispielproblem) mittels einer Polynomialzeitreduktion darauf reduzieren kann.
• Gehe auf die Schritte und die Implikationen der Reduktion ein, um zu zeigen, warum dies die Vollständigkeit des Beispielproblems beweist.

Lösung:

Untersuchung der Effizienz von Algorithmen: In dieser Aufgabe wirst Du die Effizienz von Algorithmen in Bezug auf ihre benötigten Ressourcen wie Zeit und Speicher untersuchen. Du wirst die Komplexitätsklassen P, NP, NP-komplett und NP-schwer, die Zeitkomplexität und die Raumkomplexität beachten. Zudem werden wir Reduktionen und ihre Rolle in der Komplexitätstheorie untersuchen sowie die Polynomialzeitreduktion anwenden.Subexercise: Erkläre die Bedeutung der Polynomialzeitreduktion in der Komplexitätstheorie.

• Wähle ein Beispielproblem, das NP-vollständig ist, und skizziere, wie man ein anderes NP-Problem (Dein Beispielproblem) mittels einer Polynomialzeitreduktion darauf reduzieren kann.
• Gehe auf die Schritte und die Implikationen der Reduktion ein, um zu zeigen, warum dies die Vollständigkeit des Beispielproblems beweist.

• Definition: Eine Polynomialzeitreduktion von einem Problem A zu einem Problem B ist eine Transformation, die Eingaben des Problems A in Eingaben des Problems B in polynomialer Zeit umwandelt, sodass jede Instanz von A genau dann eine Ja-Antwort hat, wenn die transformierte Instanz von B eine Ja-Antwort hat.
• Die Bedeutung der Polynomialzeitreduktion liegt darin, dass sie ein Werkzeug ist, um die Schwierigkeit von Problemen zu vergleichen. Wenn ein Problem A in polynomialer Zeit auf ein anderes Problem B reduziert werden kann und Problem B in NP liegt, dann liegt auch Problem A in NP.

• Beispiel eines NP-vollständigen Problems: Betrachten wir das SAT-Problem (Erfüllbarkeitsproblem der Aussagenlogik), bei dem geprüft wird, ob eine gegebene boolesche Formel erfüllbar ist.
• Ein weiteres bekanntes NP-Problem ist das 3-SAT-Problem, bei dem die Formel in konjunktiver Normalform (CNF) vorliegt und jede Klausel genau drei Literale hat.
• Polynomialzeitreduktion von SAT zu 3-SAT: Um zu zeigen, dass 3-SAT NP-vollständig ist, zeigen wir, dass ein allgemeines SAT-Problem in polynomialer Zeit zu einem 3-SAT-Problem reduziert werden kann.
• Schritt 1: Gegeben eine boolesche Formel in CNF. Wenn jede Klausel bereits drei Literale enthält, keine Änderung erforderlich. Andernfalls, führen wir folgende Transformation durch:
• Eine Klausel mit weniger als drei Literalen (z. B., (A ∨ B)) kann in eine Klausel mit drei Literalen umgewandelt werden, indem ein Dummy-Literal Y hinzugefügt wird. Es wird (A ∨ B ∨ Y) ∧ (~Y) generiert, wobei ~Y als eine „Wahr-Falsch“-Bedingung wirkt.
• Eine Klausel mit mehr als drei Literalen (z. B. (A ∨ B ∨ C ∨ D)) wird in mehrere Klauseln aufgeteilt: (A ∨ B ∨ Z1) ∧ (~Z1 ∨ C ∨ D), wobei Z1 eine neue Variable ist.
• Schritte und Implikationen der Reduktion:
• Indem wir jede Klausel der ursprünglichen Formel durch diese Transformationen ersetzen, wird die resultierende Formel eine äquivalente 3-SAT-Formel, die erfüllbar ist, wenn und nur wenn die ursprüngliche Formel erfüllbar ist.
• Da diese Transformationen in polynomialer Zeit durchgeführt werden können, ist die Reduktion eine Polynomialzeitreduktion.
• Die Implikation dieser Reduktion ist, dass, wenn wir einen polynomialen Algorithmus zur Lösung von 3-SAT hätten, wir diesen Algorithmus auch verwenden könnten, um SAT in polynomialer Zeit zu lösen. Dies beweist, dass SAT in NP ist.
<>
• Da SAT als NP-vollständig bekannt ist, bedeutet dies, dass durch die Reduktion auf 3-SAT wir gezeigt haben, dass 3-SAT ebenfalls NP-vollständig ist.

Aufgabe 3)

Analyse eines Algorithmus: Du hast einen neuen Sortieralgorithmus entwickelt, der wie folgt funktioniert: Der Algorithmus teilt das zu sortierende Array der Größe n in zwei gleich große Teile auf, sortiert dann rekursiv die beiden Hälften und kombiniert schließlich die sortierten Hälften in linearer Zeit. Verwende die gegebenen Informationen zur Algorithmenanalyse, um eine vollständige Analyse der Effizienz dieses Algorithmus durchzuführen.

a)

Teil 1: Bestimme die Zeitkomplexität des Algorithmus im Worst Case. Beginne, indem du die Rekursionsgleichung aufstellst und dann das Master-Theorem anwendest, um die Zeitkomplexität zu bestimmen. Zeige jeden Schritt deiner Berechnung und erkläre die Anwendung des Master-Theorems im Detail.

Lösung:

Teil 1: Bestimme die Zeitkomplexität des Algorithmus im Worst Case.

• Rekursionsgleichung aufstellen:Der Algorithmus teilt das Array der Größe n in zwei gleich große Teile auf, sortiert rekursiv die beiden Hälften und kombiniert schließlich die sortierten Hälften in linearer Zeit. Die Rekursionsgleichung lautet:T(n) = 2T(n/2) + cn, wobei T(n) die Zeitkomplexität ist, und cn die Zeit für das Kombinieren in linearer Zeit ist.
• Anwendung des Master-Theorems:Das Master-Theorem hilft uns, die Rekursionsgleichung der Form T(n) = aT(n/b) + f(n) zu lösen, wobei a = 2, b = 2 und f(n) = cn in unserem Fall sind.
  • Vergleiche f(n) mit n^log_b(a):log₂(2) = 1, somit vergleichen wir f(n) = cn mit n¹ = n.
• Bestimmung des Falles: Im Master-Theorem gibt es drei Fälle:
• Fall 1: f(n) = O(n^{log_b(a) - ε}) für ein konstantes ε > 0.
• Fall 2: f(n) = Θ(n^log_b(a)).
• Fall 3: f(n) = Ω(n^{log_b(a) + ε}) für ein konstantes ε > 0.
• In unserem Fall ist f(n) = cn und n^log_b(a) = n, also gilt f(n) = Θ(n¹).Das entspricht dem zweiten Fall des Master-Theorems, daher ist die Zeitkomplexität:
• Ergebnis:
  • T(n) = Θ(n^log₂(2) log(n)) entspricht Θ(n log n).
  • Zusammenfassend ist die Zeitkomplexität des Algorithmus im Worst Case Θ(n log n).

b)

Teil 2: Diskutiere, ob dieser Algorithmus zur Klasse \textbf{P}, \textbf{NP}, \textbf{NP}-vollständig oder \textbf{NP}-schwer gehört. Erkläre deine Argumentation auf Basis der Eigenschaften des Algorithmus und der Definitionen der Komplexitätsklassen. Beziehe dich dabei auch auf die Platzkomplexität und die Art des Algorithmus (Divide and Conquer).

Lösung:

Teil 2: Diskutiere, ob dieser Algorithmus zur Klasse \textbf{P}, \textbf{NP}, \textbf{NP}-vollständig oder \textbf{NP}-schwer gehört.Um die Komplexitätsklasse des Algorithmus zu bestimmen, betrachten wir die Charakteristika der verschiedenen Komplexitätsklassen und die Eigenschaften des gegebenen Algorithmus.

• Klasse P (Polynomielle Zeit): Ein Algorithmus gehört zur Klasse P, wenn er in polynomieller Zeit gelöst werden kann, d.h. seine Zeitkomplexität ist eine polynomielle Funktion der Eingabegröße. Der gegebene Algorithmus hat eine Zeitkomplexität von \( O(n \log n)\), was als polynomielle Zeit betrachtet wird, da \( O(n \log n) \) in polynomieller Zeit liegt. Außerdem arbeitet der Algorithmus nach dem Divide-and-Conquer-Prinzip, welches typischerweise zu effizienten Algorithmen mit polynomieller Zeitkomplexität führt. Somit gehört unser Algorithmus zur Klasse P.
• Klasse NP (Nicht-deterministische polynomielle Zeit): Ein Problem gehört zur Klasse NP, wenn eine Lösung in polynomieller Zeit verifiziert werden kann, jedoch nicht notwendigerweise in polynomieller Zeit gefunden werden kann. Da unser Sortieralgorithmus zur Klasse P gehört, gehört er auch zur Klasse NP, da P eine Untermenge von NP ist. Jedoch erfüllt der Algorithmus keine der Kriterien für NP-vollständig oder NP-schwer, da er bereits in P liegt und somit in polynomieller Zeit gelöst werden kann.
• Klasse NP-vollständig und NP-schwer: Ein Problem ist NP-vollständig oder NP-schwer, wenn es in der Klasse NP liegt und alle Probleme aus NP darauf in polynomieller Zeit reduziert werden können. Dies ist bei unserem Problem nicht der Fall, da es bereits in P liegt, d.h. es kann effizient (in polynomieller Zeit) gelöst werden.
• Divide and Conquer Prinzip und Platzkomplexität:Der Algorithmus funktioniert nach dem Divide and Conquer-Prinzip. Das bedeutet, dass wir das Problem in kleinere Teilprobleme aufteilen, diese rekursiv lösen und anschließend kombinieren. Die Platzkomplexität des Algorithmus ist ebenfalls relevant und beträgt in der Regel \( O(n) \), da zusätzlicher Speicher für das Kombinieren der sortierten Hälften verwendet wird. Diese Art von Algorithmen sind bekannt dafür, effizient zu sein und liegen typischerweise in der Klasse P.
Fazit: Der betrachtete Sortieralgorithmus gehört zur Klasse P, da er in polynomieller Zeit, konkret \( O(n \log n) \), gelöst werden kann. Daher ist er auch in NP, aber nicht NP-vollständig oder NP-schwer.

Aufgabe 4)

Betrachte folgendes Szenario in der objektorientierten Programmierung: Ein Programm zur Verwaltung einer Bibliothek. Es gibt verschiedene Arten von Medien, darunter Bücher, Zeitschriften und DVDs. Alle Medien haben gemeinsame Eigenschaften wie Titel, Veröffentlichungsjahr und eine eindeutige ID.

a)

Erstelle eine Klasse Medium in Python mit den Attributen titel, veroeffentlichungsjahr und id. Implementiere einen Konstruktor, der diese Attribute initialisiert und stelle sicher, dass diese Attribute nur innerhalb der Klasse zugänglich sind.

Lösung:

Erstellung der Klasse Medium in Python Hier ist der Python-Code, um die verlangte Klasse Medium zu erstellen:

 class Medium:    def __init__(self, titel, veroeffentlichungsjahr, id):        self.__titel = titel        self.__veroeffentlichungsjahr = veroeffentlichungsjahr        self.__id = id    # Getter-Methoden, um auf die privaten Attribute zuzugreifen    def get_titel(self):        return self.__titel    def get_veroeffentlichungsjahr(self):        return self.__veroeffentlichungsjahr    def get_id(self):        return self.__id 

• Konstruktor: Der Konstruktor __init__ initialisiert die Attribute titel, veroeffentlichungsjahr und id.
• Privatsphäre: Die Attribute sind mit doppeltem Unterstrich (z.B. self.__titel) gekennzeichnet, um sie privat zu machen.
• Getter-Methoden: Es wurden Methoden hinzugefügt, um auf die privaten Attribute zuzugreifen.

b)

Leite drei Klassen Buch, Zeitschrift und DVD von der Klasse Medium ab. Füge jeder abgeleiteten Klasse spezifische Attribute hinzu; z.B. Buch hat das Attribut autor, Zeitschrift hat das Attribut ausgabe, und DVD hat das Attribut dauer. Implementiere einen geeigneten Konstruktor für jede abgeleitete Klasse.

Lösung:

Erstellung der abgeleiteten Klassen in Python Hier ist der Python-Code, um die Klassen Buch, Zeitschrift und DVD abzuleiten und die spezifischen Attribute hinzuzufügen:

 class Medium:    def __init__(self, titel, veroeffentlichungsjahr, id):        self.__titel = titel        self.__veroeffentlichungsjahr = veroeffentlichungsjahr        self.__id = id    # Getter-Methoden, um auf die privaten Attribute zuzugreifen    def get_titel(self):        return self.__titel    def get_veroeffentlichungsjahr(self):        return self.__veroeffentlichungsjahr    def get_id(self):        return self.__idclass Buch(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, autor):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__autor = autor    def get_autor(self):        return self.__autorclass Zeitschrift(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, ausgabe):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__ausgabe = ausgabe    def get_ausgabe(self):        return self.__ausgabeclass DVD(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, dauer):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__dauer = dauer    def get_dauer(self):        return self.__dauer 

• Basisklasse: Die Klasse Medium bleibt unverändert und definiert die gemeinsamen Attribute und Methoden.
• Buch: Die Klasse Buch erbt von Medium und fügt das Attribut autor hinzu. Der Konstruktor verwendet super(), um die Attribute der Basisklasse zu initialisieren.
• Zeitschrift: Die Klasse Zeitschrift erbt von Medium und fügt das Attribut ausgabe hinzu.
• DVD: Die Klasse DVD erbt von Medium und fügt das Attribut dauer hinzu.
• Getter-Methoden: Jede abgeleitete Klasse enthält eine Getter-Methode für ihr spezifisches Attribut.

c)

Implementiere eine Methode ausgabe_details, die in der Klasse Medium definiert ist und in jeder der abgeleiteten Klassen überschrieben wird. Diese Methode soll die spezifischen Details über das Medium auf der Konsole ausgeben. Stelle sicher, dass die Methode in der Lage ist, polymorph zu arbeiten.

Lösung:

Implementierung der Methode ausgabe_details in Python Hier ist der Python-Code, um die Methode ausgabe_details in der Klasse Medium zu definieren und sie in den abgeleiteten Klassen zu überschreiben:

 class Medium:    def __init__(self, titel, veroeffentlichungsjahr, id):        self.__titel = titel        self.__veroeffentlichungsjahr = veroeffentlichungsjahr        self.__id = id    def get_titel(self):        return self.__titel    def get_veroeffentlichungsjahr(self):        return self.__veroeffentlichungsjahr    def get_id(self):        return self.__id    def ausgabe_details(self):        print(f'Titel: {self.__titel}, Jahr: {self.__veroeffentlichungsjahr}, ID: {self.__id}')class Buch(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, autor):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__autor = autor    def get_autor(self):        return self.__autor    def ausgabe_details(self):        super().ausgabe_details()        print(f'Autor: {self.__autor}')class Zeitschrift(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, ausgabe):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__ausgabe = ausgabe    def get_ausgabe(self):        return self.__ausgabe    def ausgabe_details(self):        super().ausgabe_details()        print(f'Ausgabe: {self.__ausgabe}')class DVD(Medium):    def __init__(self, titel, veroeffentlichungsjahr, id, dauer):        super().__init__(titel, veroeffentlichungsjahr, id)        self.__dauer = dauer    def get_dauer(self):        return self.__dauer    def ausgabe_details(self):        super().ausgabe_details()        print(f'Dauer: {self.__dauer}')# Beispiel für polymorphe Methode medien = [Buch('Buch1', 2021, 'ID1', 'Autor1'),          Zeitschrift('Zeitschrift1', 2020, 'ID2', 'Ausgabe1'),          DVD('DVD1', 2019, 'ID3', '120min')]for medium in medien:    medium.ausgabe_details()    print()  

• Basisklasse: Die Klasse Medium enthält die Methode ausgabe_details, die die allgemeinen Details des Mediums ausgibt.
• Überschreibung: Jede abgeleitete Klasse überschreibt die Methode ausgabe_details, um ihre spezifischen Details hinzuzufügen. super().ausgabe_details() wird aufgerufen, um die allgemeinen Details auszugeben, bevor die spezifischen Details hinzugefügt werden.
• Polymorphismus: Ein Beispiel wird gezeigt, wie die Methode ausgabe_details polymorph aufgerufen werden kann.