• Zu Aufgabe 1 - Umsetzung der Python-Klasse 'BankAccount' für die Verwaltung von Kontoständen, Einzahlungen und Abhebungen
• Zu Aufgabe 2 - Einfacher Taschenrechner in C++: Übersetzung der Python-Klasse 'Calculator' mit den Grundrechenarten
• Zu Aufgabe 3 - Lösung quadratischer Gleichungen
• Zu Aufgabe 4 - Sichtbarkeit der Bühne
• Fazit

Aufgabe 1: Umsetzung der Python-Klasse 'BankAccount' für die Verwaltung von Kontoständen, Einzahlungen und Abhebungen

Gegeben ist eine Python-Klasse namens "BankAccount", die ein Bankkonto repräsentiert. Die Klasse besitzt eine Konstruktor welche, den Kontostand des Kontos auf 0 setzt. Die Klasse hat ebenfalls Methoden, um den Kontostand abzufragen, Einzahlungen zu tätigen und Abhebungen vorzunehmen. Übersetzen Sie dann diese Klasse in C++ und implementieren Sie die gleiche Funktionalität:

Promt: Übersetze diesen Python Code in C++:

class BankAccount:
    def __init__(self):
        self.balance = 0
    
    def get_balance(self):
        return self.balance
    
    def deposit(self, amount):
        self.balance += amount
    
    def withdraw(self, amount):
        if amount > self.balance:
            raise ValueError("Insufficient balance")
        self.balance -= amount

Ergebnis:

Hier ist der übersetzte C++ Code:

#include <iostream>
using namespace std;

class BankAccount {
private:
    double balance;
public:
    BankAccount() {
        balance = 0;
    }
    double get_balance() {
        return balance;
    }
    void deposit(double amount) {
        balance += amount;
    }
    void withdraw(double amount) {
        if (amount > balance) {
            throw "Insufficient balance";
        }
        balance -= amount;
    }
};
int main() {
    BankAccount account;
    cout << "Initial balance: " << account.get_balance() << endl;
    account.deposit(100);
    cout << "After deposit: " << account.get_balance() << endl;
    account.withdraw(50);
    cout << "After withdrawal: " << account.get_balance() << endl;
    return 0;
}

Der C++ Code definiert eine Klasse "BankAccount", die ähnliche Funktionalität wie die Python-Klasse bereitstellt. Die Klasse hat eine private Variable "balance", die den Kontostand des Bankkontos speichert. Der Konstruktor setzt den Kontostand auf 0. Die Methoden "get_balance", "deposit" und "withdraw" entsprechen den entsprechenden Python-Methoden.

In der "withdraw" Methode wird eine Ausnahme ausgelöst, wenn der Kontostand nicht ausreichend ist, um den angeforderten Betrag abzuheben. Die main-Funktion demonstriert die Verwendung der BankAccount-Klasse durch Erstellen eines Bankkontos, Einzahlen von Geld und Abheben von Geld.

Überprüfung mit converter Python | C++ Converter:

#include <iostream>
using namespace std;

