Schreiben von Code

• 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: