Se le dará una cadena (posiblemente vacía) que contiene corchetes ( [{()}]) y cualquier otro carácter ( A- Z, a- z, 0- 9, puntuación). Debe verificar si cumple con las siguientes reglas:

• Los caracteres sin corchetes se ignoran.
• Cada soporte abierto [{(tiene un soporte de cierre )}]. Entonces [](no está permitido.
• Los corchetes están anidados correctamente. [(])No se permite.
• Los corchetes no pueden contener corchetes dentro de ellos. Los corchetes simples no pueden contener corchetes ni corchetes dentro de ellos. Entonces [({})], [{[]}]y ({})no están permitidos. Los corchetes se pueden anidar con corchetes similares, por lo que [[{((()))}{{(())}}]()]{()}está permitido.

La salida es un único valor verdadero / falso según su elección.

El código más corto gana.

Casos de prueba

b[[a{(/)}(())+={{}-}],] -> Válido

([h][e][l][l][o]) -> Inválido

[///[{(\/(arg()))}1{{((-)-2)}}]()]{()} -> Válido

hi -> Válido

Retina , 84 bytes

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

Pruébalo en línea.

Esta es una extensión bastante directa (pero desarrollada) de la expresión regular de comprobación de paréntesis .NET .

Si bien esto es bastante posible con grupos de equilibrio, la recurrencia de Perl definitivamente tiene la ventaja aquí . Sin embargo, cualquiera de los dos enfoques se supera al abandonar la elegancia de una sola combinación de expresiones regulares en favor de reducir la entrada gradualmente a través de sustituciones repetidas, como lo hace la respuesta sed de Digital Trauma . Esto se puede implementar en 34 bytes en Retina, pero dudo en publicar el código yo mismo, ya que no se me ocurrió la idea.

Retina, 34

En primer lugar, crédito donde se debe:

• @ ן nɟuɐɯɹɐ ן oɯ quien publicó este enfoque por primera vez .
• @ MartinBüttner, quien sugirió esta respuesta exacta pero era demasiado buen deportista para no publicarla él mismo.

Independientemente (más tarde) se me ocurrió el mismo enfoque en sed , así que espero no pisar ningún dedo del pie ( grande o no) al publicar esto:

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

Así que ahora con una sudo apt-get install mono-completey git clone https://github.com/mbuettner/retina.gittengo una retina trabajando en mi Ubuntu VM. Aquí está la salida de prueba:

$ 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

Aquí estoy afirmando que, dado sedque realmente no tiene un concepto de verdad / falsey, entonces estoy definiendo la cadena vacía para que signifique la verdad y todas las demás cadenas para que signifiquen falsey.

Si eso no es aceptable, entonces podemos agregar un par de líneas, por lo tanto:

Sed, 66

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

Esto genera 0 para falso y 1 para verdadero.

CJam, 27 26 bytes

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

Esto imprime 1 (verdad) o 0 (falso). Pruébalo en línea! o verificar todos los casos de prueba.

Cómo funciona

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

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

Try it here (Firefox only).

No

Sin embargo, si uso características recientemente implementadas, puedo bajar a 28 caracteres / 47 bytes:

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

Japt , 42 37 bytes

Guarde 5 bytes con una función que no sabía que tenía mi propio idioma ... ¡Gracias por agregarlo, @Downgoat!

Japt realmente necesita un mejor soporte de RegExp ...

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

Pruébalo en línea!

Cómo funciona

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

Esta es la primera vez que intento jugar 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['(']);}

Legible:

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

Hay un desbordamiento del búfer, pero no parece afectar nada. Creo que esto se debe a la alineación.

Perl, 50 + 1 = 51 bytes

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

Requiere la -pbandera y las huellas 1de verdad y nada de resultados falsos. Estoy contando -pcomo uno, porque se puede combinar con -e:

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

El código es básicamente una simple coincidencia de expresiones regulares contra la entrada, utilizando la ingeniosa función de expresiones regulares recursivas de Perl.

Gracias a Dennis por ayudarme a probar esto y jugar al golf en Perl.

Python 3: 120 bytes

Sobre la base de la respuesta de @ Adnan , resultó ser más corto de usar:

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 bytes

Torpemente largo, gracias a Mego por guardar 6 bytes:

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)