class BankAccount {
    private:
        int balance;
    public:
        BankAccount() {
            balance = 0;
        }
        int get_balance() {
            return balance;
        }
        void deposit(int amount) {
            balance += amount;
        }
        void withdraw(int amount) {
            if (amount > balance) {
                throw "Insufficient balance";
            }
            balance -= amount;

Aufgabe 2: Einfacher Taschenrechner in C++: Übersetzung der Python-Klasse 'Calculator' mit den Grundrechenarten

Gegeben ist eine Python-Klasse die einen einfachen Taschenrechner darstellt. Die Klasse besitzt die vier Grundrechenarten (Addition, Subtraktion, Multiplikation und Division). Schreiben Sie eine Übersetzung dieser Klasse in C++.

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:

Promt: Übersetze diesen Python Code in C++:

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Division by zero is not allowed")
        return a / b

Ergebnis:

Hier ist eine Übersetzung der Python-Klasse Calculator in C++:

class Calculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        if b == 0:
            raise ValueError("Division by zero is not allowed")
        return a / b

In C++ wird die throw-Anweisung verwendet, um eine Ausnahme zu erzeugen, wenn die Division durch Null aufgerufen wird. Die Ausnahme wird durch die Klasse std::invalid_argument dargestellt, die in der stdexcept-Bibliothek definiert ist.

Beachte, dass in C++ Methoden standardmäßig nicht virtual sind. Wenn Sie Polymorphismus in Ihrer Klasse verwenden möchten, sollten Sie die Methoden als virtual deklarieren.

Überprüfung mit converter Python | C++ Converter:

class Calculator {
public:
    double add(double a, double b) {
        return a + b;
    }
    double subtract(double a, double b) {
        return a - b;
    }
    double multiply(double a, double b) {
        return a * b;
    }
    double divide(double a, double b) {
        if (b == 0) {
            throw std::invalid_argument("Division by zero is not allowed");
        }
        return a / b;
    }
};

Aufgabe 3: Lösung quadratischer Gleichungen

Eine quadratische Gleichung a x² + b x + c = 0 hat entweder 0, 1 oder 2 verschiedene Lösungen für reelle Werte von x. Wenn a, b und c gegeben sind, sollten Sie die Anzahl der Lösungen für die Gleichung zurückgeben. Übersetzen Sie diesen Python Code anschließend in C++.

Beispiel:
solutions(1, 0, -1) ➞ 2
// x² - 1 = 0 has two solutions

solutions(1, 0, 0) ➞ 1
// x² = 0 has one solution

solutions(1, 0, 1) ➞ 0
// x² + 1 = 0 has no real solutions.

Prompt:
Übersetze diesen Python Code in C++:

def solutions(a, b, c):
    discriminant = b**2 - 4*a*c
    if discriminant > 0:
        return 2
    elif discriminant == 0:
        return 1
    else:
        return 0

Ergebnis:

Hier ist der Code in C++:

#include <cmath>

int solutions(int a, int b, int c) {
    int discriminant = pow(b, 2) - 4 * a * c;
    if (discriminant > 0) {
        return 2;
    } else if (discriminant == 0) {
        return 1;
    } else {
        return 0;
    }
}

In C++ verwenden wir die Funktion pow() aus der Bibliothek <cmath>, um das Quadrat von b zu berechnen. Der Rest des Codes bleibt gleich.

Überprüfung mit converter Python | C++ Converter:

Aufgabe 4: Sichtbarkeit der Bühne

Erstellen Sie eine Funktion, die bestimmt, ob jeder Sitz die vordere Bühne „sehen“ kann. Eine Zahl kann die vordere Stufe „sehen“, wenn sie größer als die Zahl davor ist.

Beispiel:
# FRONT STAGE
[[1, 2, 3, 2, 1, 1],
[2, 4, 4, 3, 2, 2],
[5, 5, 5, 5, 4, 4],
[6, 6, 7, 6, 5, 5]]
# Starting from the left, the 6 > 5 > 2 > 1, so all numbers can see.
# 6 > 5 > 4 > 2 - so all numbers can see, etc.

# FRONT STAGE
[[1, 2, 3, 2, 1, 1],
[2, 4, 4, 3, 2, 2],
[5, 5, 5, 10, 4, 4],
[6, 6, 7, 6, 5, 5]]
# The 10 is directly in front of the 6 and blocking its view.

Prompt: Übersetze diesen Python Code in C++

def can_see_stage(seats):
    num_rows = len(seats)
    num_cols = len(seats[0])

    for col in range(num_cols):
        for row in range(1, num_rows):
            if seats[row][col] <= seats[row - 1][col]:
                return False
    return True

Ergebnis ChatGPT:

Hier ist der Code in C++, der die Funktion can_see_stage übersetzt:

#include <vector>

bool can_see_stage(std::vector<std::vector<int>>& seats) {
    int num_rows = seats.size();
    int num_cols = seats[0].size();

    for (int col = 0; col < num_cols; col++) {
        for (int row = 1; row < num_rows; row++) {
            if (seats[row][col] <= seats[row - 1][col]) {
                return false;
            }
        }
    }

    return true;
}

Diese Übersetzung verwendet einen Vektor, um die Sitzplätze zu repräsentieren. Die Funktion überprüft jede Spalte und jede Zeile, um zu prüfen, ob die Zahl in jeder Zeile streng größer ist als die Zahl in der darunterliegenden Zeile. Wenn an irgendeiner Stelle eine Verletzung gefunden wird, wird sofort false zurückgegeben. Wenn die Schleifen ohne Verletzungen abgeschlossen werden, bedeutet dies, dass jeder Sitzplatz die Bühne sehen kann, und die Funktion gibt true zurück.

Bitte beachten Sie, dass diese Übersetzung voraussetzt, dass die Sitzplätze als zweidimensionaler Vektor von Ganzzahlen (int) übergeben werden. Stellen Sie sicher, dass Sie den entsprechenden Header vector eingebunden haben, um Vektoren zu verwenden.

Überprüfung mit converter Python | C++ Converter:

Fazit

• Zu Aufgabe 1 - Risiken der Benutzereingabe: Sicherheitslücken beim Ausführen von Befehlen auf Dateien
• Zu Aufgabe 2 - Sicherer Dateidownload: Überprüfung und Schutz vor potenziell schädlichen Inhalten bei der Verwendung
• Zu Aufgabe 3 - Subprocess
• Zu Aufgabe 4 - Dateilöschung
• Fazit

Aufgabe 1: Risiken der Benutzereingabe: Sicherheitslücken beim Ausführen von Befehlen auf Dateien

Dieses Skript liest den Dateinamen von der Benutzereingabe ein und führt dann das Unix-Befehl "cat" auf dieser Datei aus. Das Problem dabei ist, dass der Benutzer jeden beliebigen Dateinamen eingeben kann, und das Skript wird diesen Namen einfach an das Betriebssystem weitergeben.

Das bedeutet, dass ein Angreifer ein Verzeichnispfad einschleusen könnte, der unerwartete Ergebnisse liefert, wie z.B. das Auslesen von vertraulichen Dateien, das Ausführen von Schadcode oder das Löschen wichtiger Systemdateien.

Prompt:

Teste diesen Code auf Sicherheitsprobleme und behebe diese falls notwendig:

import os

filename = input("Bitte geben Sie den Namen der Datei ein: ")
os.system("cat " + filename)

Ergebnis:

Hier ist eine mögliche Lösung, die die Sicherheitsprobleme in dem gegebenen Python-Code behebt:

import os
import subprocess

def run_cat():
    filename = input("Bitte geben Sie den Namen der Datei ein: ")
    allowed_dir = "/path/to/allowed/dir"
    if not filename.startswith(allowed_dir):
        print("Nur Dateien in %s sind erlaubt." % allowed_dir)
        return
    try:
        output = subprocess.check_output(["cat", filename])
        print(output.decode())
    except subprocess.CalledProcessError:
        print("Fehler beim Ausführen von 'cat' auf der Datei.")

run_cat()

Diese Lösung verwendet subprocess.check_output() statt os.system(), um sicherzustellen, dass die Parameter korrekt behandelt werden. Der Dateiname wird mit einer erlaubten Verzeichnisbaumstruktur verglichen, um sicherzustellen, dass nur Dateien aus einem bestimmten Verzeichnis gelesen werden können. Wenn der Dateiname nicht in diesem Verzeichnis liegt, wird eine entsprechende Fehlermeldung ausgegeben. Wenn alles gut geht, wird der Inhalt der Datei auf der Konsole ausgegeben.

Beachten Sie, dass Sie möglicherweise das erlaubte Verzeichnis (allowed_dir) entsprechend Ihren Anforderungen anpassen müssen.

Aufgabe 2: Sicherer Dateidownload: Überprüfung und Schutz vor potenziell schädlichen Inhalten bei der Verwendung

In diesem Code wird die requests-Bibliothek verwendet, um eine Datei von einer angegebenen URL herunterzuladen. Die heruntergeladene Datei wird dann in einer lokalen Datei namens "downloaded_file.txt" gespeichert.

Das potenzielle Sicherheitsproblem bei diesem Code besteht darin, dass der Benutzer eine bösartige URL angeben könnte, die einen schädlichen Inhalt enthält, der auf das lokale System übertragen wird. Der Code überprüft nicht, ob die heruntergeladene Datei sicher ist oder nicht.

Prompt:

Teste diesen Code auf Sicherheitsprobleme und behebe diese falls notwendig:

import os
import subprocess

def run_cat():
    filename = input("Bitte geben Sie den Namen der Datei ein: ")
    allowed_dir = "/path/to/allowed/dir"
    if not filename.startswith(allowed_dir):
        print("Nur Dateien in %s sind erlaubt." % allowed_dir)
        return
    try:
        output = subprocess.check_output(["cat", filename])
        print(output.decode())
    except subprocess.CalledProcessError:
        print("Fehler beim Ausführen von 'cat' auf der Datei.")

run_cat()

Ergebnis:

Hier ist eine mögliche Lösung potenzielle Sicherheitsprobleme zu identifizieren und zu beheben:

import requests
import hashlib

def download_file(url):
    response = requests.get(url)
    if response.status_code == 200:
        # calculate the SHA-256 hash of the downloaded content
        hash_value = hashlib.sha256(response.content).hexdigest()
        # check if the hash matches a known, safe hash
        if hash_value == "4c1bf7f51f7f3be56eaeaf60d4cf4554dfb2d50c04bbd7f8752a4d292219f277":
            # if the hash matches, save the file to disk
            with open("downloaded_file.txt", "wb") as f:
                f.write(response.content)
            print("File downloaded successfully.")
        else:
            # if the hash does not match, delete the downloaded content
            print("File download failed: hash mismatch.")
    else:
        print("File download failed: unable to connect to URL.")

In dieser Lösung wurde eine Überprüfung hinzugefügt, um sicherzustellen, dass die heruntergeladene Datei sicher ist, bevor sie auf dem lokalen System gespeichert wird. Die Funktion berechnet den SHA-256-Hash-Wert der heruntergeladenen Inhalte und überprüft, ob der Hash-Wert mit einem bekannten, sicheren Hash-Wert übereinstimmt. Wenn der Hash-Wert übereinstimmt, wird die heruntergeladene Datei auf dem lokalen System gespeichert. Wenn der Hash-Wert nicht übereinstimmt, wird die heruntergeladene Datei nicht auf dem lokalen System gespeichert und eine Fehlermeldung wird ausgegeben.

Außerdem wurde eine weitere Überprüfung hinzugefügt, um sicherzustellen, dass die URL von einer vertrauenswürdigen Quelle stammt. In diesem Beispiel wurde jedoch nur eine Überprüfung auf den HTTP-Statuscode durchgeführt. Weitere Überprüfungen wie beispielsweise Zertifikatsprüfungen können hier noch implementiert werden, um die Sicherheit weiter zu verbessern.

Aufgabe 3: Subprocess

Dieser Code übergibt Benutzereingaben an die subprocess.call() Funktion und führt diese aus.

import subprocess

def execute_command():
    command = input("Geben Sie den Befehl ein, den Sie ausführen möchten: ")
    subprocess.call(command, shell=True)
    print("Befehl wurde ausgeführt.")

execute_command()

Prompt: Teste den Code auf mögliche Sicherheitsprobleme und behebe diese:

Ergebnis ChatGPT:

Der bereitgestellte Code hat ein Sicherheitsproblem, da er Benutzereingaben direkt an die subprocess.call()-Funktion übergibt, ohne eine angemessene Überprüfung oder Validierung durchzuführen. Dies kann zu sogenannten "Command Injection"-Angriffen führen, bei denen ein Angreifer schädlichen Code einschleust, der auf dem System des Benutzers ausgeführt wird.

Um dieses Sicherheitsproblem zu beheben, sollte die Benutzereingabe validiert und gefiltert werden, um sicherzustellen, dass nur erlaubte Befehle ausgeführt werden können. Eine Möglichkeit, dies zu erreichen, ist die Verwendung einer Whitelist-Technik, bei der nur vordefinierte und sichere Befehle zugelassen werden.

Hier ist eine verbesserte Version des Codes, die die Sicherheitsprobleme behebt:

import subprocess

ALLOWED_COMMANDS = ["ls", "pwd", "echo"]  # Liste erlaubter Befehle

def execute_command():
    command = input("Geben Sie den Befehl ein, den Sie ausführen möchten: ")

    if command in ALLOWED_COMMANDS:
        subprocess.call(command, shell=True)
        print("Befehl wurde ausgeführt.")
    else:
        print("Ungültiger Befehl.")

execute_command() 

In dieser verbesserten Version wird eine Whitelist ALLOWED_COMMANDS verwendet, die eine vordefinierte Liste erlaubter Befehle enthält. Die Benutzereingabe wird mit dieser Whitelist verglichen, und nur wenn der eingegebene Befehl in der Whitelist enthalten ist, wird der Befehl ausgeführt. Andernfalls wird eine entsprechende Fehlermeldung ausgegeben. Durch diese Änderungen werden potenziell gefährliche Befehle von der Ausführung ausgeschlossen und mögliche Sicherheitsrisiken minimiert.

Aufgabe 4: Dateilöschung

Dieser Code löscht nach Angabe des Namens file_name die jeweilige Datei aus dem vorgegebenen Verzeichnis.

import os

def delete_file():
    file_name = input("Geben Sie den Dateinamen zum Löschen ein: ")
    file_path = "/var/www/uploads/" + file_name
    os.remove(file_path)
    print("Datei wurde gelöscht.")

delete_file()

Prompt: Teste den Code auf mögliche Sicherheitsprobleme und behebe diese.

Ergebnis ChatGPT:

Bei dem gegebenen Code besteht ein Sicherheitsproblem, da Benutzereingaben direkt in den Dateipfad (file_path) eingefügt werden. Dies ermöglicht sogenannte "Path-Traversal-Angriffe", bei denen ein Angreifer versuchen könnte, Dateien außerhalb des vorgesehenen Verzeichnisses zu löschen.

Um dieses Sicherheitsproblem zu beheben, sollten Sie sicherstellen, dass die Benutzereingaben überprüft und bereinigt werden, um unerwünschte Zeichen oder Pfade zu verhindern. Eine Möglichkeit, dies zu tun, ist die Verwendung der os.path-Module, um Dateipfade sicher zu manipulieren.

Hier ist eine verbesserte Version des Codes, die das Sicherheitsproblem behebt:

import os
import os.path

UPLOADS_DIR = "/var/www/uploads/"

def delete_file():
    file_name = input("Geben Sie den Dateinamen zum Löschen ein: ")
    file_path = os.path.join(UPLOADS_DIR, file_name)

    # Überprüfen, ob der Dateipfad innerhalb des UPLOADS_DIR liegt
    if os.path.abspath(file_path).startswith(os.path.abspath(UPLOADS_DIR)):
        os.remove(file_path)
        print("Datei wurde gelöscht.")
    else:
        print("Ungültiger Dateiname.")

delete_file()

In dieser verbesserten Version wird die Funktion os.path.join() verwendet, um den Dateipfad sicher zu erstellen und die richtige Trennung der Verzeichnistrennzeichen zu gewährleisten. Der resultierende Dateipfad wird dann mit os.path.abspath() überprüft, um sicherzustellen, dass er sich innerhalb des erwarteten UPLOADS_DIR befindet. Durch diese Änderungen wird sichergestellt, dass nur Dateien innerhalb des vorgesehenen Verzeichnisses gelöscht werden können und potenzielle Sicherheitslücken vermieden werden.

Fazit

• Zu Aufgabe 1 - Effiziente Summenberechnung: Optimierung der Berechnung großer Summen von natürlichen Zahlen
• Zu Aufgabe 2 - Durchschnittsberechnung: Ermittlung des arithmetischen Mittels einer Liste von Zahlen in Python
• Zu Aufgabe 3 - Primfaktorzerlegung
• Zu Aufgabe 4 - Summe der Zahlen von 0 bis x
• Fazit

1. Aufgabe: Effiziente Summenberechnung: Optimierung der Berechnung großer Summen von natürlichen Zahlen

Dieser Code berechnet die Summe aller natürlichen Zahlen von 0 bis n-1. Wenn wir eine große Zahl als Eingabe (n) verwenden, kann es eine Weile dauern, um die Summe zu berechnen.

def find_sum(n):
    sum = 0
    for i in range(n):
        sum += i
    return sum

print(find_sum(1000000))

Die Ausführung des Code-Blocks hat 0.02502 Sekunden gedauert.

Promt: Wie kann man diesen Code optimieren, um die Berechnungszeit zu verkürzen?

Ergebnis: Hier ist eine optimierte Version des Codes:

def find_sum(n):
    sum = 0
    for i in range(n):
        sum += i
    return sum

print(find_sum(1000000))

Diese Version verwendet eine mathematische Formel, um die Summe aller natürlichen Zahlen von 0 bis n-1 zu berechnen, anstatt eine Schleife zu durchlaufen. Die Formel ist bekannt als die "Gaußsche Summenformel" oder auch "arithmetische Summenformel". Indem wir diese Formel verwenden, können wir die Berechnungszeit erheblich reduzieren. Die Division durch 2 wird verwendet, um eine Ganzzahl-Division sicherzustellen und das richtige Ergebnis zu erhalten, auch wenn n ungerade ist.

Wenn wir diese optimierte Version des Codes verwenden, wird die Summe der natürlichen Zahlen von 0 bis 999999 in weniger als einer Sekunde berechnet, im Gegensatz zur vorherigen Version, die mehrere Sekunden benötigt hätte.

Test in der Entwicklungsumgebung:

def find_sum(n):
    sum = 0
    for i in range(n):
        sum += i
    return sum

Output:

499999500000

Die Ausführung des Code-Blocks hat 0.00000 Sekunden gedauert.

2. Aufgabe: Durchschnittsberechnung: Ermittlung des arithmetischen Mittels einer Liste von Zahlen in Python

Gegeben ist eine Liste von Zahlen. Schreibe eine Funktion in Python, die das arithmetische Mittel dieser Zahlen berechnet.

def average(numbers):
    sum = 0
    count = 0
    for number in numbers:
        sum += number
        count += 1
    if count > 0:
        return sum / count
    else:
        return 0

Die Ausführung des Code-Blocks hat 0.00000 Sekunden gedauert.

Prompt: Wie kann ich die Länge dieses Codes verkürzen?

Ergebnis: Dieser Code funktioniert, aber er kann noch verbessert werden. Eine mögliche Verbesserung besteht darin, die Funktion sum() zu verwenden, um die Summe der Zahlen in der Liste zu berechnen, anstatt eine Schleife zu verwenden. Außerdem können wir die Bedingung if count > 0 entfernen, da die Division durch 0 nicht möglich ist und wir daher sicher sein können, dass count immer größer als 0 ist.

Hier ist der optimierte Code:

def average(numbers):
    sum = 0
    count = 0
    for number in numbers:
        sum += number
        count += 1
    if count > 0:
        return sum / count
    else:
        return 0

In diesem optimierten Code haben wir die Funktion sum() verwendet, um die Summe der Zahlen in der Liste zu berechnen, anstatt eine Schleife zu verwenden. Außerdem haben wir die Bedingung if count > 0 entfernt und sie durch if len(numbers) > 0 ersetzt, um sicherzustellen, dass wir immer eine Liste von Zahlen haben und nicht versehentlich eine leere Liste übergeben.

Test in der Entwicklungsumgebung:

def average(numbers):
    if len(numbers) > 0:
        return sum(numbers) / len(numbers)
    else:
        return 0

numbers = [1, 2, 3, 4, 5]
result = average(numbers)
print("Das arithmetische Mittel von", numbers, "ist", result)

Output:

Das arithmetische Mittel von [1, 2, 3, 4, 5] ist 3.0

3. Aufgabe: Primfaktorzerlegung

Dieser Code führt die Primfaktorzerlegung für die Zahl number durch:

def prime_factorization(n):
    factors = []
    divisor = 2

    while divisor <= n:
        if n % divisor == 0:
            factors.append(divisor)
            n /= divisor
        else:
            divisor += 1

    return factors
number = 999999998
factors = prime_factorization(number)
print("Primfaktoren von", number, ":", factors)

Die Ausführung des Code-Blocks führte zu folgendem Ergebnis:

Primfaktoren von 999999998 : [2, 691, 723589]
Ausführungsdauer: 0.083147 Sekunden

Prompt:

Lässt sich dieser Code für die Primfaktorzerlegung optimieren?

Ergebnis ChatGPT:

Ja, der Code für die Primfaktorzerlegung lässt sich optimieren, um die Ausführungszeit zu reduzieren. Hier ist eine optimierte Version des Codes:

def prime_factorization(n):
    factors = []
    divisor = 2

    while divisor * divisor <= n:
        if n % divisor == 0:
            factors.append(divisor)
            n //= divisor
        else:
            divisor += 1

    if n > 1:
        factors.append(n)

    return factors

# Eine große Zahl für die Primfaktorzerlegung
number = 999999998

# Berechnung der Primfaktorzerlegung
factors = prime_factorization(number)

print("Primfaktoren von", number, ":", factors)

Die Optimierungen im Code sind:

Wir verwenden die Bedingung divisor * divisor <= n anstelle von divisor <= n in der While-Schleife. Dadurch reduzieren wir die Anzahl der Schleifendurchläufe, da wir wissen, dass der größte Teiler einer Zahl nicht größer als die Quadratwurzel dieser Zahl sein kann.

Anstelle von n /= divisor verwenden wir n //= divisor, um eine Ganzzahldivision durchzuführen. Dadurch wird eine Fließkommaoperation vermieden und die Leistung verbessert.

Am Ende überprüfen wir, ob n größer als 1 ist. Wenn ja, fügen wir n als weiteren Primfaktor hinzu. Dies ist wichtig, um sicherzustellen, dass alle Primfaktoren erfasst werden, insbesondere wenn die eingegebene Zahl selbst eine Primzahl ist.

Durch diese Optimierungen wird die Ausführungszeit der Primfaktorzerlegung erheblich reduziert.

Test in der Entwicklungsumgebung:

import time
start = time.time()
def prime_factorization(n):
    factors = []
    divisor = 2

    while divisor * divisor <= n:
        if n % divisor == 0:
            factors.append(divisor)
            n //= divisor
        else:
            divisor += 1

    if n > 1:
        factors.append(n)

    return factors

# Eine große Zahl für die Primfaktorzerlegung
number = 999999998

# Berechnung der Primfaktorzerlegung
factors = prime_factorization(number)

print("Primfaktoren von", number, ":", factors)


end = time.time()
execution_time = end - start
print("Ausführungsdauer: {:.6f} Sekunden".format(execution_time))

Output:

Primfaktoren von 999999998 : [2, 691, 723589]
Ausführungsdauer: 0.001001 Sekunden

4. Aufgabe: Summe der Zahlen von 0 bis x

Dieser Code summiert die Zahlen von 0 bis 100 Millionen:

def perform_computation():
    result = 0
    for i in range(10**8):
        result += i
    return result
computation_result = perform_computation()
print("Berechnungsergebnis:", computation_result)

Berechnungsergebnis: 4999999950000000
Ausführungsdauer: 3.566159 Sekunden

Prompt: Lässt sich dieser Code im Hinblick auf die Ausführungsdauer optimieren?

Ergebnis ChatGPT:

Um die Ausführungsdauer des Codes zu optimieren, könnten wir die Berechnung durch eine mathematische Formel ersetzen, die die Summe der Zahlen von 0 bis n berechnet. Hier ist eine optimierte Version des Codes:

Berechnungsergebnis: 4999999950000000
Ausführungsdauer: 3.566159 Sekunden

In dieser optimierten Version verwenden wir die mathematische Formel für die Summe der Zahlen von 0 bis n, die als die Summe der aufeinanderfolgenden natürlichen Zahlen bekannt ist. Durch die direkte Berechnung der Formel anstelle einer Schleife wird die Ausführungsdauer erheblich verkürzt.

Test in der Entwicklungsumgebung:

import time
start = time.time()

def perform_computation():
    n = 10**8
    result = (n * (n + 1)) // 2
    return result

computation_result = perform_computation()
print("Berechnungsergebnis:", computation_result)

end = time.time()
execution_time = end - start
print("Ausführungsdauer: {:.6f} Sekunden".format(execution_time))

Output:

Berechnungsergebnis: 5000000050000000
Ausführungsdauer: 0.000000 Sekunden

Das Ergebnis liegt 1 daneben, aber ist von der zeitlichen Durchführung her deutlich reduziert.

Fazit

• Zu Aufgabe 1 - Matrizenmultiplikation in Python
• Zu Aufgabe 2 - Generierung einer großen Liste: Vermeidung von Speicherüberlauf durch effiziente Implementierung
• Zu Aufgabe 3 - Fakultätsberechnungen
• Zu Aufgabe 4 - Summe der Primzahlen
• Fazit

1. Aufgabe: Matrizenmultiplikation in Python

Diese Funktion multipliziert zwei Matrizen a und b und gibt das Ergebnis zurück. Sie verwendet verschachtelte Schleifen, um alle Elemente der beiden Matrizen zu durchlaufen. Wenn jedoch die Matrizen zu groß sind, kann dies zu einem Speicherüberlauf oder einer Ausführungszeitüberschreitung führen.

def multiply_matrices(a, b):

   result = []

   for i in range(len(a)):

       row = []

       for j in range(len(b[0])):

           element = 0

           for k in range(len(b)):

               element += a[i][k] * b[k][j]

           row.append(element)

       result.append(row)

   return result

Prompt:

Test diesen code auf mögliche Grenzen in seiner Ausführbarkeit:

   result = []

   for i in range(len(a)):

       row = []

       for j in range(len(b[0])):

           element = 0

           for k in range(len(b)):

               element += a[i][k] * b[k][j]

           row.append(element)

       result.append(row)

   return result

Ergebnis:

Der gegebene Code multipliziert zwei Matrizen. Im Allgemeinen ist die Ausführbarkeit des Codes von der Größe der Matrizen abhängig, die multipliziert werden sollen. Hier sind einige mögliche Grenzen, die berücksichtigt werden sollten:

1. Speicherbegrenzung: Der Code erstellt eine neue Matrix, um das Ergebnis zu speichern. Wenn die beiden Eingabematrizen sehr groß sind, kann dies dazu führen, dass der Computer nicht genügend Speicher hat, um das Ergebnis zu speichern. Dies kann zu einer Speicherüberlastung führen und den Code zum Absturz bringen.
2. Zeitbegrenzung: Der Code verwendet drei ineinander verschachtelte Schleifen, um das Ergebnis zu berechnen. Wenn die Matrizen sehr groß sind, kann dies dazu führen, dass der Code sehr langsam wird und möglicherweise gar nicht ausgeführt werden kann, bevor ein Timeout erreicht wird.
3. Eingabebegrenzung: Der Code geht davon aus, dass die beiden Eingabematrizen eine gültige Größe haben, um multipliziert werden zu können. Wenn eine der Matrizen leer ist oder eine ungültige Größe hat, kann dies zu Fehlern führen.
4. Datentypbegrenzung: Der Code geht davon aus, dass die Elemente der Matrizen numerisch sind und dass die Matrizen denselben Datentyp haben. Wenn die Matrizen andere Datentypen haben oder nicht numerisch sind, kann dies zu Fehlern führen.
5. Rundungsfehlerbegrenzung: Bei der Matrixmultiplikation können Rundungsfehler auftreten, insbesondere wenn die Matrizen sehr große oder sehr kleine Werte enthalten. Wenn die Genauigkeit der Ergebnisse wichtig ist, müssen möglicherweise spezielle Techniken zur Fehlerreduzierung verwendet werden.
6. Parallelisierungsbegrenzung: Der Code ist sequentiell geschrieben und nutzt nicht die Vorteile der parallelen Verarbeitung. Wenn die Matrizen sehr groß sind, kann es vorteilhaft sein, den Code parallel auszuführen, um die Verarbeitungszeit zu reduzieren.

import numpy as np

def multiply_matrices(a, b):
    if len(a[0]) != len(b):
        raise ValueError("Matrix dimensions don't match")

    a_np = np.array(a)
    b_np = np.array(b)

    result_np = np.dot(a_np, b_np)

    result = result_np.tolist()
    return result

Die Änderungen, die vorgenommen wurden, umfassen:

1. Verwendung von numpy: Numpy ist eine leistungsfähige Bibliothek für numerische Berechnungen in Python. Der Code verwendet die numpy-Bibliothek, um die Matrixmultiplikation durchzuführen, was zu einer besseren Leistung führen kann.
2. Fehlerprüfung: Der Code prüft, ob die Dimensionen der Eingabematrizen übereinstimmen. Wenn die Dimensionen nicht übereinstimmen, wird eine ValueError-Ausnahme ausgelöst.
3. Rückgabe des Ergebnisses als Liste: Der Code konvertiert das Ergebnis von numpy-Array in eine Liste, um die Ausgabe mit dem ursprünglichen Code kompatibel zu machen.

Dieser Code ist nicht nur schneller und effizienter, sondern berücksichtigt auch einige der möglichen Grenzen, die im ursprünglichen Code genannt wurden.

2. Aufgabe: Generierung einer großen Liste: Vermeidung von Speicherüberlauf durch effiziente Implementierung

Diese Funktion erstellt eine Liste der Größe size und füllt sie mit aufeinanderfolgenden Zahlen. Wenn size jedoch zu groß ist, kann dies zu einem Speicherüberlauf führen, da der Computer möglicherweise nicht genügend Speicherplatz hat, um die gesamte Liste zu erstellen.

def create_large_list(size):

   my_list = []

   for i in range(size):

       my_list.append(i)

   return my_list

Prompt:

Test diesen code auf mögliche Grenzen in seiner Ausführbarkeit:

def create_large_list(size):

   my_list = []

   for i in range(size):

       my_list.append(i)

   return my_list

Ergebnis:

Der Code sieht gut aus und sollte problemlos ausgeführt werden können, solange der verfügbare Arbeitsspeicher des Systems ausreicht, um eine Liste der angegebenen Größe zu erstellen.

Es gibt jedoch einige mögliche Grenzen, die die Ausführbarkeit des Codes beeinträchtigen können:

1. Speicherbegrenzung: Wenn der verfügbare Arbeitsspeicher des Systems nicht ausreicht, um eine Liste der angegebenen Größe zu erstellen, wird ein Speicherfehler auftreten.
2. Maximale Listenlänge: In Python gibt es eine maximale Listenlänge, die durch die Größe des zugewiesenen Speichers begrenzt wird. Die maximale Größe der Liste hängt also von der verfügbaren Systemressource ab. Wenn die maximale Listenlänge überschritten wird, wird ein Overflow-Fehler auftreten.
3. Rechenzeit: Wenn die Größe der Liste sehr groß ist, kann es länger dauern, um die Schleife auszuführen und die Liste zu erstellen. In diesem Fall kann die Ausführung des Codes eine längere Zeit in Anspruch nehmen oder zu einer Timeout-Exception führen.

Es ist jedoch unwahrscheinlich, dass diese Grenzen für eine typische Anwendung ein Problem darstellen werden, da die meisten Systeme über ausreichend Speicher und Rechenleistung verfügen, um eine Liste der angegebenen Größe zu erstellen.

3. Aufgabe: Fakultätsberechnungen

Prompt:
Führe für folgenden Code unit tests durch:

def factorial(n): 
 	if n == 0: 
 		return 1 
 	else: 
 		return n * factorial(n - 1)

Ergebnis ChatGPT:

Hier sind Unit-Tests für die gegebene Funktion factorial:

def test_factorial():
    # Testfall 1: Überprüfen der Fakultät von 0
    n_1 = 0
    expected_result_1 = 1
    assert factorial(n_1) == expected_result_1

    # Testfall 2: Überprüfen der Fakultät von 1
    n_2 = 1
    expected_result_2 = 1
    assert factorial(n_2) == expected_result_2

    # Testfall 3: Überprüfen der Fakultät von 5
    n_3 = 5
    expected_result_3 = 120
    assert factorial(n_3) == expected_result_3

    # Testfall 4: Überprüfen der Fakultät von 10
    n_4 = 10
    expected_result_4 = 3628800
    assert factorial(n_4) == expected_result_4

    print("Alle Tests erfolgreich durchgeführt.")


# Führe die Unit-Tests aus
test_factorial()

Die Unit-Tests umfassen verschiedene Testfälle, einschließlich der Fakultät von 0, 1, 5 und 10. Die erwarteten Ergebnisse werden festgelegt und mit den tatsächlichen Ergebnissen der factorial-Funktion verglichen. Wenn alle Tests erfolgreich sind, wird die Meldung "Alle Tests erfolgreich durchgeführt" ausgegeben. Andernfalls wird eine Fehlermeldung angezeigt, die angibt, welcher Test fehlgeschlagen ist.

4. Aufgabe: Summe der Primzahlen

Prompt:

Führe für folgenden Code unit tests durch:

def sum_of_primes(limit): 
 	prime_numbers = [] 
 	for num in range(2, limit + 1): 
 		is_prime = True 
 		for divisor in range(2, int(num ** 0.5) + 1): 
 			if num % divisor == 0: 
 				is_prime = False 
 				break 
 		if is_prime: 
 			prime_numbers.append(num) 
 	return sum(prime_numbers)

Ergebnis ChatGPT:

Entschuldigung, aber als textbasiertes KI-Modell kann ich den Code nicht direkt ausführen oder Unit-Tests durchführen. Ich kann jedoch den Code analysieren und Ihnen helfen, Testfälle zu definieren, die Sie selbst ausführen können. Hier sind einige Beispiele für Testfälle für die Funktion sum_of_primes:

def test_sum_of_primes():
    # Testfall 1: Überprüfen der Summe aller Primzahlen bis 10
    limit_1 = 10
    expected_result_1 = 17  # 2 + 3 + 5 + 7
    assert sum_of_primes(limit_1) == expected_result_1

    # Testfall 2: Überprüfen der Summe aller Primzahlen bis 20
    limit_2 = 20
    expected_result_2 = 77  # 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19
    assert sum_of_primes(limit_2) == expected_result_2

    # Testfall 3: Überprüfen der Summe aller Primzahlen bis 50
    limit_3 = 50
    expected_result_3 = 328  # 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 + 23 + 29 + 31 + 37 + 41 + 43 + 47
    assert sum_of_primes(limit_3) == expected_result_3

    print("Alle Tests erfolgreich durchgeführt.")


# Führe die Unit-Tests aus
test_sum_of_primes()

Sie können die Funktion test_sum_of_primes aufrufen, um die definierten Testfälle auszuführen und sicherzustellen, dass die Funktion sum_of_primes die erwarteten Ergebnisse liefert.

Fazit

• Zu Aufgabe 1 - Syntaxfehler beim Python-Taschenrechner: Debugging und Korrektur des Codes
• Zu Aufgabe 2 - Implementierung des binären Suchalgorithmus in Python
• Zu Aufgabe 3 - Nulldivision
• Zu Aufgabe 4 - Primzahltest-Durchläufe
• Fazit

1. Aufgabe: Syntaxfehler beim Python-Taschenrechner: Debugging und Korrektur des Codes

Ursprünglicher Code:

def divide_numbers(a, b):

result = a / b
return result

x = 10
y = 0

result = divide_numbers(x, y)

print(result)

Error des Codes:

def divide_numbers(a, b):

result = a / b
return result

x = 10
y = 0

result = divide_numbers(x, y)

print(result)

result = a / b
             ~~^~~
ZeroDivisionError: division by zero

Prompt: Debugge mir diesen Code:

def divide_numbers(a, b):

result = a / b
return result

x = 10
y = 0

result = divide_numbers(x, y)

print(result)

Ergebnis:

Gerne! Hier ist der Code, den Sie zur Fehlerbehebung bereitgestellt haben: 

def divide_numbers(a, b):

result = a / b
return result

x = 10
y = 0

result = divide_numbers(x, y)

print(result)

Dieser Code enthält eine Division durch 0, was zu einem Laufzeitfehler führt. Um diesen Fehler zu beheben, können Sie eine Überprüfung hinzufügen, um sicherzustellen, dass b nicht 0 ist, bevor die Division durchgeführt wird. Hier ist eine aktualisierte Version des Codes:

def divide_numbers(a, b):
    if b != 0:
        result = a / b
        return result
    else:
        print("Fehler: Division durch 0 ist nicht erlaubt!")
        return None

x = 10
y = 0
result = divide_numbers(x, y)
print(result)

Wenn Sie den aktualisierten Code ausführen, erhalten Sie die Ausgabe:

Fehler: Division durch 0 ist nicht erlaubt!
None

Durch die Überprüfung auf eine Division durch 0 wird vermieden, dass der Fehler auftritt. Stattdessen wird eine Fehlermeldung ausgegeben und None wird zurückgegeben, um anzuzeigen, dass kein gültiges Ergebnis vorliegt.

Test in der Entwicklungsumgebung:

def divide_numbers(a, b):
    if b != 0:
        result = a / b
        return result
    else:
        print("Fehler: Division durch 0 ist nicht erlaubt!")
        return None

x = 10
y = 0
result = divide_numbers(x, y)
print(result)

Output:

Fehler: Division durch 0 ist nicht erlaubt!
None

2. Aufgabe: Implementierung des binären Suchalgorithmus in Python

Error des Codes: None

Prompt: Debugge mir diesen Code:

def find_prime_numbers(limit):
    prime_numbers = []
    
    for num in range(2, limit + 1):
        is_prime = True
        
        for divisor in range(2, int(num ** 0.5) + 1):
            if num % divisor == 0:
                is_prime = False
                break
        
        if is_prime:
            prime_numbers.append(num)
    
    return prime_numbers

# Beispielaufruf
limit = 20
result = find_prime_numbers(limit)
print("Primzahlen bis", limit, ":", result)

Ergebnis ChatGPT:

Der Code, den Sie zur Verfügung gestellt haben, scheint korrekt zu sein und sollte die Primzahlen bis zum angegebenen Limit finden und ausgeben. Es gibt keinen offensichtlichen Fehler oder Anomalien im Code.

Ich werde den Code jedoch ausführen und eine zusätzliche Debugging-Anweisung hinzufügen, um den Verlauf der Schleifenvariablen zu überprüfen:

Wenn ich den Code mit dieser Debugging-Anweisung ausführe, erhalte ich die folgende Ausgabe:

def find_prime_numbers(limit):
    prime_numbers = []
    
    for num in range(2, limit + 1):
        is_prime = True
        
        for divisor in range(2, int(num ** 0.5) + 1):
            if num % divisor == 0:
                is_prime = False
                break
        
        if is_prime:
            prime_numbers.append(num)
    
    return prime_numbers

# Beispielaufruf
limit = 20
result = find_prime_numbers(limit)
print("Primzahlen bis", limit, ":", result)

Wenn ich den Code mit dieser Debugging-Anweisung ausführe, erhalte ich die folgende Ausgabe:

num: 2 divisor: 2
num: 3 divisor: 2
num: 3 divisor: 3
num: 4 divisor: 2
num: 5 divisor: 2
num: 5 divisor: 3
num: 5 divisor: 4
num: 6 divisor: 2
num: 7 divisor: 2
num: 7 divisor: 3
num: 7 divisor: 4
num: 7 divisor: 5
num: 7 divisor: 6
num: 8 divisor: 2
num: 9 divisor: 2
num: 9 divisor: 3
num: 10 divisor: 2
num: 11 divisor: 2
num: 11 divisor: 3
num: 11 divisor: 4
num: 11 divisor: 5
num: 11 divisor: 6
num: 11 divisor: 7
num: 11 divisor: 8
num: 11 divisor: 9

num: 12 divisor: 2
num: 13 divisor: 2
num: 13 divisor: 3
num: 13 divisor: 4
num: 13 divisor: 5
num: 13 divisor: 6
num: 13 divisor: 7
num: 13 divisor: 8
num: 13 divisor: 9
num: 13 divisor: 10
num: 13 divisor: 11
num: 13 divisor: 12
num: 14 divisor: 2
num: 15 divisor: 2
num: 15 divisor: 3
num: 16 divisor: 2
num: 17 divisor: 2
num: 17 divisor: 3
num: 17 divisor: 4
num: 17 divisor: 5
num: 17 divisor: 6
num: 17 divisor: 7
num: 17 divisor: 8
num: 17 divisor: 9
num: 17 divisor: 10

num: 17 divisor: 11
num: 17 divisor: 12
num: 17 divisor: 13
num: 17 divisor: 14
num: 17 divisor: 15
num: 17 divisor: 16
num: 18 divisor: 2
num: 19 divisor: 2
num: 19 divisor: 3
num: 19 divisor: 4
num: 19 divisor: 5
num: 19 divisor: 6
num: 19 divisor: 7
num: 19 divisor: 8
num: 19 divisor: 9
num: 19 divisor: 10
num: 19 divisor: 11
num: 19 divisor: 12
num: 19 divisor: 13
num: 19 divisor: 14
num: 19 divisor: 15
num: 19 divisor: 16
num: 19 divisor: 17

Die Ausgabe zeigt die Werte der Variablen num und divisor für jeden Schleifendurchlauf. Auf diese Weise können Sie überprüfen, ob die Schleifenlogik korrekt ist und ob die Variablen die erwarteten Werte haben.

In diesem Fall scheint der Code wie erwartet zu funktionieren und die Primzahlen bis zum angegebenen Limit zu finden.

Test in der Entwicklungsumgebung:

def find_prime_numbers(limit):
    prime_numbers = []

    for num in range(2, limit + 1):
        is_prime = True

        for divisor in range(2, int(num ** 0.5) + 1):
            print("num:", num, "divisor:", divisor, "Primzahlen:", prime_numbers)  # Debugging-Anweisung
            if num % divisor == 0:
                is_prime = False
                break

        if is_prime:
            prime_numbers.append(num)

    return prime_numbers


# Beispielaufruf
limit = 20
result = find_prime_numbers(limit)
print("Primzahlen bis", limit, ":", result)

Output:

Primzahlen bis 20: [2, 3, 5, 7, 11, 13, 17, 19]

Debug der Variablen (zuzüglich der Primzahlen)

num: 4 divisor: 2 Primzahlen: [2, 3]
num: 5 divisor: 2 Primzahlen: [2, 3]
num: 6 divisor: 2 Primzahlen: [2, 3, 5]
num: 7 divisor: 2 Primzahlen: [2, 3, 5]
num: 8 divisor: 2 Primzahlen: [2, 3, 5, 7]
num: 9 divisor: 2 Primzahlen: [2, 3, 5, 7]
num: 9 divisor: 3 Primzahlen: [2, 3, 5, 7]
num: 10 divisor: 2 Primzahlen: [2, 3, 5, 7]
num: 11 divisor: 2 Primzahlen: [2, 3, 5, 7]
num: 11 divisor: 3 Primzahlen: [2, 3, 5, 7]
num: 12 divisor: 2 Primzahlen: [2, 3, 5, 7, 11]
num: 13 divisor: 2 Primzahlen: [2, 3, 5, 7, 11]
num: 13 divisor: 3 Primzahlen: [2, 3, 5, 7, 11]
num: 14 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 15 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 15 divisor: 3 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 16 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 17 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 17 divisor: 3 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 17 divisor: 4 Primzahlen: [2, 3, 5, 7, 11, 13]
num: 18 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13, 17]
num: 19 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13, 17]
num: 19 divisor: 3 Primzahlen: [2, 3, 5, 7, 11, 13, 17]
num: 19 divisor: 4 Primzahlen: [2, 3, 5, 7, 11, 13, 17]
num: 20 divisor: 2 Primzahlen: [2, 3, 5, 7, 11, 13, 17, 19]

3. Aufgabe: Nulldivision

Ursprünglicher Code:

calculate_sum(lst):

   total_sum = 0

   for num in list

       total_sum += num

   return total_sum

numbers = [1, 2, 3, 4, 5]

result = calculate_sum(numbers)

print("The sum is: ", result)

Error des Codes:

calculate_sum(lst):
SyntaxError: invalid syntax

Promt: Debugge mir diesen Code:

def calculate_sum(lst):
    total_sum = 0
    for num in list
        total_sum += num
    return total_sum
numbers = [1, 2, 3, 4, 5]
result = calculate_sum(numbers)
print("The sum is: ", result)

Ergebnis:

Klar, hier ist der korrigierte Code:

def calculate_sum(lst):
    total_sum = 0
    for num in lst:
        total_sum += num
    return total_sum

numbers = [1, 2, 3, 4, 5]
result = calculate_sum(numbers)
print("The sum is: ", result)

Es gab zwei Fehler im ursprünglichen Code:

1. In der for-Schleife wurde die Variable lst als list geschrieben, was zu einem NameError geführt hat. Es muss jedoch lst geschrieben werden, um die Liste aus der Funktionsargumentübergabe zu verwenden.
2. Es gab keinen Doppelpunkt am Ende der for-Schleife, was zu einem Syntaxfehler geführt hat.

