Вам буде наданий (можливо, порожній) рядок, що містить дужки ( [{()}]) та будь-які інші символи ( A- Z, a- z, 0- 9, пунктуація). Вам потрібно перевірити, чи він дотримується таких правил:

• Персонажі без дужок ігноруються.
• Кожна відкрита дужка [{(має дужку , що закривається )}]. Так [](не дозволено.
• Дужки належним чином вкладені. [(])не дозволено.
• Фігурні дужки не можуть містити в них квадратні дужки. Прості дужки не можуть містити в собі ні фігурні, ні квадратні дужки. Отже [({})], [{[]}]і ({})не допускаються. Дужки можуть бути вкладені в подібні дужки, тому [[{((()))}{{(())}}]()]{()}це дозволено.

Вихід - це одне значення truthy / falsey за вашим вибором.

Найкоротший код виграє.

Тестові кейси

b[[a{(/)}(())+={{}-}],] -> Дійсно

([h][e][l][l][o]) -> Недійсний

[///[{(\/(arg()))}1{{((-)-2)}}]()]{()} -> Дійсно

hi -> Дійсно

Сітківка , 84 байти

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

Спробуйте в Інтернеті.

Це досить прямого (але гольф) розширення базових. NET-регексів .

Незважаючи на те, що це цілком можливо для балансуючих груп, рекурсія Перла тут безумовно має перевагу . Однак будь-який підхід долається, вибиваючи елегантність одного матчу регулярних виразів на користь зменшення введення поступово за допомогою повторних підстановок, як це робить відповідь Digital Trauma . Це може бути реалізовано в 34 байтах у Retina, але я не вагаюся, коли я сам розміщувати код, оскільки я не придумав ідеї.

Сітківка, 34

По-перше, кредит, у якому належить отримати кредит:

• @ ן nɟuɐɯɹɐ ן oɯ хто вперше опублікував такий підхід .
• @ MartinBüttner, який запропонував цю точну відповідь, але був занадто гарний спортсмен, щоб не публікувати його сам.

Я самостійно (пізніше) придумав такий же підхід у sed , тому сподіваюся, що я не ступаю ні на які пальці ( великі чи інакше), публікуючи це:

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

Тож тепер з a sudo apt-get install mono-completeі у git clone https://github.com/mbuettner/retina.gitмене працює сітківка на моєму Ubuntu VM. Ось тестовий вихід:

$ 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
$ 

Сід, 53

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

Тут я стверджую, що оскільки sedнасправді не існує поняття truthy / falsey, то я визначаю порожню рядок, щоб означати truthy, а всі інші рядки означати falsey.

Якщо це не прийнятно, ми можемо додати пару рядків, таким чином:

Сід, 66

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

Це виводить 0 для хибних та 1 для істинних.

CJam, 27 26 байт

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

Це друкує 1 (truthy) або 0 (false). Спробуйте в Інтернеті! або перевірити всі тестові випадки.

Як це працює

"(){}[]"                    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 символи / 62 байти

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

Try it here (Firefox only).

Ні.

Однак якщо я використовую щойно реалізовані функції, я можу скоротитись до 28 символів / 47 байт:

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

Japt , 42 37 байт

Збережено 5 байт з функцією, яку я не зрозумів, що моя власна мова мала ... Дякую, що додали її, @Downgoat!

Japt дійсно потребує кращої підтримки RegExp ...

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

Спробуйте в Інтернеті!

Як це працює

               // 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 байт

Це мій перший раз, коли я щось намагаюся займатися гольфом

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

Читає:

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

Існує переповнення буфера, але, здається, це ніяк не впливає - я вважаю, що це пов'язано з вирівнюванням.

Perl, 50 + 1 = 51 байт

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

Потрібен -pпрапор і відбитки 1для трибуни і нічого для хибних результатів. Я рахую -pяк один, тому що його можна поєднувати з -e:

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

Код - це лише звичайний збіг регулярних виразів проти введення, використовуючи чудову рекурсивну функцію регексу Perl.

Дякую Деннісу за те, що він допоміг мені перевірити це і переграти котельну плиту Perl.

Пітон 3: 120 байт

Спираючись на відповідь @ Аднана , його виявилося коротшим:

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

Пітон 3, 196 170 160 154 байт

Неприємно довго, завдяки Mego за збереження 6 байт:

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)