„Trójkątny wspornik” (który przygotowałem na to wyzwanie) to jedno z poniższych:

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

Zrównoważony ciąg nawiasów tripletowych (w skrócie BTBS) jest albo pustym ciągiem, połączonymi dwoma BTBS, albo jednym z powyższych nawiasów tripletowych, z których każdy jest ...zastąpiony BTBS.

Twoim zadaniem jest napisanie programu lub funkcji, która sprawdza, czy ciąg składający się tylko z (+)[:]{|}<->jest zrównoważony. Najkrótszy kod wygrywa.

Przykłady

Twój program powinien zwracać wartość true dla następujących ciągów:

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

Twój program powinien zwrócić fałsz dla następujących ciągów:

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

Japt, 25 bajtów

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

Przetestuj online!

ena ciągach jest funkcją zastępowania rekurencyjnego. Drugi parametr domyślnie przyjmuje pusty ciąg, co oznacza, że ​​rekurencyjnie usuwa dopasowania wyrażenia "%(%+%)|%[:]|\{%|}|<->"regularnego Japt (w normalnych warunkach /\(\+\)|\[:]|{\|}|<->/). Zwraca pusty ciąg dla zrównoważonych ciągów tripletowych i niepusty ciąg dla niezrównoważonych, więc poprawna wartość zwracana jest logicznym NIE tego.

JavaScript (ES6), 77 58 57 56 bajtów

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

Przypadki testowe

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 bajtów

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

sed nie ma pojęcia „prawda / fałsz”, więc rozważam pusty ciąg znaków „prawda” i niepusty ciąg znaków „fałsz”. Sprawdza to, czy rozważamy warunki warunkowe /^$/.

Dzięki @Neil za grę w golfa z 1 bajtu!

Wypróbuj online!

Python, 77 bajtów

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

Wykorzystuje pomysł zastępowania Arnaulda . Generuje i ocenia długi ciąg znaków

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

aby przełączać się między wymianą wszystkich typów wsporników. Następnie sprawdza, czy wynikiem jest pusty ciąg.

Mathematica, 55 bajtów

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

Funkcja anonimowa. Bierze ciąg jako dane wejściowe i zwraca Truelub Falsedane wyjściowe. Używa do tego standardowej metody.

Brud , 39 bajtów

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

Wypróbuj online! Niestety w większości przypadków testowych w wersji TIO zabrakło pamięci.

Wyjaśnienie

Nie ma tu nic nadzwyczajnego. _jest skrótem dla całego wzoru i v*jest taki sam jak *, ale z niższym priorytetem.

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

J, 48 bajtów

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

Podobnie jak inne, jest to również oparte na metodzie Arnaulda .

Stosowanie

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

Wyjaśnienie

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 bajtów

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

Jest to zasadniczo ten sam pomysł, co inne odpowiedzi, ale z pewną płytą kotłową Scala.

bez kradzieży pomysłów od innych (188 bajtów):

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 bajtów

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

Wypróbuj online!

Pętle len (a) razy, zastępując wszystkie wystąpienia pustych nawiasów trypletowych ( "(+)[:]{|}<->"<>3gdzie <>operator „grupy”, => ["(+)"; "[:]"; "{|}"; "<->"]) pustym łańcuchem ( x). Tak wiele iteracji to przesada, ale zawsze wystarczy, aby całkowicie zredukować wszystkie poprawnie utworzone nawiasy trójkątowe do zera. Po zakończeniu pętli wyprowadza !a: 0if ajest prawdą (nadal ma kilka znaków), 1jeśli ajest falsey (pusty).