Durch diese beiden Korrekturen sollte der Code jetzt fehlerfrei ausgeführt werden. Die Funktion calculate_sum berechnet die Summe aller Zahlen in der übergebenen Liste lst, und das Ergebnis wird dann in der Variablen result gespeichert und ausgegeben.

Test in der Entwicklungsumgebung:

def calculate_sum(lst):
    total_sum = 0
    for num in lst:
        total_sum += num
    return total_sum

numbers = [1, 2, 3, 4, 5]
result = calculate_sum(numbers)
print("The sum is: ", result)

Output:

The sum is:  15

4. Aufgabe: Primzahltest-Durchläufe

Ursprünglicher Code: 
def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = (low + high) / 2
    while low <= high:
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
        mid = (low + high) / 2
    return -1

my_list = [1, 3, 5, 7, 9]
search_value = 7
result = binary_search(my_list, search_value)
if result != -1:
    print("Element is present at index", result)
else:
    print("Element is not present in array")

Error des Codes:

result = binary_search(my_list, search_value)
if arr[mid] < x:
TypeError: list indices must be integers or slices, not float

Der Fehler in dieser Funktion ist ein logischer Fehler. Der Fehler tritt auf, wenn der Index des gesuchten Elements nicht im ersten Versuch gefunden werden kann. Der Index mid muss bei jedem Schleifendurchlauf aktualisiert werden, aber in der aktuellen Implementierung wird mid nur einmal am Anfang der Funktion berechnet.

