Noch ein Brainfuck-Parsing-Problem, aber diesmal ... anders.

Sie arbeiten in der Firma Infinite Monkeys Incorporated, die Brainfuck-Programme herstellt, um verschiedene interessante Probleme zu lösen (nicht weniger aus Versehen - schließlich erstellt die Firma zufällige Programme). Es scheint jedoch, dass Ihre schnellen Turing-Maschinen, die nur Brainfuck ausführen, ein kleines und teures Problem mit Syntaxfehlern haben - machen Sie eins, und der Computer explodiert. Es ist wahrscheinlich ein Designfehler, aber niemand hatte sich die Mühe gemacht, herauszufinden, warum es passiert.

Da Turing-Maschinen (besonders schnelle) teuer sind (schließlich haben sie unendlich viel RAM, was Kosten verursacht), ist es besser, sicherzustellen, dass das Programm keine Syntaxfehler aufweist, bevor Sie den Code ausführen. In Ihrem Unternehmen wird viel Code ausgeführt, sodass die manuelle Überprüfung nicht funktioniert. Schreiben Sie ein Programm, das den STDIN for Brainfuck-Code liest und mit einem anderen Exit-Status als 0 (Fehler) beendet, wenn das Programm einen Syntaxfehler aufweist (z. B. ]ein Syntaxfehler, da keine Übereinstimmung vorliegt [). Beenden Sie mit dem auf 0 gesetzten Beendigungsstatus, wenn das Programm vollständig in Ordnung ist.

Vergewissern Sie sich, dass Ihr Programm die Fehler korrekt erkennt []. Sie möchten doch nicht, dass ein anderer Computer explodiert, oder? Oh, und stellen Sie sicher, dass es so kurz wie möglich ist - Ihr Chef bezahlt für kurze Programme (weil er denkt, dass sie schnell sind oder so). Oh, und Sie müssen keinen Code in Brainfuck eingeben (das können Sie auch nicht, da Brainfuck keine Exit-Codes unterstützt) - Ihr Code wird auf einem normalen Computer ausgeführt.

Wie Sie sehen, müssen Sie überprüfen, ob das Brainfuck-Programm "gültig" ist (mit []Symbolen gepaart ). Beachten Sie, dass Brainfuck-Programme andere Zeichen als []enthalten können. Verweigern Sie das Programm daher nicht, nur weil es andere Befehle enthält. Kleinster Code gewinnt, aber wahrscheinlich interessieren Sie sich sowieso mehr für Upvotes.

GolfScript, 18 Zeichen

