Um "suporte tripleto" (que eu compus para esse desafio) é um dos seguintes:

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

Uma sequência de colchetes triplos balanceados (BTBS para abreviar) é uma sequência vazia, dois BTBSes concatenados ou um dos colchetes tripletos acima, sendo que cada ...um deles é substituído por um BTBS.

Sua tarefa é escrever um programa ou função que verifique se uma sequência que consiste apenas (+)[:]{|}<->é equilibrada. O menor código vence.

Exemplos

Seu programa deve retornar verdadeiramente para as seguintes seqüências de caracteres:

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

Seu programa deve retornar falso para as seguintes seqüências de caracteres:

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

Japt, 25 bytes

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

Teste online!

eon strings é uma função de substituição recursiva. O segundo parâmetro é o padrão da string vazia, o que significa que isso remove recursivamente correspondências do regex Japt "%(%+%)|%[:]|\{%|}|<->"(em termos regulares /\(\+\)|\[:]|{\|}|<->/). Isso retorna uma cadeia vazia para cadeias triplas balanceadas e uma cadeia não vazia para não balanceadas, portanto, o valor de retorno correto é o NOT lógico disso.

JavaScript (ES6), 77 58 57 56 bytes

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

Casos de teste

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 não tem um conceito de verdade / falsidade, então estou considerando uma verdade de cadeia vazia e uma falsidade de cadeia não vazia. Isso verifica se considerarmos o condicional /^$/.

Obrigado a @ Nee por jogar fora um byte!

Experimente online!

Python, 77 bytes

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

Usa a ideia de substituição de Arnauld . Gera e avalia uma cadeia longa como

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

para alternar entre a substituição de todos os tipos de colchetes. Em seguida, verifica se o resultado é a sequência vazia.

Mathematica, 55 bytes

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

Função anônima. Toma uma string como entrada e retorna Trueou Falsecomo saída. Usa o método padrão para fazer isso.

Grime , 39 bytes

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

Experimente online! Infelizmente, a versão TIO fica sem memória na maioria dos casos de teste.

Explicação

Nada muito chique aqui. _é uma abreviação para todo o padrão e v*é o mesmo que *, mas com menor precedência.

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

Semelhante aos outros, isso também é baseado no método de Arnauld .

Uso

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

Explicação

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

Essa é basicamente a mesma idéia que as outras respostas, mas com algumas informações básicas da Scala.

sem roubar idéias de outras pessoas (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

Experimente online!

Loops len (a) vezes, substituindo todas as ocorrências de colchetes vazios de trigêmeos ( "(+)[:]{|}<->"<>3, onde <>é o operador "group", => ["(+)"; "[:]"; "{|}"; "<->"]) por string vazia ( x). Essas muitas iterações são um exagero, mas sempre será mais do que suficiente para reduzir completamente todos os colchetes tripletos adequadamente formados para nada. Após a conclusão do loop, gera !a: 0if aé verdade (ainda possui alguns caracteres), 1se aé falsey (vazio).