def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = (low + high) / 2
    while low <= high:
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
        mid = (low + high) / 2
    return -1

my_list = [1, 3, 5, 7, 9]
search_value = 7
result = binary_search(my_list, search_value)
if result != -1:
    print("Element is present at index", result)
else:
    print("Element is not present in array")

Promt: Debugge mir diesen Code:

Ergebnis: Die korrigierte Version der Funktion ist:

def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    mid = (low + high) / 2
    while low <= high:
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
        mid = (low + high) / 2
    return -1

my_list = [1, 3, 5, 7, 9]
search_value = 7
result = binary_search(my_list, search_value)
if result != -1:
    print("Element is present at index", result)
else:
    print("Element is not present in array")

Jetzt sollte die Funktion ordnungsgemäß ausgeführt werden und den Index des gesuchten Elements zurückgeben, wenn es im Array vorhanden ist.

Test in der Entwicklungsumgebung:

def binary_search(arr, x):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            return mid
    return -1

my_list = [1, 3, 5, 7, 9]
search_value = 7
result = binary_search(my_list, search_value)
if result != -1:
    print("Element is present at index", result)
else:
    print("Element is not present in array")

Output:

Element is present at index 3

Fazit

• Zu Aufgabe 1 - Rekursive Prüfung auf Array Maximalwert
• Zu Aufgabe 2 - Binärcodeumkehr
• Zu Aufgabe 3 - Fibonacci-Folge
• Zu Aufgabe 4 - Berechnung der Gesamtzahl aller Tiere auf dem Bauernhof
• Fazit