.{[]`?)},~](`91?./

Dieser Code wird erfolgreich mit dem Exit-Code 0 ausgeführt (und gibt einen Teil des Mülls nach stdout aus), wenn die eckigen Klammern in der Eingabe ausgeglichen sind. Wenn dies nicht der Fall ist, schlägt der Vorgang mit einem Exit-Code ungleich Null fehl und es wird eine Fehlermeldung an stderr ausgegeben, z.

(eval):2:in `/': divided by 0 (ZeroDivisionError)

oder

(eval):1:in `initialize': undefined method `ginspect' for nil:NilClass (NoMethodError)

Da die Herausforderung nichts über die Ausgabe an stdout / stderr aussagte, schätze ich, dass dies qualifiziert. In jedem Fall können Sie diese jederzeit an umleiten /dev/null.

Erläuterung:

Der Code entfernt {[]`?)},alles außer eckigen Klammern von der Eingabe und ~wertet das Ergebnis als GolfScript-Code aus. Der schwierige Teil ist, dass unausgeglichene Klammern in GolfScript vollkommen legal sind (und in der Tat enthält mein Code eine!), Also brauchen wir eine andere Möglichkeit, um den Code zum Absturz zu bringen.

Der Trick, den ich verwende, besteht darin, eine Kopie der Eingabe am unteren Rand des Stapels zu belassen, den gesamten Stapel in einem Array zusammenzufassen (unter Verwendung des Unsymmetrischen ]) und das erste Element auszuschalten. An diesem Punkt können drei Dinge passieren:

• Wenn die Eingabe nicht geschlossen wurde [und versucht wird, ein Element aus einem leeren Array herauszuschieben, stürzt der Interpreter ab (was in diesem Fall genau das ist, was wir wollen!)
• Wenn die Klammern in der Eingabe ausgeglichen waren, ist das verschobene Element die ursprüngliche Eingabezeichenfolge.
• Andernfalls (wenn der Eingang ungeöffnet ]oder nicht geschlossen war [) handelt es sich um ein Array.

Mein ursprünglicher Eintrag mit 14 Zeichen verglich dann den verschobenen Wert mit einer Zeichenfolge, die abstürzen würde, wenn es sich um ein verschachteltes Array handeln würde. Leider hat sich herausgestellt, dass das Vergleichen eines flachen (oder insbesondere leeren) Arrays mit einer Zeichenfolge auch in GolfScript zulässig ist, sodass ich den Kurs ändern musste.

Stattdessen verwendet meine aktuelle Übermittlung eine sehr brachiale Methode, um Arrays von Strings zu unterscheiden: Sie entfernt sie und versucht, das erste Vorkommen von [(ASCII-Code 91) zu finden, das genau dann null ist, wenn das nicht ausgewertete nicht vorhanden ist Variable war ein Array. Wenn dies der Fall ist, löst das Teilen der Null mit sich selbst den gewünschten Absturz aus.

Ps. Zwei weitere 18-Zeichen-Lösungen sind:

.{[]`?)},{.}%~](n<

und

.{[]`?)},~]([n]+n<

Leider habe ich noch keinen kürzeren Weg gefunden, um das "Problem mit leeren Arrays" zu lösen.

Brainfuck 76 Bytes

>>+[<+++++++++[->---------<]+>-[--[[-]<->]<[<[->-]>[<+]<]>]<[-<+>]+>,]<<[<+]

Dies geht verloren, wenn eckige Klammern unsymmetrisch sind und der bf-Interpreter / -Compiler ausfällt. Einige von ihnen haben Exit-Codes, die dies widerspiegeln.

erfordert eof = 0, umschließende Werte und endliche Anzahl von Zellen

In Ubuntu können Sie den Interpreter bf( sudo apt-get install bf) verwenden

% echo '[[[]' | bf -n bf_matching.bf
Error: Out of range! Youwanted to '<' below the first cell.
To solve, add some '>'s at the beginning, for example.
an error occured
% echo $? 
5
% bf -n bf_matching.bf < bf_matching.bf
% echo $?
0

Befunge 98 - 26 31 20 19 Zeichen

~:']-!\'[-!-+:0`j#q

Wurde einige massive Bedingungen los. Jetzt arbeitet das Programm wie folgt:

~:   read an input char and duplicate it

']-! push a 1 if the char is the ] char, 0 otherwise

\    swap the comparison value for the duplicated input char

'[-! push a 1 if the char is the [ char, 0 otherwise

-    subtract the two comparison values. If the second one is 1, the first is 0, 
     so the result is -1. Else if the second one is 0, the first is 1 and the result is
     1. Else, the first and the second are both 0 and the result is 0

+    Add the number to the counter (which is 0 if there is none already)

:0`  test if the counter is positive (that'd mean an invalid program). Pushes a 1 if 
     positive, 0 otherwise.

j#q  if the counter is positive, then this jumps to the q. Otherwise, it skips the q 
     and continues to the ~ at the beginning of the line. If there are no more chars in
     the input, then the IP will be sent back to the q. 

qBeendet das Programm und zeigt den obersten Wert als Fehlerwert an. Der Fehlerwert ist -1 1, wenn zu viele vorhanden sind ], 0, wenn sie ausgeglichen sind, und positiv negativ, wenn zu viele vorhanden sind [. Wenn die Zahl positiv oder negativ ist, werden so viele Absolutwerte dieser Zahl ]benötigt, um das Programm auszugleichen.

Bearbeiten: Inkrementieren und Dekrementieren umgeschaltet. [dient zum Inkrementieren des Zählers und ]zum Dekrementieren des Zählers . Durch Umschalten spare ich 1 Zeichen, da ich für die Ausgangsbedingung nur prüfen muss, ob der Zähler positiv und nicht negativ ist.

Alte Version

~:'[-!j;\1+\#;']-!j;1-#;:0\`j#q

Dieser Code funktioniert wie folgt:

~    read one char of input
:    duplicate it
'[-! push 1 if the character is [, 0 otherwise
j    jump that number of characters
;    skip until next ;
\1+\ increment counter

similarily for ].

#q when end of input is reached, ~ reflects the IP back. q ends the program with the error value on the stack.

Edit: erkannte, dass diese akzeptierten Eingaben wie ][, jetzt endet es, wenn die Zählung negativ wird, mit

:0\`j

J ( 38 35)

exit({:+.<./)+/\+/1 _1*'[]'=/1!:1[3

Erläuterung:

• 1!:1[3: lese stdin
• '[]'=/: Erstellt eine Matrix, in der die erste Zeile eine Bitmaske des [s in der Eingabe und die zweite Zeile das ]s ist.
• 1 _1*: multipliziere die erste mit 1 und die zweite mit -1.
• +/: Summiere die Spalten der Matrix und erhalte Delta-Einrückung pro Zeichen
• +/\: Erstelle eine laufende Summe von diesen und gib jedem Charakter die Einrückungsstufe
• ({:+.<./): Gibt die GCD des letzten Elements ( {:) und des kleinsten Elements ( <./) zurück. Wenn alle Klammern übereinstimmen, sollten beide übereinstimmen, 0damit dies zurückkehrt 0. Wenn die Klammern nicht übereinstimmen, wird ein Wert ungleich Null zurückgegeben.
• exit: Stellen Sie den Ausgangswert auf diesen Wert ein und beenden Sie den Vorgang.

Rubin (64)

exit $<.read.tr('^[]','').tap{|x|0while x.gsub!('[]','')}.empty?

vorher (68) war es:

exit ARGF.read.tr('^[]','').tap{|x| 0 while x.gsub!('[]','')}.empty?

Eine andere äquivalente Lösung verwendet

exit $<.read.tr('^[]','').tap{|x|0while x.gsub!('[]','')}.size>0

Kann nicht sizealleine verwendet werden, da dies zu falschen Negativen (!!!) führen würde, wenn die Gesamtzahl der unsymmetrischen Klammern ein Vielfaches von 256 ist

Perl, 30 Zeichen

Ihr grundlegender rekursiver Perl-Regex zur Rettung:

perl -0ne 'exit!/^(([^][]|\[(?1)\])*)$/'

Für diejenigen, die mit den hier verwendeten Befehlszeilenargumenten nicht vertraut sind: -0Ermöglicht das Festlegen des Zeilenendezeichens für die Zwecke der Dateieingabe; Wird -0kein Argument verwendet, wird das Zeilenendezeichen auf EOF gesetzt. -nLiest die Eingabe (in diesem Fall die gesamte Datei) automatisch $_vorher ein.

Wenn der reguläre Ausdruck übereinstimmt, wird ein wahrer Wert zurückgegeben, der für den Exit-Code auf 0 negiert wird. Andernfalls ergibt der falsche Rückgabewert einen Exit-Code von 1.

bash (tr + sed) - 42

[ -z `tr -Cd []|sed ":a;s/\[\]//g;t a"` ]

Wenn Ihnen Fehlermeldungen nichts ausmachen, können Sie das letzte Leerzeichen zwischen `und entfernen ], um Länge 41 zu erhalten.

Perl (56 Zeichen)

$/=0;$r=qr/[^][]*(\[(??{$r})\])*[^][]*/;<>=~m/^$r$/||die

Die naheliegende Perl-Lösung: ein rekursiver regulärer Ausdruck. Leider ist es ein ziemlich ausführliches Konstrukt.

Haskell (143)

import System.Exit
f=exitFailure
v c []|c==0=exitSuccess|True=f
v c (s:t)|c<0=f|s=='['=v(c+1)t|s==']'=v(c-1)t|True=v c t
main=getContents>>=v 0

zu jgon: Die Verwendung von 2 Wachen scheint dichter zu sein als wenn-dann-sonst. Ich glaube auch nicht, dass deine prüft, ob die Klammern in der richtigen Reihenfolge sind ("] [" passt)

C, 73 64 Zeichen

Dank Vorschlägen von breadbox (obwohl dies wahrscheinlich Little-Endian erfordert, um zu arbeiten):

i;main(c){while(read(0,&c,1)*(i+1))i+=(c==91)-(c==93);return i;}

Wie es funktioniert:

• implicit int global iwird auf 0 initialisiert
• cwird zu einem impliziten int, das wird argc(initialisiert auf 1, aber es ist uns egal, solange die höheren Bits nicht gesetzt sind)
• read(0,&c,1)Liest ein einzelnes Zeichen in das niedrige Byte von c (bei Little-Endian-Architekturen) und gibt bei EOF 0 zurück. i+1 != 0es sei denn, das ausgeglichene Klammer-Zitat geht auf -1; Das Multiplizieren funktioniert als (sicherer) Boolescher Wert UND das kostet ein Zeichen weniger als&&
• c==91ergibt 1 für '['und c==93ergibt 1 für ']'. (Möglicherweise gibt es einen kleinen Trick, aber mir fällt nichts ein.)
• return iWird mit dem Statuscode 0 beendet, wenn er ausgeglichen ist, und mit einem Wert ungleich Null, wenn dies nicht der Fall ist. Das Zurückgeben von -1 verstößt technisch gegen POSIX, aber das interessiert eigentlich niemanden.

Vorherige Version:

main(i){char c;i=0;while(read(0,&c,1)*(i+1))i+=(c==91)-(c==93);return i;}

Lua, 56

os.exit(("["..io.read"*a".."]"):match"^%b[]$"and 0 or 1)

GTB , 55

0→O:0→X[`I@I="[":X+1→X@I="]":X-1→X@X<0:1→O@!!Ig;e]l;e~O

Vermisst []

Verwenden Sie, 0um anzuhalten.

MATHEMATICA, 88 Zeichen

s = "[ [ my crazy code ] [ don't explode please! [] [ :)Ahh) ]  [] []]]";

r=StringReplace;
StringLength@FixedPoint[r[#,"[]"-> ""]&,r[s,Except@Characters["[]"]-> ""]]

Rubin, 59 58

Sucht nach öffnender und schließender Klammer, zählt [als 1 und ]als -1 und wird beendet, wenn die Anzahl unter 0 fällt.

b=0
$<.read.scan(/\]|\[/){exit 1if(b+=92-$&.ord)<0}
exit b

Hassium , 104 Bytes

func main(){l=0;r=0;b=input();foreach (c in b){if(c=="[")l++;if(c=="]")r++;}if(!(r==l))exit(1);exit(0);}

Voll ausgebaut (Anmerkung im Online - Interpreter funktioniert nicht als Eingang () deaktiviert ist) hier

Turing Machine Code, 286 276 Bytes

Auch hier verwende ich die hier definierte Regeltabellensyntax.

0 * * l 1
1 _ ! r Q
5 _ _ r 5
5 * * * W
W [ ! l E
W ] ! l T
W _ _ l I
W * ! r *
E ! ! l *
E * * * R
R _ [ r O
R * * l *
T ! ! l *
T * * * Y
Y _ _ r U
Y * * l *
U [ _ r O
U ! ! * halt-err
I ! ! l *
I _ _ r halt
I * * l halt-err
O ! ! r Q
O _ _ l I
O * * r *
Q ! ! r *
Q * * * W

Beendet in state halt, um die Eingabe zu akzeptieren und halt-errabzulehnen.

Pyth, 25 Bytes

Ilzv::z"[^[\]]"k"]\[""],[

Probieren Sie es online!

import re
z=input()
if len(z):
 print(eval(re.sub("]\[","],[",re.sub("[^[\]]","",z))))

Haskell ( 167 , 159)

Habe das hauptsächlich zum Spaß gemacht, wenn jemand Vorschläge hat, wie man es kürzer macht, würde ich mich freuen, wenn ich sie höre :)

import System.Exit
p x y b|b=x|True=y
main=getContents>>=(return.all (>=0).scanl (\v->p (v-1) (v+1).(==']')) 0.filter (`elem`"[]"))>>=p exitSuccess exitFailure

Bearbeiten: Es wurde ein Problem behoben, auf das ich in den Kommentaren hingewiesen wurde (11 Byte hinzugefügt).

Bearbeiten 2: Zusatzfunktion zum Testen von Prädikaten mit von user13350 inspirierten Guards erstellt, wobei 8 Bytes entfernt wurden.

Stax , 14 11 Zeichen

╬Äτ↔EªÉs «Ü

Führen Sie es aus und debuggen Sie es

Gutschrift auf @recursive für -3 Bytes.

ASCII-Äquivalent:

.[]Y|&{yz|egp!

Entfernen Sie alle Zeichen außer []und dann, []bis sich die Zeichenfolge nicht mehr ändert. Rückgabe, 1wenn die letzte Zeichenfolge leer ist.