Sorry, ich find's wirklich nett von euch, dass ihr mir helfen wollt.
Aber wenn ihr euch so viel Mühe macht, dann schaut euch den Code vielleicht nochmal besser an.
Der Code ist immer noch nicht in Ordnung - dass etwas "funktioniert" ist kein gutes Argument, wenn man nicht weiß warum.
Wo schreib ich, dass ich nicht weiß warum? Ich verstehe meinen Code zu 100%. Zugegebenermaßen, ich hab ihn, als er nicht funktionierte nicht verstanden, da ich nicht wusste, wieso er nicht funktioniert
Ich glaube, ihr versteht ihn nicht ganz, drum erläutere ich ihn mal gleich etwas genauer.
Warum nimmst du (Zeile 8ff) keine Zählschleife?
Möglicherweise braucht es hier überhaupt keine Schleife (aber dazu habe ich mich - und da hast du mal Recht mit einer deiner Äußerungen - zu wenig in Brainfuck bzw. deinen Code hineingedacht), und du kommst mit der count()-Methode von Zeichenketten aus.
Auf jeden Fall: Die Bedingung in der while-Schleife ist unsinnig, weil sie immer True ist: i ist eine Ganzzahl, self.code (warum in Klammern?) eine Zeichenkette. Die Schleife beendet sich nicht, weil die Bedingung irgendwann falsch ist, sondern wenn das abschließende "]" gefunden ist und die Funktion verlassen wird.
Du sagst mir, wie unsinnig mein Code ist, aber vorher sagst du "vielleicht hab ich mich zu wenig hineingedacht"?
Du magst recht damit haben, dass man das auch ohne while-Schleife beziehungsweise mit einer Zählschleife (meinst du damit for?) machen könnte, aber das ist mir erstmal relativ egal. Ich hab die while-Schleife genommen, weil ich vorher die for-Schleife hatte, ich dort aber noch den Bug drin hatte, den ich beseitigen wollte. Also habe ich die gesamte Funktion neugeschrieben und um mich nicht wieder im selben Fehler zu verlieren, die while-Schleife genommen, da ich da gezwungen bin, den Code nochmal ein (bisschen) anders zu schreiben. Ich hab mir gedacht, dass mir das eventuell hilft, um nicht wieder denselben Fehler zu machen.
Dass meine Bedingung in der Schleife unsinnig ist, mag auch sein. Ein True würde es auch tun, sofern die Brainfuck-Syntax korrekt ist. Aber ansonsten hätte ich eine Endlosschleife, das wollte ich auch erstmal vermeiden, bis ich eine Methode zum Überprüfen der Syntax habe.
Warum ich die Klammern um self.Code habe, weiß ich nicht mehr, aber ist ja auch eigentlich egal.
Und: Deine Bedingungen im Schleifenkörper sind immer noch so, dass je nach Inhalt von self.code das return gar nicht erreicht wird. Wg. der immer wahren Bedingung erhältst du bei dieser Version dann eine Endlosschleife.
Habe ich ja gerade oben erklärt
Die Schleife ist auch nicht endlos, da die Bedingung nicht immer wahr ist. Ich erhöhe ja schließlich i am Ende?
@Hyperion:
Ich hab schon oft genug wiederholt, dass es keine anderen Möglichkeiten für die Funktion gibt, als ein return auszugeben. Okay ... Am Anfang hat's auch nicht gestimmt, aber das war, weil ich einen Bug im Code hatte, der etwas gemacht hat, was ich nicht wollte.
WIE soll denn bitte bei einem korrektem Brainfuck-Programm (davon gehen wir jetzt mal aus) KEIN Schleifenanfang zu einem Schleifenende gehören können?
Der Code macht nur folgendes: Falls das Feld == 0 ist, ignoriere die Schleife -> Suche dazu das passende Ende und springe dorthin, laufe anschließend einfach vom Ende aus weiter.
Da gibt es kein else oder sonst irgendwas.
Ich versteh auch nicht, warum zu jedem if ein return gehören soll. DAS ist doch gerade der Sinn: Wenn dies und das der Fall ist, tue dies und das und dreh noch ne Runde in der Schleife! Was soll da ein return? Das würde doch das Programm direkt beenden ohne dass die Schleife ein zweites Mal durchgelaufen ist. Außer ich habe einen else-Zweig, wenn der aber auch noch n return hat, dann überlebt die Schleife echt keine Runde.
Hier hab ich nochmal ein Beispiel dafür, dass der Code funktioniert:
Code: Alles auswählen
x = Brainfuck()
x.code = ",>++++>+<<[>-<-]>[>-<[-]]>[>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.[-]]"
x.run()
x.reset()
x.code = ",->,>+>>+<<<[>>>[<<<<+>>>>-]<<[-]<<[>>+<<-[>>>>+<<<<-]]>-]>[++++++.[-]]"
x.run()
x.reset()
x.code = """"->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>
+++>+>>++>+>+++>>++>++>>+>>+>++>++>+>>>>+++
>+>>>>++>++>>>>+>>++>+>+++>>>++>>++++++>>+>>
++>+>>>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>
+++>>>++>>+++++++++++++>>+>>++>+>+++>+>+++>>>
++>>++++>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>
++>>+++>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>
+++>+>++>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>
+>+>++>>>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+>
++++++++++++++++++>>>>+>+>>>+>>++>+>+++>>>++>
>++++++++>>+>>++>+>>>>+++>>++++++>>>+>++>>+++
>+>+>++>+>+++>>>>>+++>>>+>+>>++>+>+++>>>++>>+
+++++++>>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>
+>+++>>+>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+
<<]<+]+++++[->+++++++++<]>.[+]>>[<<+++++++
[->+++++++++<]>-.------------------->-[-<.<+>>]<[+]<+>>>]
<<<[-[-[-[>>+<++++++[->+++++<]]>++++++++++++++<]>+++
<]++++++[->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<]"""
x.run()
Ausgabe:
Code: Alles auswählen
>>> ================================ RESTART ================================
>>>
4 # Input zum 1.
T # Output zum 1.
23 # Input zum 2.
12 # Input zum 2.
# Output zum 2. unten drunter folgt die 3. Ausgabe
->+>+++>>+>++>+>+++>>+>++>>>+>+>+>++>+>>>>+++
>+>>++>+>+++>>++>++>>+>>+>++>++>+>>>>+++>+>>>
>++>++>>>>+>>++>+>+++>>>++>>++++++>>+>>++>+>>
>>+++>>+++++>>+>+++>>>++>>++>>+>>++>+>+++>>>+
+>>+++++++++++++>>+>>++>+>+++>+>+++>>>++>>+++
+>>+>>++>+>>>>+++>>+++++>>>>++>>>>+>+>++>>+++
>+>>>>+++>+>>>>+++>+>>>>+++>>++>++>+>+++>+>++
>++>>>>>>++>+>+++>>>>>+++>>>++>+>+++>+>+>++>>
>>>>++>>>+>>>++>+>>>>+++>+>>>+>>++>+>++++++++
++++++++++>>>>+>+>>>+>>++>+>+++>>>++>>+++++++
+>>+>>++>+>>>>+++>>++++++>>>+>++>>+++>+>+>++>
+>+++>>>>>+++>>>+>+>>++>+>+++>>>++>>++++++++>
>+>>++>+>>>>+++>>++++>>+>+++>>>>>>++>+>+++>>+
>++>>>>+>+>++>+>>>>+++>>+++>>>+[[->>+<<]<+]+++++
[->+++++++++<]>.[+]>>[<<+++++++[->+++++++++
<]>-.------------------->-[-<.<+>>]<[+]<+>>>]<<<[-[-[-[>>+
<++++++[->+++++<]]>++++++++++++++<]>+++<]++++++
[->+++++++<]>+<<<-[->>>++<<<]>[->>.<<]<<]
>>>
Klar ist das kein Beweis.
Aber imho ist das Programm auch nicht so kompliziert, dass man das mit irgendwelchen besonderen Methoden beweisen müsste.
Edit: Bei der Ausgabe des 2. Brainfuck-Codes wird irgendein Zeichen ausgegeben, das hier nicht dargestellt werden kann, aber es kommt trotzdem eine, was ja auch schon die Leerzeile beweist.
Edit (Georg): BF-Code umbrochen.
[/code]
