Ti verrà data una stringa (possibilmente vuota) contenente parentesi ( [{()}]) e qualsiasi altro carattere ( A- Z, a- z, 0- 9, punteggiatura). È necessario verificare se aderisce alle seguenti regole:

• I caratteri non tra parentesi vengono ignorati.
• Ogni staffa aperta [{(ha una staffa di chiusura )}]. Quindi [](non è permesso.
• Le parentesi sono nidificate correttamente. [(])non è permesso.
• Le parentesi graffe non possono contenere parentesi quadre al loro interno. Le parentesi semplici non possono contenere parentesi graffe o quadrate al loro interno. Quindi [({})], [{[]}]e ({})non sono ammessi. Le parentesi possono essere nidificate con parentesi simili, quindi [[{((()))}{{(())}}]()]{()}è consentito.

L'output è un singolo valore di verità / falsità secondo la vostra scelta.

Il codice più corto vince.

Casi test

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

([h][e][l][l][o]) -> Non valido

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

hi -> Valido

Retina , 84 byte

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

Provalo online.

Questa è un'estensione abbastanza semplice (ma giocata a golf) della regex .NET di controllo parentesi di base .

Sebbene ciò sia del tutto possibile con i gruppi di bilanciamento, la ricorsione di Perl ha sicuramente il vantaggio qui . Tuttavia, entrambi gli approcci vengono battuti abbandonando l'eleganza di una singola partita regex a favore della riduzione graduale dell'input tramite ripetute sostituzioni, come fa la risposta sed di Digital Trauma . Questo può essere implementato in 34 byte a Retina, ma sono restio a pubblicare il codice da solo, poiché non mi è venuta l'idea.

Retina, 34

In primo luogo, il credito in cui è dovuto il credito:

• @ ן nɟuɐɯɹɐ ן oɯ che per primo ha pubblicato questo approccio .
• @ MartinBüttner che ha suggerito questa risposta esatta ma era troppo bravo da sportivo a non pubblicarla da solo.

Indipendentemente (più tardi) ho trovato lo stesso approccio in sed , quindi spero di non camminare su alcun piede ( grande o altro) pubblicando questo:

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

Quindi ora con a sudo apt-get install mono-completee git clone https://github.com/mbuettner/retina.githo una retina funzionante sulla mia macchina virtuale Ubuntu. Ecco l'output del 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

Qui sto affermando che poiché sednon ha davvero un concetto di verità / falsità, allora sto definendo la stringa vuota per significare la verità e tutte le altre stringhe per significare la falsità.

Se ciò non è accettabile, possiamo aggiungere un paio di righe, quindi:

Sed, 66

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

Questo produce 0 per falso e 1 per vero.

CJam, 27 26 byte

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

Questo stampa 1 (verità) o 0 (falsa). Provalo online! o verifica tutti i casi di test.

Come funziona

"(){}[]"                    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 caratteri / 62 byte

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

Try it here (Firefox only).

No.

Tuttavia, se utilizzo le funzionalità appena implementate, posso ottenere fino a 28 caratteri / 47 byte:

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

Japt , 42 37 byte

Ho salvato 5 byte con una funzione che non avevo realizzato che la mia lingua avesse ... Grazie per averla aggiunta, @Downgoat!

Japt ha davvero bisogno di un miglior supporto RegExp ...

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

Provalo online!

Come funziona

               // 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 byte

Questa è la prima volta che provo a giocare a 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['(']);}

Leggibile:

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['(']);
}

C'è un buffer overflow ma non sembra influenzare nulla - credo che ciò sia dovuto all'allineamento.

Perl, 50 + 1 = 51 byte

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

Richiede la -pbandiera e le stampe 1per la verità e niente per i risultati falsi. Sto contando -pcome uno, perché può essere combinato con -e:

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

Il codice è fondamentalmente solo una semplice corrispondenza regex rispetto all'input, utilizzando la caratteristica regex ricorsiva elegante di Perl.

Grazie a Dennis per avermi aiutato a testare questo e giocare a golf con la piastra Perl.

Python 3: 120 byte

Sulla base della risposta di @Adnan , si è dimostrato più breve da usare:

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 154 byte

Stranamente lungo, grazie a Mego per il salvataggio di 6 byte:

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)