1. Aufgabe: Rekursive Prüfung auf Array Maximalwert

Prompt: Schreibe mir einen Python Code, der eine beliebige Liste von Ganzzahlen rekursiv überprüft und davon die höchste Zahl zurückgibt.

Antwort von Chat GPT:

Natürlich! Hier ist ein Beispielcode, der eine beliebige Liste von Ganzzahlen rekursiv überprüft und die höchste Zahl zurückgibt:

def find_max(numbers):
    if len(numbers) == 1:
        return numbers[0]
    else:
        first = numbers[0]
        rest = numbers[1:]
        max_rest = find_max(rest)
        if first > max_rest:
            return first
        else:
            return max_rest

# Beispielaufruf
numbers = [5, 10, 2, 8, 3]
maximum = find_max(numbers)
print("Die höchste Zahl ist:", maximum)

Der find_max-Funktion wird eine Liste numbers übergeben. Wenn die Länge der Liste 1 ist, wird das einzige Element in der Liste zurückgegeben. Andernfalls wird das erste Element first von der Liste abgetrennt und der Rest rest erstellt. Dann wird die find_max-Funktion rekursiv auf den Rest angewendet, um das Maximum max_rest der restlichen Zahlen zu finden. Schließlich wird überprüft, ob first größer ist als max_rest. Wenn ja, wird first als Maximum zurückgegeben, andernfalls wird max_rest zurückgegeben.

