Klausur falsch korrigiert?

[Pagega]

Moin,

ich habe meine Informatikklausur zurück bekommen und habe das Gefühl das mein Lehrer diese falsch korrigiert hat. Leider lässt er da wenig mit sich reden.






Wie er beim Code geschrieben hat, passen mein Programmablaufplan und Struktogramm wohl nicht zum Code. Das sehe ich anders.

Dann meinte er noch das meine Lösung sowieso nicht richtig ist und niemand das so machen würde weil ich ja keine zwei for-Schleifen benutzt habe um die Potenz zu berechnen Mitdenken ist anscheinend also auch nicht gewünscht. Ich habe mir halt ne Hilfsvariable genommen und es über die gleiche Schleife laufen lassen.


Dann hat er bemängelt das ich im Struktogramm und Ablaufplan keine Fußgesteuerte Schleife benutzt habe. Dabei soll mein Struktogramm am Ende doch zum Code passen Naja auch wenn wir im Unterricht mehrfach durchgekaut haben das es diese in Python nicht gibt hat er nie bemängelt wenn ich ne Kopfgesteuerte eingezeichnet habe, außer jetzt in der Klausur.

Weiterhin habe ich noch Punktabzug bekommen weil ich bei Structorizer einfach meine Daten eingetragen habe und nicht den kompletten automatisch erstellten Text geändert habe. Benutzen wir nicht extra dafür so ein Programm ?

Und manche Sachen hat er als falsch angestrichen weil er sie nicht verstanden hat. Wie zb. den Teil am Ende wo ich abfrage ob der Benutzer das Programm beenden möchte und warum ich Basis und Exponent vor der Schleife definiere.

Achso und was das while True: bedeutet hat er auch nicht so ganz verstanden XD.

Da ich mir nicht sicher bin ob die Bilder jetzt laden oder nicht hier nochmal der Ori-Text der Aufgabenstellung:

Code: Alles auswählen

Wichtig: Bewertet werden nur die Dateien! Sorgen Sie also für eine regelmäßige, richtige Speicherung.
 allein sie sind für die Speicherung verantwortlich, denn bei Verlust zählt die Arbeit als nicht abgegeben und als ungenügend. Benennen Sie die Dateien mit ihrem Nachnamen Aufgabennummer und speichern Sie auf dem USB-Stick

Sie sollen ein Programm erstellen, mit dem man eine beliebige Potenz aus einer ganzen Zahl berechnen kann. Es wurden schon erste Überlegungen zu den Begrifflichkeiten getätigt Die Zahl, von der die Potenz berechnet werden soll, heißt Basis.

Die Hochzahl, die zeigt, wie oft die Basis miteinander multipliziert wird, heißt Exponent Das Ergebnis wird als Potenz bezeichnet.

Aufgabe 1:

Schreiben sie ein Programmablaufplan und ein Struktogramm für ein Programm, mit dem Sie die n'te Potenz zu einer Zahl X errechnen können.

Zur Ermittlung der Potenz soll eine gezählte Wiederholungsschleife verwendet werden Beachten Sie auch die Besonderheit, wenn eine Zahl hoch 0 gerechnet wird (dann ist das Ergebnis als.1 definiert, egal, wie die Basis ist).

