Vous recevrez une chaîne (éventuellement vide) contenant des crochets ( [{()}]) et tout autre caractère ( A- Z, a- z, 0- 9, ponctuation). Vous devez vérifier s'il respecte les règles suivantes:

• Les caractères non crochets sont ignorés.
• Chaque support ouvert [{(a un support de fermeture )}]. Ce [](n'est donc pas permis.
• Les supports sont imbriqués correctement. [(])n'est pas autorisé.
• Les accolades ne peuvent pas contenir de crochets. Les crochets simples ne peuvent contenir ni crochets ni crochets. Donc [({})], [{[]}]et ({})ne sont pas autorisés. Les crochets peuvent être imbriqués avec des crochets similaires, ce qui [[{((()))}{{(())}}]()]{()}est donc autorisé.

La sortie est une seule valeur vérité / falsey selon votre choix.

Le code le plus court gagne.

Cas de test

b[[a{(/)}(())+={{}-}],] -> Valide

([h][e][l][l][o]) -> invalide

[///[{(\/(arg()))}1{{((-)-2)}}]()]{()} -> Valide

hi -> Valide

Rétine , 84 octets

^([^][}{)(]|()\(|(?<-2>)\)|(?!\2)((){|(?<-4>)}|(?!\4)(()\[|(?<-6>)])))*$(?!\2|\4|\6)

Essayez-le en ligne.

Il s'agit d'une extension assez simple (mais jouée) de l'expression rationnelle .NET de vérification des parenthèses de base .

Bien que cela soit tout à fait possible avec des groupes d'équilibrage, la récursivité de Perl a définitivement l'avantage ici . Cependant, l'une ou l'autre approche est battue en abandonnant l'élégance d'un match regex unique en faveur de la réduction progressive de l'entrée via des substitutions répétées, comme le fait la réponse sed de Digital Trauma . Cela peut être implémenté en 34 octets dans la rétine, mais j'hésite à publier le code moi-même, car je n'ai pas eu l'idée.

Rétine, 34

Tout d'abord, le crédit lorsque le crédit est dû:

• @ ן nɟuɐɯɹɐ ן oɯ qui a publié cette approche en premier .
• @ MartinBüttner qui a suggéré cette réponse exacte mais qui était trop bon sportif pour ne pas l'afficher lui-même.

J'ai indépendamment (plus tard) proposé la même approche dans sed , donc j'espère que je ne marche sur aucun orteil ( gros ou autre) en publiant ceci:

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

Alors maintenant, avec un sudo apt-get install mono-completeet git clone https://github.com/mbuettner/retina.gitj'ai une rétine de travail sur ma machine virtuelle Ubuntu. Voici la sortie de test:

$ while read; do echo "Input: \"$REPLY\", Ouput: $( mono Retina.exe -s brbal.ret <<< "$REPLY" )" ; done < ../brbal.txt 
Input: "[[{((()))}{{(())}}]()]{()}", Ouput: 1
Input: "b[[a{(/)}(())+={{}-}],]", Ouput: 1
Input: "[///[{(/(arg()))}1{{((-)-2)}}]()]{()}", Ouput: 1
Input: "hi", Ouput: 1
Input: "", Ouput: 1
Input: "", Ouput: 1
Input: "([h][e][l][l][o])", Ouput: 0
Input: "[](", Ouput: 0
Input: "[(])", Ouput: 0
Input: "[({})]", Ouput: 0
Input: "[{[]}]", Ouput: 0
Input: "({})", Ouput: 0
$ 

Sed, 53

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc

Ici, je prétends que depuis sed prétends qu'étant n'y a pas vraiment de concept de vérité / falsey, je définis la chaîne vide comme signifiant vérité et toutes les autres chaînes comme signifiant falsey.

Si cela n'est pas acceptable, nous pouvons ajouter quelques lignes, ainsi:

Sed, 66

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc
/./c0
/^$/c1

Cela renvoie 0 pour faux et 1 pour vrai.

CJam, 27 26 octets

"(){}[]"q1$f&_,@2/e*{/s}/!

Cela imprime 1 (véridique) ou 0 (fausse). Essayez-le en ligne! ou vérifiez tous les cas de test.

Comment ça fonctionne

"(){}[]"                    Push that string.
        q                   Read all input and push it on the stack.
         1$                 Copy the bracket string.
           f&               Intersect each input character with the bracket string.
                            This pushes an array of singleton and empty strings.
             _,             Get the length of the array (L), i.e., the number of
                            characters in the original input.
               @            Rotate the bracket string on top of the stack.
                2/          Split it into ["()" "{}" "[]"].
                  e*        Repeat each character pair L times.
                    {  }/   For each character pair.
                     /      Split the string on the stack at occurrences of that
                            character pair. This dosn't work properly the first
                            time, since there's a string array on the stack.
                      s     Flatten the resulting array of strings.
                         !  Apply logical NOT.

𝔼𝕊𝕄𝕚𝕟, 43 caractères / 62 octets

!Մ(Մ(Մ(ïċ/⁅⬮[\]{}]⌿),`⬮`,⬯),`{}`,⬯),`[]`,⬯)

