Seite 2 von 2
Re: Brainfuck Interpreter
Verfasst: Sonntag 24. Februar 2013, 19:40
von BlackJack
@fail: Nein, das würde nur funktionieren wenn *alle* Schleifen ineineinander geschachtelt sind, aber nicht wenn es Schleifen gibt, die nacheinander ausgeführt werden. Beispiel wo es nicht nach dem von Dir beschriebenen Muster funkioniert:
Code: Alles auswählen
...[...[...]...]...[...]... BF-Code
1 2 3 4 5 6 Klammer-Nr.
012345678901234567890123456 Code Index
1 2
Hier gehören zusammen: Klammern 1 und 4, 2 und 3, 5 und 6.
Du musst die Zeichen abgehen und dir Merken wie viele Klammern aktuell noch offen sind, für die Du noch keine schliessende Klammer gesehen hast.
Am besten macht man das am Anfang in einem Durchlauf und merkt sich in einem Wörterbuch welche Indizes in den Code zusammen gehören. Jeweils in beide Richtungen. Da kann man sich mit einem Stack die Positionen der noch offenen Klammern merken. Dann braucht man während des BF-Programmablaufs keinen Stack mehr und kann die jeweils andere Klammerposition ganz einfach ermitteln in dem man im Wörterbuch nachschaut. Für das Beispiel oben sähe das Wörterbuch so aus:
Re: Brainfuck Interpreter
Verfasst: Sonntag 24. Februar 2013, 19:47
von fail
Wie kann ich das mit dem Suchen machen?
Re: Brainfuck Interpreter
Verfasst: Sonntag 24. Februar 2013, 19:54
von BlackJack
@fail: Das habe ich im Grunde doch beschrieben. Ich nehme mal an *Du* kannst bei einem beliebigen Ausdruck mit korrekt verschachtelten Klammern heraus finden welche zusammen gehören. Dann musst Du ja auch beschreiben können wie Du auf das Ergebnis kommst. Das musst Du dann nur noch so genau/formal beschreiben, dass man es als Quelltext schreiben kann.
Re: Brainfuck Interpreter
Verfasst: Sonntag 24. Februar 2013, 20:43
von fail
Wo ist jetzt der fehler das Hello world Programm gibt irgendeine Komische ausgabe aus
Code: Alles auswählen
def Klammernpaare(code):
codeindex=0
listeoffen=[]
zuposition={}
offenposition={}
while codeindex<len(code):
if code[codeindex]=="[":
listeoffen.append(codeindex)
elif code[codeindex]=="]":
letze=listeoffen.pop()
zuposition[letze]=codeindex
codeindex +=1
for i in zuposition:
offenposition[zuposition[i]]= i
return offenposition, zuposition
def bf(code):
#Kommentare entfernen
code=[s for s in code if s in ("<",">","+","-",".",",")]
#aktuelle Zelle
cellindex=0
#Zellen
cells=[0]*30000
#Position im Code
codeindex=0
#Klammernpaare finden für Schleifen
offenposition, zuposition= Klammernpaare(code)
while codeindex < len(code):
index=code[codeindex]
if index==">":
cellindex +=1
elif index=="<":
cellindex -=1
elif index=="+":
cells[cellindex] +=1
elif index=="-":
cells[cellindex] -=1
elif index==".":
print(chr(cells[cellindex]), end="")
elif index==",":
cells[cellindex] = ord(input())
elif index=="[":
if cells[cellindex]== 0:
codeindex=zuposition[codeindex]
codeindex -=1
elif index=="]":
codeindex=offenposition[codeindex]
codeindex -=1
codeindex +=1
Re: Brainfuck Interpreter
Verfasst: Sonntag 24. Februar 2013, 20:51
von Sirius3
@fail: Dafür ist das Testen der einzelnen Funktionen gut. Tut jedes BF-Commando das was es soll, werden die Klammern richtig ermittelt, springt [ und ] an die richtige Stelle, usw.
Re: Brainfuck Interpreter
Verfasst: Mittwoch 27. Februar 2013, 21:32
von fail
Ihr müsst mir helfen ich hab keine Ahnung wo der Fehler liegt. Wahrscheinlich etwas mit den Schleifenindex
Re: Brainfuck Interpreter
Verfasst: Mittwoch 27. Februar 2013, 22:25
von Sirius3
1. vor die while-Schleife ein print(offenposition,zuposition)
2. in die while Schleife ein print(codeindex,index)
und dann von Hand Dein brain**** Programm durcharbeiten und schauen, ob der Computer auf die selben Ergebnisse kommt.
Re: Brainfuck Interpreter
Verfasst: Donnerstag 28. Februar 2013, 14:38
von fail
Scheint jetzt zu funktionieren. Noch eine Frage wie kann ich die Eingabe so machen das ich nicht enter drücken muss?
Code: Alles auswählen
def Klammernpaare(code):
codeindex=0
listeoffen=[]
zuposition={}
offenposition={}
while codeindex<len(code):
if code[codeindex]=="[":
listeoffen.append(codeindex)
elif code[codeindex]=="]":
letze=listeoffen.pop()
zuposition[letze]=codeindex
codeindex +=1
for i in zuposition:
offenposition[zuposition[i]]= i
return offenposition, zuposition
def bf(code):
#Kommentare entfernen
code=[s for s in code if s in ("<",">","+","-",".",",","[","]")]
#aktuelle Zelle
cellindex=0
#Zellen
cells=[0]*30000
#Position im Code
codeindex=0
#Klammernpaare finden für Schleifen
offenposition, zuposition= Klammernpaare(code)
while codeindex < len(code):
index=code[codeindex]
if index==">":
cellindex +=1
elif index=="<":
cellindex -=1
elif index=="+":
cells[cellindex] +=1
elif index=="-":
cells[cellindex] -=1
elif index==".":
print(chr(cells[cellindex]), end="")
elif index==",":
cells[cellindex] = ord(input())
elif index=="[":
if cells[cellindex]== 0:
codeindex=zuposition[codeindex]
elif index=="]":
codeindex=offenposition[codeindex]
codeindex -=1
codeindex +=1
Re: Brainfuck Interpreter
Verfasst: Freitag 1. März 2013, 19:39
von darktrym
Re: Brainfuck Interpreter
Verfasst: Freitag 1. März 2013, 20:39
von BlackJack
@darktrym: Weder noch würde ich sagen, sondern einfach ein Byte von der Standardeingabe lesen wie das Sirius3 weiter vorne im Thema schon mal in einem BF nach Python-Übersetzer gezeigt hat. So machen das jedenfalls alle anderen BF-Implementierungen die ich kenne. Man kann ja kein Terminal voraussetzen und die Eingaben müssen ja nicht zwingend aus Tastendrücken bestehen.
Re: Brainfuck Interpreter
Verfasst: Freitag 1. März 2013, 20:57
von darktrym
@BlackJack: Ich steh' grad auf dem Schlauch. Das("sys.stdin.read(1)") verhält sich doch wie raw_input unter Windows, Abschluss der Eingabe mit einem Enter. Und gerade das war nicht gewollt?
Re: Brainfuck Interpreter
Verfasst: Freitag 1. März 2013, 21:11
von BlackJack
@darktrym: Nein, so verhält sich das ``sys.stdin.read(1)`` nicht. Das liest genau ein Byte von der Standardeingabe des Prozesses. Das was Du beobachtest ist wahrscheinlich das Verhalten des Terminals was die Eingabe erst an den Prozess weiterleitet, wenn Du entweder das Zeichen für eine neue Zeile durch die Eingabetaste erzeugst oder den Datenstrom mit der entsprechenden Tastenkombination beendest. Unter Unix ist das Ctrl+D und unter Windows Ctrl+Z. Auf jeden Fall ist das das Verhalten was alle anderen (mit bekannten) BF-Interpreter an den Tag legen und was auch Sinn macht. Denn man möchte Ein- und Ausgabe in der Regel umleiten können.
Re: Brainfuck Interpreter
Verfasst: Samstag 2. März 2013, 18:59
von fail
Ich habe versucht es mit einem Dictionary umzusetzen aber nach eine Schleife beendet es mein Programm.
Code: Alles auswählen
import sys
def bf(code):
def Klammernpaare(code):
listeoffen=[]
zuposition={}
for s in code:
if s=="[":
listeoffen.append(code.index(s))
elif s=="]":
zuposition[listeoffen.pop()]=code.index(s)
offenposition=dict((zuposition[i],i) for i in zuposition)
return offenposition, zuposition
def ink():
cells[cellindex] +=1
def dek():
cells[cellindex] -=1
def vorne():
cellindex +=1
def hinten():
cellindex -=1
def ausgabe():
print(chr(cells[cellindex]), end="")
def eingabe():
cells[cellindex] = ord(sys.stdin.read(1)) #ord(input())
def schleifenanfang():
if cells[cellindex]== 0:
codeindex=zuposition[codeindex]
def schleifenende():
codeindex=offenposition[codeindex]
codeindex -=1
befehle={"+":ink,"-":dek,">":vorne,"<":hinten,".":ausgabe,",":eingabe,"[":schleifenanfang,"]":schleifenende}
#Kommentare entfernen
code=[s for s in code if s in ("<",">","+","-",".",",","[","]")]
#aktuelle Zelle
cellindex=0
#Zellen
cells=[0]*30000
#Position im Code
codeindex=0
#Klammernpaare finden für Schleifen
offenposition, zuposition= Klammernpaare(code)
while codeindex < len(code):
index=code[codeindex]
befehle[code[codeindex]]()
codeindex +=1
bf(input("Geben sie hier ihren Code ein: "))
input()