Un "soporte de triplete" (que inventé para este desafío) es uno de los siguientes:

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

Una cadena de corchetes triples equilibrada (BTBS para abreviar) es una cadena vacía, dos BTBS concatenados o uno de los corchetes ...triples anteriores, cada uno reemplazado por un BTBS.

Su tarea es escribir un programa o función que verifique si una cadena que consta de solo (+)[:]{|}<->está equilibrada. El código más corto gana.

Ejemplos

Su programa debe devolver la verdad para las siguientes cadenas:

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

Su programa debe devolver falsedad para las siguientes cadenas:

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

Japt, 25 bytes

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

¡Pruébalo en línea!

een cadenas es una función de reemplazo recursivo. El segundo parámetro predeterminado es la cadena vacía, lo que significa que esto elimina recursivamente las coincidencias de la expresión regular de Japt "%(%+%)|%[:]|\{%|}|<->"(en términos regulares /\(\+\)|\[:]|{\|}|<->/). Esto devuelve una cadena vacía para cadenas de triplete balanceadas y una cadena no vacía para cadenas no balanceadas, por lo que el valor de retorno correcto es el NOT lógico de esto.

JavaScript (ES6), 77 58 57 56 bytes

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

Casos de prueba

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 no tiene un concepto de verdad / falsedad, así que estoy considerando una cadena vacía de verdad y una cadena no vacía de falsedad. Esto verifica si consideramos el condicional /^$/.

¡Gracias a @Neil por jugar golf en 1 byte!

Pruébalo en línea!

Python, 77 bytes

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

Utiliza la idea de reemplazo de Arnauld . Genera y evalúa una cadena larga como

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

para alternar entre la sustitución de todos los tipos de soporte. Luego, verifica si el resultado es la cadena vacía.

Mathematica, 55 bytes

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

Función anónima. Toma una cadena como entrada y devuelve Trueo Falsecomo salida. Utiliza el método estándar para hacer esto.

Grime , 39 bytes

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

Pruébalo en línea! Lamentablemente, la versión TIO se queda sin memoria en la mayoría de los casos de prueba.

Explicación

Nada muy lujoso aquí. _es una forma abreviada de todo el patrón, y v*es igual que *, pero con menor prioridad.

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&.>/'(+)';'[:]';'{|}';'<->';])^:_

Al igual que los demás, esto también se basa en el método de Arnauld .

Uso

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

Explicación

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)}

Esta es básicamente la misma idea que las otras respuestas, pero con un poco de escala scala.

sin robar ideas de otros (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

Pruébalo en línea!

Bucles len (a) veces, reemplazando todas las apariciones de corchetes triples vacíos ( "(+)[:]{|}<->"<>3, donde <>está el operador "grupo", => ["(+)"; "[:]"; "{|}"; "<->"]) con una cadena vacía ( x). Esta cantidad de iteraciones es exagerada, pero siempre será más que suficiente para reducir completamente todos los corchetes de triplete correctamente formados a nada. Una vez que se completa el ciclo, sale !a: 0si aes verdadero (todavía tiene algunos caracteres), 1si aes falso (vacío).