Try it here (Firefox only).

Nan.

Cependant, si j'utilise des fonctionnalités nouvellement implémentées, je peux descendre à 28 caractères / 47 octets:

!ïċ/⁅⬮[\]{}]⌿)ė`⬮”ė`{}”ė`[]”

Japt , 42 37 octets

Enregistré 5 octets avec une fonctionnalité que je ne savais pas que ma propre langue avait ... Merci de l'avoir ajouté, @Downgoat!

Japt a vraiment besoin d'un meilleur support RegExp ...

!Uo"()[\\]\{}" e"\\(\\)" e"\{}" e"\\[]

Essayez-le en ligne!

Comment ça fonctionne

               // Implicit: U = input string
Uo"()[\\]\{}"  // Remove all non-bracket.
e"\\(\\)"      // Recursively remove all pairs of simple brackets.
e"\{}"         // Recursively remove all pairs of curly brackets.
e"\\[]         // Recursively remove all pairs of square brackets.
!              // Return the Boolean NOT of the result.
               // (true for empty string, false for anything else)
               // Implicit: output last expression

C99, 226 208 207 octets

C'est la première fois que j'essaie de jouer au golf

#define S s[i]
t(s,i)char*s;{int a[]={['[']=0,['{']=0,['(']=0};for(i=0;S*!(S=='{'&a['(']|S=='['&(a['(']|a['{'])|S==']'&(a['(']|a['{'])|S=='}'&a['(']);i++)a[S]++,a[S-S/90-1]--;return !(a['[']+a['{']+a['(']);}

Lisible:

int t(char* s){
    int a[265]={['[']=0,['{']=0,['(']=0};
    for(int i=0;s[i]&&!((s[i]=='{'&a['(']>0)|(s[i]=='['&(a['(']>0|a['{']>0))|(s[i]==']'&(a['(']>0|a['{']>0))|(s[i]=='}'&a['(']>0));i++){
        a[s[i]]++;
        a[s[i]-(s[i]/90+1)]--;
    }
    return !(a['[']+a['{']+a['(']);
}

Il y a un débordement de tampon mais cela ne semble pas affecter quoi que ce soit - je pense que cela est dû à l'alignement.

Perl, 50 + 1 = 51 octets

$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/

Nécessite le -pdrapeau et les impressions 1pour des résultats véridiques et rien pour des résultats faux. Je compte -pcomme un, car il peut être combiné avec -e:

> perl -pe '$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/'

Le code est fondamentalement juste une correspondance regex ordinaire avec l'entrée, en utilisant la fonctionnalité de regex récursif astucieux de Perl.

Merci à Dennis de m'avoir aidé à tester cela et à jouer au passe-partout Perl.

Python 3: 120 octets

S'appuyant sur la réponse de @ Adnan , il s'est avéré plus court à utiliser:

import re
x=re.sub('[^[\](){}]','',input())  
for i in('()','{}','[]'):  
 while x.find(i)>=0:x=x.replace(i,'')  
print(x=='')

Python 3, 196 170 160 160 154 octets

Longtemps maladroit, merci à Mego pour avoir économisé 6 octets:

d=y=""
for C in input():
 for a in "[](){}":y+=C*(C==a)
 y=y.replace("()",d)
x=y
for r in y:x=x.replace("{}",d)
for s in y:x=x.replace("[]",d)
print(x==d)