Un "support triplet" (que j'ai compensé pour ce défi) est l'un des suivants:

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

Une chaîne de crochets triplet équilibrée (BTBS pour faire court) est soit une chaîne vide, deux BTBS concaténés, soit l'un des crochets de triplet ci-dessus, chacun étant ...remplacé par un BTBS.

Votre tâche consiste à écrire un programme ou une fonction qui vérifie si une chaîne composée uniquement (+)[:]{|}<->est équilibrée. Le code le plus court gagne.

Exemples

Votre programme doit retourner véridique pour les chaînes suivantes:

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

Votre programme doit renvoyer la falsification pour les chaînes suivantes:

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

Japt, 25 octets

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

Testez-le en ligne!

eon strings est une fonction de remplacement récursif. Le deuxième paramètre par défaut est la chaîne vide, ce qui signifie que cela supprime récursivement les correspondances de l'expression "%(%+%)|%[:]|\{%|}|<->"régulière Japt (en termes réguliers, /\(\+\)|\[:]|{\|}|<->/). Cela renvoie une chaîne vide pour les chaînes triplet équilibrées et une chaîne non vide pour les chaînes non équilibrées, donc la valeur de retour correcte est le NON logique de cela.

JavaScript (ES6), 77 58 57 56 octets

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

Cas de test

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 octets

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

sed n'a pas de concept de vérité / fausse, donc je considère une chaîne vide véridique et une fausse chaîne non vide. Cela vérifie si nous considérons le conditionnel /^$/.

Merci à @Neil d'avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Python, 77 octets

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

Utilise l'idée de remplacement d'Arnauld . Génère et évalue une longue chaîne comme

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

pour basculer entre le remplacement de tous les types de supports. Ensuite, vérifie si le résultat est la chaîne vide.

Mathematica, 55 octets

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

Fonction anonyme. Prend une chaîne en entrée et retourne Trueou Falseen sortie. Utilise la méthode standard pour ce faire.

Grime , 39 octets

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

Essayez-le en ligne! Malheureusement, la version TIO manque de mémoire sur la plupart des cas de test.

Explication

Rien d'extraordinaire ici. _est un raccourci pour l'ensemble du modèle et v*est identique à *, mais avec une priorité inférieure.

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

J, 48 octets

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

Semblable aux autres, cela est également basé sur la méthode d'Arnauld .

Usage

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

Explication

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 octets

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

C'est fondamentalement la même idée que les autres réponses, mais avec un passe-partout scala.

sans voler les idées des autres (188 octets):

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 octets

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

Essayez-le en ligne!

Boucle len (a) fois, remplaçant toutes les occurrences de crochets de triplets vides ( "(+)[:]{|}<->"<>3, où <>est l'opérateur "groupe", => ["(+)"; "[:]"; "{|}"; "<->"]) par une chaîne vide ( x). Ce nombre d'itérations est exagéré, mais ce sera toujours plus que suffisant pour réduire complètement à néant tous les supports de triplets correctement formés. Une fois la boucle terminée, affiche !a: 0si aest véridique (a encore quelques caractères), 1si aest falsey (vide).