Eine "Triplett-Klammer" (die ich für diese Herausforderung erfunden habe) ist eine der folgenden:

(...+...)
[...:...]
{...|...}
<...-...>

Eine symmetrische Triplett-Klammer-Zeichenfolge (kurz BTBS) ist entweder eine leere Zeichenfolge, zwei verkettete BTBS oder eine der obigen Triplett-Klammern, wobei jede ...durch eine BTBS ersetzt wird.

Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben, die überprüft, ob eine Zeichenfolge, die nur aus (+)[:]{|}<->besteht, ausgeglichen ist. Kürzester Code gewinnt.

Beispiele

Ihr Programm sollte für die folgenden Zeichenfolgen die Wahrheit zurückgeben:

(+)(+)(+)
[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)
<<<<<<<<<<<<->->->->->->->->->->->->
{|(+[:<-{|(+[:<->])}>])}
[[[:]:[:]]:[[:]:[:]]]
{[:](+)|<->{|}}[(+)<->:{|}(+)]

Ihr Programm sollte für die folgenden Zeichenfolgen einen Fehler zurückgeben:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->

Japt, 25 Bytes

!Ue"%(%+%)|%[:]|\{%|}|<->

Testen Sie es online!

eon strings ist eine rekursive Ersetzungsfunktion. Der zweite Parameter ist standardmäßig die leere Zeichenfolge. Dies bedeutet, dass Übereinstimmungen mit dem "%(%+%)|%[:]|\{%|}|<->"regulären Ausdruck Japt rekursiv entfernt werden /\(\+\)|\[:]|{\|}|<->/. Dies gibt eine leere Zeichenfolge für ausgeglichene Triplett-Zeichenfolgen und eine nicht leere Zeichenfolge für nicht ausgeglichene zurück, sodass der richtige Rückgabewert das logische NICHT davon ist.

JavaScript (ES6), 77 58 57 56 Bytes

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

Testfälle

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

console.log("Testing truthy values");
console.log(f("(+)(+)(+)"));
console.log(f("[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)"));
console.log(f("<<<<<<<<<<<<->->->->->->->->->->->->"));
console.log(f("{|(+[:<-{|(+[:<->])}>])}"));
console.log(f("[[[:]:[:]]:[[:]:[:]]]"));
console.log(f("{[:](+)|<->{|}}[(+)<->:{|}(+)]"));

console.log("Testing falsy values");
console.log(f(":["));
console.log(f("<|>"));
console.log(f("(+(+)"));
console.log(f("[:][:](+[[:]):]"));
console.log(f("{|{|{|(+{|{|{|}}}}}+)}[:]{|}"));
console.log(f("{{||}}"));
console.log(f("<<->-<->-<->>"));
console.log(f("[(+):((+)+)+(+(+))]"));
console.log(f("<<<<<->->->->->->"));

sed, 28 27 bytes

:
s#(+)\|\[:]\|{|}\|<->##
t

sed hat kein Konzept von Wahrhaftigkeit / Falschheit, daher betrachte ich eine leere Zeichenfolge als wahr und eine nicht leere Zeichenfolge als falsch. Dies prüft, ob wir die Bedingung berücksichtigen /^$/.

Vielen Dank an @Neil für das Golfen ab 1 Byte!

Probieren Sie es online!

Python, 77 Bytes

lambda s:eval("s"+".replace('%s','')"*4%('(+)','[:]','{|}','<->')*len(s))==''

Verwendet Arnauld's Ersatzidee . Erzeugt und wertet einen langen String wie

s.replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','').replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','')

um zwischen dem Ersetzen aller Klammertypen zu wechseln. Überprüft dann, ob das Ergebnis die leere Zeichenfolge ist.

Mathematica, 55 Bytes

StringDelete["(+)"|"[:]"|"{|}"|"<->"]~FixedPoint~#==""&

Anonyme Funktion. Nimmt einen String als Eingabe und gibt ihn zurück Trueoder Falseals Ausgabe. Verwendet dazu die Standardmethode.

Schmutz , 39 Bytes

e`\(_\+_\)|\[_\:_\]|\{_\|_\}|\<_\-_\>v*

Probieren Sie es online! Leider verfügt die TIO-Version in den meisten Testfällen nicht über genügend Arbeitsspeicher.

Erläuterung

Nichts Besonderes hier. _Abkürzung für das gesamte Muster ist, und v*ist das gleiche wie *, aber mit einer geringeren Priorität.

e`                                       Match entire input against this pattern:
  \(_\+_\)                               '(', match of _, '+', match of _, ')'
          |                              or
           \[_\:_\]|\{_\|_\}|\<_\-_\>    same for the other bracket types
                                     v*  repeated 0-∞ times

J, 48 Bytes

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_

Ähnlich wie die anderen basiert auch dies auf der Methode von Arnauld .

Verwendung

   f =: a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_
   f '(+)(+)(+)'
1
   f '[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)'
1
   f '<<<<<<<<<<<<->->->->->->->->->->->->'
1
   f '<|>'
0
   f '[:][:](+[[:]):]'
0
   f '{|{|{|(+{|{|{|}}}}}+)}[:]{|}'
0

Erläuterung

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_  Input: string S
   (                                        )^:_  Repeat until convergence
                                         ]          Get S
                 '(+)';'[:]';'{|}';'<->';           Append to ['(+)', '[:]', '{|}', '<->']
    [:delstring&.>/                                 Reduce right-to-left by deleting
                                                    occurrences of each string on the
                                                    left from the right
                                                    Return the final string as the new S
a:=                                               Test if the final value of S is empty

Scala, 96 Bytes

def&(s:String):Any={val t=s.replaceAll(raw"\(\+\)|\[:]|\{\|}|<->","")
if(t==s)t.size<1 else&(t)}

Dies ist im Grunde die gleiche Idee wie die anderen Antworten, aber mit etwas Scala-Boilerplate.

ohne Ideen von anderen zu stehlen (188 Bytes):

import scala.util.parsing.combinator._
val a = new RegexParsers{def r:Parser[_]="("~r~"+"~r~")"|"["~r~":"~r~"]"|"{"~r~"|"~r~"}"|"<"~r~"-"~r~">"|""
def!(s:String)= !parseAll(r,s).isEmpty}!_

Pip , 26 Bytes

L#aaR:"(+)[:]{|}<->"<>3x!a

Probieren Sie es online!

Schleifen Sie len (a) times und ersetzen Sie alle Vorkommen von leeren Triplett-Klammern ( "(+)[:]{|}<->"<>3wobei <>der Operator "group" ist, => ["(+)"; "[:]"; "{|}"; "<->"]) durch leere Zeichenfolge ( x). Diese vielen Iterationen sind übertrieben, aber es wird immer mehr als genug sein, um alle richtig geformten Triplett-Klammern vollständig auf Null zu reduzieren. Nach Beendigung der Schleife wird Folgendes ausgegeben !a: 0if aist wahr (hat noch einige Zeichen), 1if aist falsch (leer).