대괄호 ( [{()}])와 다른 문자 ( A- Z, a- z, 0- 9, 문장 부호)를 포함하는 (비어있을 수있는) 문자열이 제공됩니다 . 다음 규칙을 준수하는지 확인해야합니다.

• 대괄호가 아닌 문자는 무시됩니다.
• 모든 열린 브래킷 [{(에는 닫는 브래킷이 )}]있습니다. 따라서 [](허용되지 않습니다.
• 브래킷은 올바르게 중첩되어 있습니다. [(])허용되지 않습니다.
• 중괄호 안에는 대괄호가 포함될 수 없습니다. 단순 괄호 안에는 중괄호 나 대괄호가 포함될 수 없습니다. 그래서 [({})], [{[]}]그리고 ({})허용되지 않습니다. 대괄호는 유사한 대괄호로 중첩 될 수 있으므로 [[{((()))}{{(())}}]()]{()}허용됩니다.

출력은 선택에 따라 하나의 진실 / 거짓 값입니다.

가장 짧은 코드가 승리합니다.

테스트 사례

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

([h][e][l][l][o]) -> 유효하지 않습니다

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

hi -> 유효

레티 나 , 84 바이트

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

온라인으로 사용해보십시오.

이것은 기본 괄호 확인 .NET 정규식 의 상당히 간단하지만 골프 확장 입니다 .

이것은 밸런싱 그룹에서 가능하지만 Perl의 재귀는 분명히 우위에 있습니다 . 그러나 Digital Trauma의 sed answer처럼 반복 된 대체를 통해 점차적으로 입력을 줄이려면 단일 정규식 일치의 우아함을 버려 두 접근 방식을 모두 극복하십시오 . 이것은 Retina에서 34 바이트로 구현 될 수 있지만 아이디어를 얻지 못했기 때문에 코드를 직접 게시하는 것이 주저합니다.

망막, 34

첫째, 신용이 필요한 신용 :

• 이 접근 방식 을 처음 게시 한 @ ן nɟuɐɯɹɐ ן oɯ .
• @ MartinBüttner 는이 정확한 답변 을 제안 했지만 직접 게시하지 않는 스포츠맨에게는 너무 좋았습니다.

나는 독립적으로 (나중에) sed에서 동일한 접근 방식을 생각해 냈 으므로이 글을 올리면 발가락에 큰 영향을 미치지 않기를 바랍니다 .

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

그래서 지금에 sudo apt-get install mono-complete와 git clone https://github.com/mbuettner/retina.git내 우분투 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진실 / 거짓의 개념이 실제로 없기 때문에 빈 끈을 진실을 의미하고 다른 모든 끈을 거짓을 의미한다고 정의하고 있습니다.

이것이 허용되지 않으면 몇 줄을 추가 할 수 있습니다.

Sed, 66

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

false는 0, true는 1을 출력합니다.

CJam, 27 26 바이트

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

1 (트러스트) 또는 0 (거짓)을 인쇄합니다 . 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오.

작동 원리

"(){}[]"                    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 바이트로 줄일 수 있습니다.

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

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

버퍼 오버플로가 있지만 아무것도 영향을 미치지 않는 것 같습니다. 이것은 정렬 때문이라고 생각합니다.

펄, 50 + 1 = 51 바이트

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

-p플래그가 필요하고 1진실을 위해 인쇄 하고 허위 결과를 위해 아무것도 인쇄 하지 않습니다. -p다음과 결합 할 수 있기 때문에 하나로 계산합니다 -e.

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

이 코드는 기본적으로 Perl의 멋진 재귀 정규 표현식 기능을 사용하여 입력에 대한 일반 정규 표현식입니다.

이것을 테스트하고 Perl 상용구를 골프화하는 데 도움을 준 Dennis에게 감사합니다.

파이썬 3 : 120 바이트

@Adnan의 답변을 바탕으로 다음과 같이 사용하는 것이 더 짧았습니다.

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 바이트

6 바이트를 절약 한 Mego 덕분에 어색하게 길었습니다.

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)