Wenn ich als Exponent eine negative Zahl eingebe, funktioniert die Zahlschleife nicht mehr Man kann aber die Zählschleife rückwärts zählen lassen (in Schleifenbedingung schreiben: Zähler-1
 Wie könnte ich das Programm ergänzen, damit auch hier das richtige Ergebnis herauskommt (Achtung negativer Exponent bedeutet potenzieren mit dem positiven Exponenten und dann noch mal 1/Ergebnis rechnen)

Hinweis: Auf dem Taschenrechner sieht die Taste so aus: Yoder oder X^Y

Das Programm soll erst beendet werden, wenn dieses abgefragt und eingegeben wurde

Aufgabe 2:

Schreiben sie das Programm in Python, mit dem Sie die n'te Potenz zu einer Zahl X berechnen können.

(Bedingungen siehe Aufgabe 1).

Und hier zum Vergleich auch noch mein Code:

Code: Alles auswählen

#Begrüßung/Programmstart
print("Willkommen zuu meinem Exponenten-Rechner")

#festlegen von Variablen
basis = 1
exponent = 1

while True: #Programmhauptschleife
    
    #erneutes festlegen von Variablen
    potenz = 1
    negativer_exponent = False
    
    #Benutzerabfragen
    basis = int(input("Geben sie die Basis ein: "))
    exponent = int(input("Geben sie den Exponenten ein: "))
    
    #Berechnung der Potenz
    if exponent != 0:
        if exponent < 0:
            exponent *= -1
            negativer_exponent = True
            
        for i in range(1, exponent + 1):
            potenz *= basis
            
        if negativer_exponent == True:
            potenz = 1/potenz
            
    #Ausgabe des Ergebniss
    print(potenz)
    
    #Abfrage des Neustarts
    if input("Möchten sie das Programm beenden [j/n]? ").lower() == "j":
        print("Auf Wiedersehen")
        break
        #Programm Ende
    else:
        continue
        #Programm wiederholen
    

Und annähernd der von meinem Lehrer:

Code: Alles auswählen

#Begrüßung/Programmstart
print("Willkommen zuu meinem Exponenten-Rechner")

#festlegen von Variablen
basis = 1
exponent = 1

while True: #Programmhauptschleife
    
    #erneutes festlegen von Variablen
    potenz = 1
    negativer_exponent = False
    
    #Benutzerabfragen
    basis = int(input("Geben sie die Basis ein: "))
    exponent = int(input("Geben sie den Exponenten ein: "))
    
    #Berechnung der Potenz
    if exponent != 0:
        if exponent > 0:
            for i in range(1, exponent + 1, 1):
                potenz *= basis
                      
        else:
            for i in range(exponent - 1, -1, 1):
                potenz *= basis
            potenz = 1/potenz
            
    #Ausgabe des Ergebniss
    print(f"Die Potenz ist: {potenz}")
    
    #Abfrage des Neustarts
    if input("Möchten sie das Programm beenden [j/n]? ").lower() == "j":
        print("Auf Wiedersehen")
        break
        #Programm Ende
    else:
        continue
        #Programm wiederholen
    

[narpfel]

Beide Lösungen sind IMHO nicht gut (auch wenn sie wahrscheinlich das richtige Ergebnis liefern; bei sind zu kompliziert geschrieben als dass man sie einfach verstehen könnte):

`basis` und `exponent` werden vor der `while`-Schleife angelegt, aber die Werte werden nie gelesen. Die beiden Zeilen sind also komplett unnötig.

Dann werden `potenz` und `negativer_exponent` zu früh festgelegt. Generell gilt, dass Variablen erst so kurz wie möglich vor ihrer Verwendung angelegt werden sollten. Dadurch muss man weniger gleichzeitig im Kopf behalten und der Code wird einfacher zu verstehen.

Bei der Eingabe von `basis` und `exponent` wird nicht abgefangen, dass auch Sachen eingegeben werden können, die keine Zahlen sind. Normalerweise würde ich bei einer solchen Aufgabe erwarten, dass man das beachten muss, außer in der Aufgabenstellung steht explizit, dass die Eingaben als gültig angenommen werden dürfen.

Die Abfrage auf `exponent == 0` ist komplett unnötig, weil die Schleife sonst einfach Null mal laufen würde und man den gleichen Effekt hätte.

`range(1, exponent + 1)` ist komisch, weil man auch einfach `range(exponent)` für den gleichen Effekt schreiben könnte und man bei letzterem sofort sieht, dass die Schleife `exponent` mal durchlaufen wird. Noch schlimmer ist `range(1, exponent + 1, 1)`, weil da auch unnötigerweise der Defaultwert der Schrittweite nochmal hingeschrieben wurde. Bei `range(exponent - 1, -1, 1)` habe ich gar keine Ahnung, wie oft die Schleife durchlaufen wird. Das würde ich so niemals schreiben, wenn ich einfach nur `abs(exponent)` mal etwas wiederholen wollen würde.

Ein Vergleich mit `True` macht keinen Sinn. `negativer_exponent` ist entweder `True` oder `False`, und `True == True` ergibt `True`, `False == True` ergibt `False`. Also hat man am Ende wieder genau den Wert von `negativer_exponent`. Das ist so, also würde man an eine Rechnung mit Zahlen `* 1 + 0` am Ende ranpacken, es sollte also einfach `if negativer_exponent:` heißen. Und ein `!= True` würde auch keinen Sinn machen, dafür gibt es `not`.

Das `else: continue` am Ende macht gar nichts: Wenn die Schleife am Ende von ihrem Körper angekommen ist, fängt sie wieder oben an (wäre ja auch doof, wenn eine Schleife nicht automatisch Code mehrfach ausführen würde).

Ich finde den Ansatz mit einer `for`-Schleife besser, weil man damit vermeidet, den gleichen Code zwei mal zu schreiben. Man hat also auch nur die Hälfte an Chancen, Fehler zu machen.

Allerdings würde ich das eher so schreiben (ungetestet):

Code: Alles auswählen

def main():
    print("Potenzberechnung")
    while True:
        # TODO: richtige Fehlerbehandlung
        basis = int(input("Basis eingeben: "))
        exponent = int(input("Exponent eingeben: "))
        potenz = 1
        for _ in range(abs(exponent)):
            potenz *= basis
        if exponent < 0:
            potenz = 1 / potenz
        print(f"({basis}) ** {exponent} = {potenz}")
        if input("nochmal? [Yn] ").lower() == "n":
            break


if __name__ == "__main__":
    main()

Und dann gibt es da noch so lustige Randfälle wie 0 ** (-1) oder 2 ** (-10_000), über die man sich Gedanken machen könnte.

[__blackjack__]

@Pagega: Struktogramm und Programmablaufplan müssen zwar zum Programm passen, aber alle sollen jeweils die Absicht so gut wie möglich ausdrücken. Wenn man eine Schleife hat, wo am Schleifenende geprüft wird ob der Benutzer noch mal wiederholen möchte, dann ist das eine fussgesteuerte Schleife. In Struktorgrammen und Programmablaufplänen kann man das explizit darstellen und sollte das natürlich auch, denn das soll ja die Idee vermitteln. In Python gibt es dafür keine spezielle Syntax, also muss man da ``while True:`` und am Ende ``if …: break`` schreiben.

Ergänzend zur Anmerkung von narpfel zu `range()` mit negativer Schrittweite: So etwas drücke ich immer als ``reverse(range(…))`` mit positiver Schrittweite aus, eben auch das man da nicht nachdenken muss, denn da entstehen sonst öfter mal Fehler die ±1 Schritte daneben liegen, je nach dem in welche Richtung man sich geirrt hat.