Im Beispielaufruf wird die Funktion mit der Liste [5, 10, 2, 8, 3] aufgerufen und das Ergebnis wird in der Variable maximum gespeichert. Dann wird das Ergebnis ausgegeben. In diesem Fall würde der Code 10 ausgeben, da dies die höchste Zahl in der Liste ist.

Test in der Entwicklungsumgebung:

def find_max(numbers):
    if len(numbers) == 1:
        return numbers[0]
    else:
        first = numbers[0]
        rest = numbers[1:]
        max_rest = find_max(rest)
        if first > max_rest:
            return first
        else:
            return max_rest

# Beispielaufruf
numbers = [5, 10, 2, 8, 3]
maximum = find_max(numbers)
print("Die höchste Zahl ist:", maximum)

Output:

Die höchste Zahl ist: 10

2. Aufgabe: Binärcodeumkehr

Prompt: Schreibe mir einen Code für folgende Aufgabenstellung:

Sie erhalten eine Liste mit 32-Bit-Ganzzahlen ohne Vorzeichen. Drehen Sie alle Bits 1 -> 0 und 0 -> 1 um und geben Sie das Ergebnis als vorzeichenlose Ganzzahl zurück.
Beispiel:
n = 4   
4 is 0100 in binary. We are working in 32 bits so:    
00000000000000000000000000000100 = 4           
11111111111111111111111111111011 = 4294967291     
return 4294967291

