Programmierung - Exam

Aufgabe 1)

Ein Softwareentwickler muss häufig verschiedene Datentypen und Variablen verwenden, um Programme zu schreiben, die numerische Berechnungen und Datenoperationen durchführen. Angenommen, in einem Programm müssen mehrere Berechnungen durchgeführt werden, um bestimmte mathematische Ergebnisse zu erzielen. Du erhältst die folgenden Informationen:

• Datentypen: int, float, double, char, bool
• typische Operationen: Addition (+), Subtraktion (-), Multiplikation (*), Division (/)
• Deklaration und Initialisierung von Variablen:

 int a = 10;  float b = 3.5;  double c = 7.2;  char d = 'A';  bool e = true;  

a)

Erstelle ein Programm in C, das die folgenden Anforderungen erfüllt:

• Deklariere und initialisiere die Variablen a als int mit dem Wert 14, b als float mit dem Wert 2.5, und c als double mit dem Wert 6.2.
• Berechne die Summe, die Differenz und das Produkt dieser Variablen und speichere die Ergebnisse in entsprechenden Variablen.
• Gib die Ergebnisse auf der Konsole aus.

 #include   int main() {  int a = 14;  float b = 2.5;  double c = 6.2;  // Berechnungen durchführen  // Ausgaben formatieren  return 0;  } 

Lösung:

Hier ist ein Beispielprogramm in C, das die genannten Anforderungen erfüllt:

 #include <stdio.h>  int main() {  int a = 14;  float b = 2.5;  double c = 6.2;  // Berechnungen durchführen  int sum_int = a + (int)b + (int)c;  float sum_float = a + b + c;  double sum_double = a + b + c;  int diff_int = a - (int)b - (int)c;  float diff_float = a - b - c;  double diff_double = a - b - c;  int prod_int = a * (int)b * (int)c;  float prod_float = a * b * c;  double prod_double = a * b * c;  // Ausgaben formatieren und ausgeben  printf("Summe (int): %d", sum_int);  printf("Summe (float): %.2f", sum_float);  printf("Summe (double): %.2lf", sum_double);  printf("Differenz (int): %d", diff_int);  printf("Differenz (float): %.2f", diff_float);  printf("Differenz (double): %.2lf", diff_double);  printf("Produkt (int): %d", prod_int);  printf("Produkt (float): %.2f", prod_float);  printf("Produkt (double): %.2lf", prod_double);  return 0;  } 

Dieses Programm deklariert und initialisiert die Variablen a als int mit dem Wert 14, b als float mit dem Wert 2.5 und c als double mit dem Wert 6.2. Anschließend berechnet es die Summe, die Differenz und das Produkt dieser Variablen und gibt die Ergebnisse auf der Konsole aus. Die Ergebnisse werden gemäß den C-spezifischen Formatierungsregeln ausgegeben.

b)

In dem vorherigen Programm, füge folgende Funktionalitäten hinzu:

• Erstelle eine Funktion calculate, die zwei float-Parameter akzeptiert und die Summe, Differenz und das Produkt dieser Parameter berechnet. Die Rückgabe soll in Form eines Arrays erfolgen.
• Rufe die Funktion mit den Variablen b und c auf und speichere die Ergebnisse in einem Array.
• Gib die Ergebnisse der Funktion auf der Konsole aus.

 float* calculate(float x, float y) {  static float result[3];  result[0] = x + y;  result[1] = x - y;  result[2] = x * y;  return result;  } 

Lösung:

Hier ist das vollständige C-Programm mit der hinzugefügten calculate-Funktion:

#include <stdio.h>  // Definition der Berechnungsfunktion float* calculate(float x, float y) {  static float result[3];  result[0] = x + y;  result[1] = x - y;  result[2] = x * y;  return result;  } int main() {  // Variablendeklaration und -initialisierung  int a = 14;  float b = 2.5;  double c = 6.2;  // Berechnungen durchführen  int sum_int = a + (int)b + (int)c;  float sum_float = a + b + c;  double sum_double = a + b + c;  int diff_int = a - (int)b - (int)c;  float diff_float = a - b - c;  double diff_double = a - b - c;  int prod_int = a * (int)b * (int)c;  float prod_float = a * b * c;  double prod_double = a * b * c;  // Ausgaben formatieren und ausgeben  printf("Summe (int): %d", sum_int);  printf("Summe (float): %.2f", sum_float);  printf("Summe (double): %.2lf", sum_double);  printf("Differenz (int): %d", diff_int);  printf("Differenz (float): %.2f", diff_float);  printf("Differenz (double): %.2lf", diff_double);  printf("Produkt (int): %d", prod_int);  printf("Produkt (float): %.2f", prod_float);  printf("Produkt (double): %.2lf", prod_double);  // Berechnungen mit der Funktion calculate  float* results = calculate(b, c);  // Ausgabe der Ergebnisse der Funktion calculate  printf("Funktion calculate - Summe: %.2f", results[0]);  printf("Funktion calculate - Differenz: %.2f", results[1]);  printf("Funktion calculate - Produkt: %.2f", results[2]);  return 0;  } 

Dieses Programm deklariert und initialisiert die Variablen a als int mit dem Wert 14, b als float mit dem Wert 2.5 und c als double mit dem Wert 6.2. Es führt die empfohlenen Berechnungen durch und gibt die Ergebnisse formatiert auf der Konsole aus. Zusätzlich wird eine Funktion calculate hinzugefügt, die die Summe, die Differenz und das Produkt von zwei float-Parametern berechnet. Die Ergebnisse dieser Funktion werden ebenfalls auf der Konsole ausgegeben.

Aufgabe 2)

Ein Mathematiksystem eines Farbmischprogramms benötigt verschiedene Kontrollstrukturen, um die richtigen Mischverhältnisse zu berechnen. Betrachten wir ein Programm, das den Prozess simuliert. Das Programm verwendet eine Funktion mixeFarben, die zwei Zahlen für Farbcodes entgegennimmt und eine Anweisung ausführt, um Farbtöne abhängig von den Farbcodes zu erzeugen. Betrachte den folgenden Pseudocode zur Lösung dieser Aufgabe:

 function mixeFarben(farbe1, farbe2) {    let gemischteFarbe;    // Bedingung zur Änderung des Programmflusses     if (farbe1 > 100) {       gemischteFarbe = farbe1 + farbe2;    } else {        gemischteFarbe = farbe1 - farbe2;    }    // Schleife zur Berechnung der Farbsättigung    for (let i = 0; i < gemischteFarbe; i++) {        gemischteFarbe = gemischteFarbe + 1;    }    return gemischteFarbe; } 

a)

Implementiere die Funktion mixeFarben in JavaScript so, dass sie zwei Farbcodes aufnimmt und die oben beschriebene Logik korrekt anwendet. Achte dabei auf saubere Syntax und korrekte Verwendung der Kontrollstrukturen. Fähige die genaue Reihenfolge der Anweisungen wie im Pseudocode beschrieben.

Lösung:

JavaScript Implementierung der Funktion zur Farbmischung

Hier ist die Implementierung der Funktion mixeFarben in JavaScript, welche die oben beschriebene Logik anwendet:

function mixeFarben(farbe1, farbe2) {    let gemischteFarbe;    // Bedingung zur Änderung des Programmflusses    if (farbe1 > 100) {        gemischteFarbe = farbe1 + farbe2;    } else {        gemischteFarbe = farbe1 - farbe2;    }    // Schleife zur Berechnung der Farbsättigung    for (let i = 0; i < gemischteFarbe; i++) {        gemischteFarbe = gemischteFarbe + 1;    }    return gemischteFarbe;}

Die Funktion mixeFarben nimmt zwei Parameter (farbe1 und farbe2) und führt eine Reihe von Operationen aus:

• Die erste Bedingung überprüft, ob farbe1 größer als 100 ist.
• Falls ja, wird die gemischte Farbe berechnet als die Summe von farbe1 und farbe2.
• Falls nein, wird die gemischte Farbe berechnet als die Differenz von farbe1 und farbe2.
• Eine Schleife läuft so oft wie der Wert der gemischten Farbe und erhöht diesen Wert in jedem Durchgang um 1.

Am Ende gibt die Funktion den berechneten Wert der gemischten Farbe zurück.

c)

Verändere den Pseudocode so, dass eine while-Schleife anstelle der for Schleife verwendet wird. Sorge dafür, dass das Verhalten des Programmes gleich bleibt. Implementiere diese Änderung in JavaScript und gehe dabei genau auf die Unterschiede zwischen for und while-Schleifen ein sowie wann welche besser geeignet ist.

Lösung:

Umwandlung der Schleife im Pseudocode

Um den Pseudocode von einer for-Schleife zu einer while-Schleife zu ändern, müssen wir einige Anpassungen vornehmen. Die while-Schleife wird solange ausgeführt, wie eine bestimmte Bedingung wahr ist, während die for-Schleife typischerweise verwendet wird, wenn die Anzahl der Iterationen bekannt ist.

Hier ist die geänderte Version des Pseudocodes:

 function mixeFarben(farbe1, farbe2) {    let gemischteFarbe;    // Bedingung zur Änderung des Programmflusses    if (farbe1 > 100) {        gemischteFarbe = farbe1 + farbe2;    } else {        gemischteFarbe = farbe1 - farbe2;    }    // Schleife zur Berechnung der Farbsättigung    let i = 0;    while (i < gemischteFarbe) {        gemischteFarbe = gemischteFarbe + 1;        i = i + 1;    }    return gemischteFarbe; }

Unterschiede zwischen for- und while-Schleifen:

• for-Schleifen: Sie sind ideal, wenn die Anzahl der Iterationen vorab bekannt ist. Eine for-Schleife hat eine Initialisierungsphase, eine Bedingungsprüfung und einen Inkrement-/Dekrement-Teil.
• while-Schleifen: Sie sind besser geeignet, wenn die Anzahl der Iterationen nicht im Voraus bekannt ist. Sie werden ausgeführt, solange die Bedingung wahr ist. Es ist wichtig, daran zu denken, die Bedingung innerhalb der Schleife zu aktualisieren, um eine Endlosschleife zu vermeiden.

In diesem Fall haben wir die for-Schleife in eine while-Schleife umgewandelt, indem wir eine Initialisierung des Schleifenzählers i außerhalb der Schleife vorgenommen haben und die Bedingung i < gemischteFarbe innerhalb der while-Bedingung überprüfen. Der Zähler i wird in jedem Schleifendurchlauf inkrementiert, genau wie in der ursprünglichen for-Schleife.

d)

Erweitere die Funktion mixeFarben um eine switch-Anweisung, um zusätzlich bestimmte Standardfarben zurückzugeben: Wenn farbe1 oder farbe2 den Wert 200 hat, soll gemischteFarbe auf 300 gesetzt werden. Ansonsten soll das Programm wie gehabt den gemischten Farbwert berechnen. Implementiere dies in JavaScript und erkläre den Nutzen der switch-Anweisung in diesem Kontext.

Lösung:

Erweiterung der Funktion mit einer switch-Anweisung

Um die Funktion mixeFarben zu erweitern, fügen wir eine switch-Anweisung hinzu, um bestimmte Standardfarben zurückzugeben. Wenn entweder farbe1 oder farbe2 den Wert 200 hat, wird gemischteFarbe auf 300 gesetzt.

Hier ist die erweiterte Funktion in JavaScript:

function mixeFarben(farbe1, farbe2) {    // Überprüfen, ob farbe1 oder farbe2 den Wert 200 haben    switch (true) {        case (farbe1 === 200):        case (farbe2 === 200):            return 300;        default:            break;    }    let gemischteFarbe;    // Bedingung zur Änderung des Programmflusses    if (farbe1 > 100) {        gemischteFarbe = farbe1 + farbe2;    } else {        gemischteFarbe = farbe1 - farbe2;    }    // Schleife zur Berechnung der Farbsättigung    let i = 0;    while (i < gemischteFarbe) {        gemischteFarbe = gemischteFarbe + 1;        i = i + 1;    }    return gemischteFarbe;}

Nutzen der switch-Anweisung in diesem Kontext:

• Verständlichkeit: Eine switch-Anweisung kann den Code klarer und leichter lesbar machen, insbesondere wenn man mehrere mögliche Fälle behandeln muss. In diesem Beispiel wird sie verwendet, um spezielle Werte (200) schnell zu identifizieren und entsprechende Aktionen (Rückgabe von 300) auszuführen.
• Flexibilität: Die switch-Anweisung ermöglicht es, verschiedene Bedingungen zu prüfen und passende Aktionen durchzuführen, ohne dass mehrere if-else-Anweisungen erforderlich sind.
• Effizienz: In bestimmten Fällen kann eine switch-Anweisung effizienter sein als mehrere if-else-Blöcke.

In unserem Beispiel überprüft die switch-Anweisung, ob entweder farbe1 oder farbe2 den Wert 200 hat. Wenn dies der Fall ist, wird sofort 300 zurückgegeben. Andernfalls wird der reguläre Prozess zur Berechnung der gemischten Farbe fortgesetzt.

Aufgabe 3)

Betrachte die folgende rekursiv definierte Funktion zur Berechnung der n-ten Fibonacci-Zahl:

 def fibonacci(n):     if n <= 0:         return 0     elif n == 1:         return 1     else:         return fibonacci(n-1) + fibonacci(n-2)  

Diese Methode ist ineffizient, da sie viele Teilergebnisse mehrfach berechnet.

a)

Teilaufgabe 1: Analysiere die Zeitkomplexität der gegebenen rekursiven Implementierung des Fibonacci-Algorithmus. Erkläre, warum diese Implementierung ineffizient ist. Nutze geeignete Diagramme, wenn notwendig.

Lösung:

Teilaufgabe 1: Analysiere die Zeitkomplexität der gegebenen rekursiven Implementierung des Fibonacci-Algorithmus. Erkläre, warum diese Implementierung ineffizient ist. Nutze geeignete Diagramme, wenn notwendig.

Die rekursive Implementierung des Fibonacci-Algorithmus in der gegebenen Form hat eine exponentielle Zeitkomplexität. Um die Zeitkomplexität zu analysieren, betrachten wir die Anzahl der rekursiven Aufrufe, die zur Berechnung der n-ten Fibonacci-Zahl notwendig sind.

Betrachten wir die Funktion:

def fibonacci(n):   if n <= 0:       return 0    elif n == 1:        return 1    else:        return fibonacci(n-1) + fibonacci(n-2)

Bei jedem Aufruf von fibonacci(n) wird die Funktion zweimal rekursiv aufgerufen: einmal mit fibonacci(n-1) und einmal mit fibonacci(n-2). Dieser doppelte Aufruf führt dazu, dass viele Teilergebnisse mehrfach berechnet werden.

Um dies zu verdeutlichen, betrachten wir ein Schaubild der rekursiven Aufrufe für ein kleines n, z.B. n=5:

• fibonacci(5)
  • fibonacci(4)
    • fibonacci(3)
      • fibonacci(2)
        • fibonacci(1)
        • fibonacci(0)
      • fibonacci(1)
    • fibonacci(2)
      • fibonacci(1)
      • fibonacci(0)
  • fibonacci(3)
    • fibonacci(2)
      • fibonacci(1)
      • fibonacci(0)
    • fibonacci(1)

Hier sieht man, dass Fibonacci-Zahlen wie fibonacci(2) und fibonacci(1) mehrfach berechnet werden. Dies führt zu einer exponentiellen Anzahl an Aufrufen. Die Zeitkomplexität dieser rekursiven Implementierung ist daher O(2^n).

Dies macht die Implementierung insbesondere für größere Werte von n ineffizient, da die Anzahl der Aufrufe exponentiell mit n anwächst, was zu sehr hoher Rechenzeit führt.

b)

Teilaufgabe 2: Implementiere den Algorithmus neu unter Verwendung von Dynamic Programming, um die Berechnung zu optimieren. Du kannst entweder Memorization (Top-down-Ansatz) oder Tabulation (Bottom-up-Ansatz) nutzen. Zeige dann die verbesserte Zeitkomplexität der optimierten Funktion anhand von Berechnungen.

 # Beispiel für Top-down Dynamic Programming mit Memorization def fibonacci_memo(n, memo={}):     if n <= 0:         return 0     elif n == 1:         return 1     if n not in memo:          memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)     return memo[n] 

Lösung:

Teilaufgabe 2: Implementiere den Algorithmus neu unter Verwendung von Dynamic Programming, um die Berechnung zu optimieren. Du kannst entweder Memorization (Top-down-Ansatz) oder Tabulation (Bottom-up-Ansatz) nutzen. Zeige dann die verbesserte Zeitkomplexität der optimierten Funktion anhand von Berechnungen.

Hier ist ein Beispiel für den Top-down-Ansatz mit Memorization:

# Beispiel für Top-down Dynamic Programming mit Memorizationdef fibonacci_memo(n, memo={}):    if n <= 0:        return 0    elif n == 1:        return 1    if n not in memo:        memo[n] = fibonacci_memo(n-1, memo) + fibonacci_memo(n-2, memo)    return memo[n]

Dieser Ansatz speichert die Ergebnisse bereits berechneter Fibonacci-Zahlen, um unnötige Berechnungen zu vermeiden. Die Zeitkomplexität dieser Methode ist O(n), da jedes Ergebnis nur einmal berechnet und dann gespeichert wird.

Hier ist ein weiteres Beispiel für den Bottom-up-Ansatz mit Tabulation:

# Beispiel für Bottom-up Dynamic Programming mit Tabulationdef fibonacci_tab(n):    if n <= 0:        return 0    elif n == 1:        return 1    fib = [0] * (n+1)    fib[1] = 1    for i in range(2, n + 1):        fib[i] = fib[i-1] + fib[i-2]    return fib[n]

In diesem Ansatz werden die Fibonacci-Zahlen in einem Array gespeichert, und die Berechnung erfolgt iterativ. Auch hier ist die Zeitkomplexität O(n), da jede Fibonacci-Zahl genau einmal berechnet wird.

Verglichen mit der ursprünglichen rekursiven Implementierung, die eine exponentielle Zeitkomplexität von O(2^n) hatte, bieten sowohl der Memorization- als auch der Tabulation-Ansatz eine signifikante Verbesserung auf lineare Zeitkomplexität O(n). Dies macht die Berechnung der Fibonacci-Zahlen auch für größere Werte von n effizient und praktikabel.

Aufgabe 4)

Gegeben sei die folgende Klasse in Python, die ein Fahrzeug beschreibt. Diese Klasse hat Attribute für die Marke, das Modell und die Geschwindigkeit. Zusätzlich besitzt die Klasse Methoden, um die Geschwindigkeit zu erhöhen und zu verringern.

a)

Implementiere die Klasse Fahrzeug mit den Attributen marke, modell und geschwindigkeit. Implementiere außerdem die Methoden beschleunigen und bremsen. Die Methode beschleunigen soll die Geschwindigkeit um einen gegebenen Wert erhöhen, und die Methode bremsen soll die Geschwindigkeit um einen gegebenen Wert verringern, aber nicht unter Null fallen lassen. Nutze dazu folgendes Gerüst:

class Fahrzeug:    def __init__(self, marke, modell, geschwindigkeit=0):        self.marke = marke        self.modell = modell        self.geschwindigkeit = geschwindigkeit    def beschleunigen(self, wert):        pass    def bremsen(self, wert):        pass

Lösung:

Implementierung der Klasse Fahrzeug

Hier ist die vollständige Implementierung der Klasse Fahrzeug mit den erforderlichen Attributen und Methoden:

class Fahrzeug:    def __init__(self, marke, modell, geschwindigkeit=0):        self.marke = marke        self.modell = modell        self.geschwindigkeit = geschwindigkeit    def beschleunigen(self, wert):        self.geschwindigkeit += wert        return self.geschwindigkeit    def bremsen(self, wert):        self.geschwindigkeit = max(0, self.geschwindigkeit - wert)        return self.geschwindigkeit

Erklärung der Methoden

• __init__: Der Konstruktor nimmt die Parameter marke, modell und geschwindigkeit, wobei letzterer einen Standardwert von 0 hat. Diese Parameter werden den Attributen der Instanz zugewiesen.
• beschleunigen: Diese Methode erhöht die Geschwindigkeit um den gegebenen Wert wert, indem sie ihn zur aktuellen Geschwindigkeit addiert. Die neue Geschwindigkeit wird zurückgegeben.
• bremsen: Diese Methode verringert die Geschwindigkeit um den gegebenen Wert wert. Dabei wird darauf geachtet, dass die Geschwindigkeit nicht unter null fällt. Die Methode nutzt die max-Funktion, um sicherzustellen, dass mindestens null zurückgegeben wird.

Beispiele für die Verwendung der Klasse Fahrzeug

# Erstellen eines Fahrzeug-Objektsauto = Fahrzeug('Toyota', 'Corolla', 50)# Geschwindigkeit erhöhenprint(auto.beschleunigen(20))  # Ausgabe: 70# Geschwindigkeit verringernprint(auto.bremsen(30))       # Ausgabe: 40# Geschwindigkeit weiter verringernprint(auto.bremsen(50))       # Ausgabe: 0

Diese Beispiele zeigen, wie Du die Klasse Fahrzeug verwenden kannst, um die Geschwindigkeit eines Fahrzeugs zu ändern.

b)

Erzeuge ein Objekt der Klasse Fahrzeug mit der Marke 'Tesla', dem Modell 'Model S' und einer initialen Geschwindigkeit von 50 km/h. Erhöhe die Geschwindigkeit auf 80 km/h und verringere sie anschließend auf 30 km/h. Stelle sicher, dass die Geschwindigkeit korrekt angepasst wird.

Lösung:

Erzeugen eines Objekts der Klasse Fahrzeug und Anpassen der Geschwindigkeit

Hier ist die vollständige Implementierung des geforderten Ablaufs:

class Fahrzeug:    def __init__(self, marke, modell, geschwindigkeit=0):        self.marke = marke        self.modell = modell        self.geschwindigkeit = geschwindigkeit    def beschleunigen(self, wert):        self.geschwindigkeit += wert        return self.geschwindigkeit    def bremsen(self, wert):        self.geschwindigkeit = max(0, self.geschwindigkeit - wert)        return self.geschwindigkeit# Erstellen eines Fahrzeug-Objekts mit der Marke 'Tesla', dem Modell 'Model S' und einer initialen Geschwindigkeit von 50 km/hauto = Fahrzeug('Tesla', 'Model S', 50)# Erhöhen der Geschwindigkeit auf 80 km/hauto.beschleunigen(30)  # 50 + 30 = 80print(f'Aktuelle Geschwindigkeit: {auto.geschwindigkeit} km/h')  # Ausgabe: Aktuelle Geschwindigkeit: 80 km/h# Verringern der Geschwindigkeit auf 30 km/hauto.bremsen(50)  # 80 - 50 = 30print(f'Aktuelle Geschwindigkeit: {auto.geschwindigkeit} km/h')  # Ausgabe: Aktuelle Geschwindigkeit: 30 km/h

Erklärung der Schritte

• Objekt-Erstellung: Mit auto = Fahrzeug('Tesla', 'Model S', 50) wird ein Objekt auto der Klasse Fahrzeug erstellt. Marke ist 'Tesla', Modell ist 'Model S' und die initiale Geschwindigkeit ist 50 km/h.
• Geschwindigkeit erhöhen: Mit auto.beschleunigen(30) wird die Geschwindigkeit des Fahrzeugs um 30 km/h erhöht. Die neue Geschwindigkeit beträgt somit 80 km/h.
• Geschwindigkeit verringern: Mit auto.bremsen(50) wird die Geschwindigkeit des Fahrzeugs um 50 km/h verringert. Die neue Geschwindigkeit beträgt somit 30 km/h.

Mit diesen Schritten wird das Objekt auto korrekt initialisiert und die Geschwindigkeit entsprechend angepasst.

c)

Erweitere die Klasse Fahrzeug um eine Methode status, die einen String zurückgibt, der die aktuellen Attribute des Fahrzeugs in folgender Form beschreibt: 'Das Fahrzeug der Marke und Modell fährt mit km/h'. Teste diese Methode mit dem zuvor erstellten Objekt.

Lösung:

Erweiterung der Klasse Fahrzeug um die Methode status

Hier ist die erweiterte Implementierung der Klasse Fahrzeug mit der neuen Methode status:

class Fahrzeug:    def __init__(self, marke, modell, geschwindigkeit=0):        self.marke = marke        self.modell = modell        self.geschwindigkeit = geschwindigkeit    def beschleunigen(self, wert):        self.geschwindigkeit += wert        return self.geschwindigkeit    def bremsen(self, wert):        self.geschwindigkeit = max(0, self.geschwindigkeit - wert)        return self.geschwindigkeit    def status(self):        return f'Das Fahrzeug der Marke {self.marke} und Modell {self.modell} fährt mit {self.geschwindigkeit} km/h'

Beispiel für die Verwendung der Methode status

# Erstellen eines Fahrzeug-Objekts mit der Marke 'Tesla', dem Modell 'Model S' und einer initialen Geschwindigkeit von 50 km/hauto = Fahrzeug('Tesla', 'Model S', 50)# Erhöhen der Geschwindigkeit auf 80 km/hauto.beschleunigen(30)  # 50 + 30 = 80# Status des Fahrzeugs anzeigenprint(auto.status())  # Ausgabe: Das Fahrzeug der Marke Tesla und Modell Model S fährt mit 80 km/h# Verringern der Geschwindigkeit auf 30 km/hauto.bremsen(50)  # 80 - 50 = 30# Status des Fahrzeugs anzeigenprint(auto.status())  # Ausgabe: Das Fahrzeug der Marke Tesla und Modell Model S fährt mit 30 km/h

Erklärung der Methode status

• status: Diese Methode erstellt einen String, der die aktuellen Werte der Attribute marke, modell und geschwindigkeit des Fahrzeugobjekts beschreibt. Der String hat das Format 'Das Fahrzeug der Marke und Modell fährt mit km/h'.

Mit diesen Änderungen kannst Du die aktuelle Beschreibung des Fahrzeugs in einem lesbaren Format anzeigen lassen.