Antwort von Chat GPT:

Hier ist ein Python-Code, der die Aufgabenstellung löst:

def reverse_bits(n):
    # Konvertiere die Zahl in eine 32-Bit-Binärzahl
    binary = bin(n)[2:].zfill(32)
    
    # Invertiere die Bits
    inverted = ''.join('1' if bit == '0' else '0' for bit in binary)
    
    # Konvertiere die invertierte Binärzahl zurück in eine Ganzzahl
    result = int(inverted, 2)
    
    return result

# Beispielaufruf
n = 4
result = reverse_bits(n)
print(result)

Die Funktion reverse_bits erhält eine Ganzzahl n und führt die folgenden Schritte aus:

1. Konvertiere n in eine 32-Bit-Binärzahl und fülle sie links mit Nullen auf, falls nötig.
2. Invertiere jedes Bit in der Binärzahl, indem 1 in 0 umgewandelt wird und 0 in 1.
3. Konvertiere die invertierte Binärzahl zurück in eine Ganzzahl.

Im Beispielaufruf wird n als 4 angegeben. Die Funktion wendet die obigen Schritte an und gibt das Ergebnis 4294967291 zurück, was der vorzeichenlosen Ganzzahl entspricht, bei der alle Bits umgedreht wurden.

Test in der Entwicklungsumgebung:

def reverse_bits(n):
    # Konvertiere die Zahl in eine 32-Bit-Binärzahl
    binary = bin(n)[2:].zfill(32)
    
    # Invertiere die Bits
    inverted = ''.join('1' if bit == '0' else '0' for bit in binary)
    
    # Konvertiere die invertierte Binärzahl zurück in eine Ganzzahl
    result = int(inverted, 2)
    
    return result

# Beispielaufruf
n = 4
result = reverse_bits(n)
print(result)

Output:

4294967291

3. Aufgabe: Fibonacci-Folge

Promt: Fibonacci-Folge: Schreiben Sie eine Funktion, die die n ersten Terme der Fibonacci-Folge anzeigt, definiert durch: u0 = 1; u1 = 1 u(n+2) = u(n+1) + un

Ergebnis:

def fibonacci(n):
    """
    Diese Funktion gibt die ersten n Zahlen der Fibonacci-Folge aus.
    """
    # Initialisiere die ersten beiden Zahlen
    u0, u1 = 1, 1
    
    # Behandle Sonderfälle
    if n == 0:
        return []
    elif n == 1:
        return [u0]
    elif n == 2:
        return [u0, u1]
    
    # Generiere den Rest der Folge
    fib_seq = [u0, u1]
    for i in range(2, n):
        un = fib_seq[i-1] + fib_seq[i-2]
        fib_seq.append(un)
    
    return fib_seq

Sie können diese Funktion aufrufen, indem Sie die Anzahl der auszugebenden Zahlen übergeben:

>>> fibonacci(10)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

Diese Implementierung verwendet eine Schleife, um die Fibonacci-Folge zu generieren. Es initialisiert die ersten beiden Zahlen und generiert dann die nächsten Zahlen, indem es die beiden vorherigen Zahlen summiert. Die Liste fib_seq hält die Zahlen der Folge fest, während sie generiert werden. Schließlich gibt die Funktion die vollständige Folge als Liste zurück.

Beachten Sie, dass diese Implementierung durch Memoisierung oder andere fortgeschrittenere Techniken optimiert werden kann, aber dies sollte für kleine Werte von n ausreichend sein.

Test in der Entwicklungsumgebung:

def fibonacci(n):
    """
    This function displays the first n terms of the Fibonacci sequence.
    """
    # initialize the first two terms
    u0, u1 = 1, 1

    # handle special cases
    if n == 0:
        return []
    elif n == 1:
        return [u0]
    elif n == 2:
        return [u0, u1]

    # generate the rest of the sequence
    fib_seq = [u0, u1]
    for i in range(2, n):
        un = fib_seq[i - 1] + fib_seq[i - 2]
        fib_seq.append(un)

    return fib_seq

print(fibonacci(10))

Output:

Output: [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

4. Aufgabe:  Berechnung der Gesamtzahl aller Tiere auf dem Bauernhof

Promt: Bei dieser Aufgabe bittet Sie ein Bauer, ihm zu sagen, wie viele Beine alle seine Tiere haben. Der Landwirt züchtet drei Arten von Tieren:

     Hühner = 2 Beine

     Kühe = 4 Beine

     Schweine = 4 Beine

Der Landwirt hat seine Tiere gezählt und gibt Ihnen für jede Art eine Zwischensumme. Sie müssen eine Funktion implementieren, die die Gesamtzahl aller Tiere zurückgibt.

Ergebnis:

Hier ist eine mögliche Funktion in Python, die das Problem löst:

def count_legs(chickens, cows, pigs):
    """
    Given the number of chickens, cows, and pigs, return the total number of legs.

    Args:
    chickens (int): number of chickens
    cows (int): number of cows
    pigs (int): number of pigs

    Returns:
    int: total number of legs
    """
    total_legs = (chickens * 2) + (cows * 4) + (pigs * 4)
    return total_legs

Diese Funktion nimmt die Anzahl der Hühner, Kühe und Schweine als Argumente und berechnet dann die Gesamtzahl der Beine aller Tiere. Dazu wird einfach die Anzahl jedes Tieres mit der entsprechenden Anzahl Beine multipliziert und dann alle Produkte addiert.

Beispielaufruf:

total_legs = count_legs(10, 5, 2)
print(total_legs)  # Output: 54

In diesem Beispiel hat der Bauer 10 Hühner, 5 Kühe und 2 Schweine, was insgesamt 48 Beine ergibt.

Test in der Entwicklungsumgebung:

def count_legs(chickens, cows, pigs):
    """
    Given the number of chickens, cows, and pigs, return the total number of legs.

    Args:
    chickens (int): number of chickens
    cows (int): number of cows
    pigs (int): number of pigs

    Returns:
    int: total number of legs
    """
    total_legs = (chickens * 2) + (cows * 4) + (pigs * 4)
    return total_legs


total_legs = count_legs(10, 5, 2)
print(total_legs)

Output:

Output: 48

Fazit: