대괄호 문자열을 사용하고 해당 문자열이 완전히 일치하는지 여부를 출력하는 프로그램 또는 함수를 작성해야합니다. 당신의 프로그램은 진실 또는 허위 가치를 인쇄해야 하며 IO는 어떤 합리적인 형식 일 수 있습니다 .

규칙 및 정의 :

• 이 과제의 목적 상 "브래킷"은 다음 문자 중 하나 ()[]{}<>입니다.

• 여는 괄호와 닫는 괄호가 올바른 순서이고 괄호 안에 문자가없는 경우 괄호 쌍은 "일치하는"것으로 간주됩니다.

  ()
  []{}
  

  또는 내부의 모든 하위 요소도 일치하는 경우

  [()()()()]
  {<[]>}
  (()())
  

  하위 요소는 여러 층으로 중첩 될 수도 있습니다.

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• 다음과 같은 경우에만 문자열이 "완전 일치"로 간주됩니다.

  1. 모든 단일 문자는 대괄호입니다.

  2. 각 브래킷 쌍에는 올바른 개폐 브래킷이 올바른 순서로 있으며

  3. 각 브래킷이 일치합니다.

• 입력에 인쇄 가능한 ASCII 만 포함되어 있다고 가정 할 수 있습니다 .

IO 테스트

다음은 정확한 값을 반환해야하는 입력 내용입니다.

()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]

그리고 다음은 잘못된 값을 반환해야하는 출력입니다.

(               Has no closing ')'
}{              Wrong order
(<)>            Each pair contains only half of a matched element
(()()foobar)    Contains invalid characters
[({}<>)>        The last bracket should be ']' instead of '>'
(((()))         Has 4 opening brackets, but only 3 closing brackets.

평소와 같이 이것은 코드 골프이므로 표준 허점이 적용되어 바이트 단위의 최단 답변이 이깁니다.

05AB1E , 19 바이트

입력은 인용 부호 로 제공됩니다 . 암호:

"[](){}<>"2÷)"":g2Q

쓰레기, 많은 버그 및 구현되지 않은 기능이 발견되었습니다. 설명:

"[](){}<>"           # Push this string
          2÷         # Split into pieces of two
            )        # Wrap it into an array (which should not be needed)
             ""      # Push an empty string
               :     # Infinite replacement

이것은 실제로 까다로운 부분입니다. 의사 코드에서 보이는 모양은 다음과 같습니다.

input().replace(['[]', '()', '{}', '<>'], "")

이 부분은 05AB1E 코드 에서 다룹니다 .

if type(b) is list:
    temp_string = temp_string_2 = str(a)
    while True:
        for R in b:
            temp_string = temp_string.replace(R, c)
        if temp_string == temp_string_2:
            break
        else:
            temp_string_2 = temp_string
    stack.append(temp_string)

보시다시피, 이것은 무한 대체입니다 (문자열이 더 이상 변경되지 않을 때까지 완료). 따라서 대체 기능이 이미 내장되어 있기 때문에 대체를 루프로 설정하는 것에 대해 걱정할 필요가 없습니다. 그 후 :

                g    # Take the length of the final string
                 2Q  # Check if equal with 2 (which are the quotes at the end)

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! (위 버전은 더 이상 사용되지 않으므로 약간 수정되었습니다).

Brain-Flak , 1101, 1085 , 981 바이트

{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}

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

이것은 980 바이트의 소스 코드이며 ASCII 입력을 허용 +1하는 -a플래그 (그러나 10 진수 출력)입니다.

이것은 내가 아주 오랫동안 쓰고 싶었던 답변 입니다. 6 개월 이상 나는이 도전에 대답하는 것이 뇌에서 매우 어렵다는 것을 알았 기 때문에 이것을 게시하기를 기다렸다. 그러나 매우 중요한 이유 중 하나는 그만한 가치가 있습니다. 소스 코드 자체는 진실한 입력이며이 언어 자체의 핵심입니다.

그리고 제가 여기에 글을 썼을 때 ,이 질문은 제가 뇌파를 쓰는 데 영감을 준 것이 었습니다.

괄호가 완전히 일치합니까?를 쓴 직후에, 일치하는 괄호만으로 얼마나 많은 정보를 저장할 수 있는지 궁금해졌습니다. 나에게 눈에 띄는 한 가지는 네 가지 "원자"종류 만 있지만

(){}[]<>

이러한 각 브래킷 유형은 비어 있거나 기본적으로 다른 정보 조각 인 다른 브래킷이있을 수 있으므로 실제로 전달할 정보는 8 개입니다. 따라서 일치하는 대괄호 만 허용하고 빈 대괄호 안에 다른 대괄호가있는 대괄호와 다른 것을 전달하는 언어를 작성하기로 결정했습니다.

이 답변을 작성하는 데 약 2 시간이 걸렸습니다. 나는 대부분의 코드가 각 브래킷 유형에 대해 반복되기 때문에 골프가 잘 안된다는 것을 인정할 것입니다. 그러나 나는 특히 Brain-Flak이 다음과 같은 점을 감안할 때 전혀 답을 쓸 수 있다는 것에 놀랐습니다.

사용하기 힘들도록 설계된 미니멀 한 esolang

나중에 골프를 타려고하지만 어쨌든 이것을 꺼내고 싶었습니다.

자세한 설명이 있지만 길이는 약 6 천 자이므로 전체를이 답변에 붙여 넣는 것이 현명하지 않다고 생각합니다. 원한다면 여기를 통해 읽을 수 있습니다 . 여기에 간단한 설명을 추가하겠습니다.

기본 아이디어는 스택의 모든 문자에 대해 다음 단계를 반복한다는 것입니다.

• 각 문자가 대괄호와 일치하는지 확인합니다. 여는 브래킷 인 경우 다음 매핑에 따라 숫자를 다른 스택으로 푸시합니다.

  ( = 1
  < = 2
  [ = 3
  { = 4
  

• 그런 다음 닫는 괄호와 일치하는지 확인합니다. 그렇다면 대괄호를 여는 것과 같이 등가 번호를 대체 스택에 푸시합니다. 그런 다음 상위 두 숫자가 같은지 확인합니다. 만약 그렇다면 둘 다 팝업되고 프로그램은 정상적으로 계속됩니다. 그렇지 않은 경우 두 스택을 모두 지우고 (루핑을 중지하기 위해) 스택을 다른 스택으로 밉니다. 이것은 본질적으로 "중단"진술입니다.

• 8 개의 브라켓 유형을 확인한 후 루프를 통해이 런 값을 푸시합니다. 우리는 대부분을 제로로 만들었으므로 값이있는 유일한 스 니펫은 대괄호와 비교할 때 조건부입니다. 따라서 대괄호가 일치하면 전체 루프의 값은 1입니다. 둘 중 하나도 없으면 전체 루프의 값이 0입니다.이 경우 두 스택을 지우고 대체 스택으로 0을 푸시합니다. 다시, 이것은 "break"문장과 같습니다.

이 메인 루프가 실행 된 후 나머지는 상당히 간단합니다. 우리는 (빈) 메인 스택에 있고 대체 스택은 비어 있거나 (괄호가 일치하는 경우) 비어 있지 않은 경우 비어 있지 않습니다. 그래서 우리는 이것을 실행합니다 :

#Toggle to the alternate stack
<>

#Push this stack-height onto main-stack
([]<>)

#Logical not
({}<(())>){((<{}{}>))}{}

이렇게하면 0 또는 1이 주 스택으로 밀리고 프로그램이 끝나면 암시 적으로 인쇄됩니다.

• 훌륭한 스택 클린 "같음"및 "논리적 아님"스 니펫을 제공하고 유용한 예제로 github 위키 를 정기적으로 업데이트 해 주신 @WheatWizard 에게 감사드립니다 .

• 이 프로그램을 작성하는 데 큰 도움이 된 온라인 정수 metagolfer 를 작성해 주신 @ASCII 전용 감사합니다

개정

• 일부 푸시 팝 중복 제거

• 제로 카운터 로직을 변경했습니다

Brain-Flak , 204 196 190 바이트

{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})

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

Wheat Wizard 덕분에 -8 바이트 Jo King 덕분에 -6 바이트

설명

이 프로그램은 현재 닫히지 않은 모든 괄호의 문자 코드를 두 번째 스택에 저장합니다. 괄호 쌍 <>, []및 {}각각은 정확히 2만큼 다른 문자 코드를 가지므로 구체적으로 확인할 필요가 없습니다. 쌍 ()은 1 만 다르므로 (계속하기 전에 해당 바이트 를 구체적으로 확인 하고 효과적으로 해당 바이트를 줄입니다 (실제로 다른 바이트마다 증가).

# While there are bytes left to process
{

 # Move byte to second stack
 ({}<>)<>

 # Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
 ((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())

 ((

   # For each opening bracket type:
   {

    # Evaluate as zero
    <

     # Compute difference between bracket type and input byte
     ({}<>[({})])

    >

    # Evaluate loop iteration as -1 if equal, 0 otherwise
    [()]{()(<{}>)}{}<>

   }

   # Remove the 0 that was inserted to terminate that loop
   {}

   # Add 1 to result
   ()

   # Evaluate rest of this expression as zero
   <

    # Determine whether the byte is open parenthesis
    ({}<>[({})])

    # If not:
    {

     # Add 1 to byte and break if
     (<{}({}())>)

    }{}

    # Return to main stack
    <>

   >

 # Push result twice (0 if matched an opening bracket, 1 otherwise)
 ))

 # If byte was not an opening bracket:
 {

  # Push zero to break out of if
  (<

    # Push (open bracket + 2 - byte) below that zero
    ({}{}<>[{}]{}<>)

  >)

 }{}

 # If byte was neither an opening bracket nor the appropriate closing bracket:
 {

  # Clear alternate stack and stay there to break out of main loop early
  <>{{}}

 }{}

# End of main loop
}

# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket.  If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.

# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})

자바 스크립트 (ES6), 52 50 바이트

f=s=>(t=s.replace(/\(\)|\[]|{}|<>/,''))==s?!s:f(t)

결과가 원본과 동일 할 때까지 대괄호를 반복해서 제거한 다음 문자열이 비어 있지 않으면 false를 반환합니다.

편집 : @ edc65 덕분에 2 바이트가 절약되었습니다.

레티 나, 20 바이트

+`\(\)|\[]|{}|<>

^$

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

CJam, 25 24 23 21 바이트

2 바이트를 절약 한 Sp3000에 감사합니다.
2 바이트를 절약 한 jimmy23013에게 감사합니다.

q_,{()<>}a`$2/*{/s}/!

테스트 스위트.

본질적으로 다른 답변과 같은 작품 : 우리가 반복적으로 제거 (), [], <>및 {}문자열에서 우리는 빈 문자열로 끝날 경우 확인하십시오. 우리가 끝났을 때 확인하지 않으려면 문자열의 길이가 N어디 N인지 항상 쌍으로 제거하십시오 . 이것이 Retina를 이길 수 없다는 것을 알게되어 기쁩니다. :) (Pyth 또는 Jelly가 ...)

여기에 재미있는 골프 트릭이 있습니다. 문자열을 얻으려면 ()<>[]{}다음을 사용하십시오.

{()<>}a`$

는 {()<>}단지 코드와 다른 브래킷을 포함하는 블록 (즉, 함수)이다. 함께 a우리 배열 된 블록을 포장. `stringifies 준다 어레이 "[{()<>}]". 마지막으로 문자열을 $로 정렬하면 대괄호가로 재정렬됩니다 ()<>[]{}.

파이썬, 67 바이트

lambda s:eval("s"+".replace('%s','')"*4%([],(),{},'<>')*len(s))==''

다음과 같은 표현식을 생성하고 회피합니다

s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')

결과가 비어 있는지 확인합니다.

Sp3000 [],(),{}은 파이썬 객체이기 때문에 따옴표없이 서브 베드 가 될 수 있고 두 개의 parens가 필요하지 않음 을 지적하여 8 바이트를 절약했습니다 .

Yacc, 119 바이트

정규식 / 대체를 사용하지 않습니다.

%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}

언 골프

%%                              # Grammar in BNF
input:
  r;
r:
  %empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%%                              # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}

편집

yacc -o bracket.c bracket.y
cc -o bracket bracket.c

용법

~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 %                                                                         :(

Pyth, 31 25 24 바이트

FryAmTheEggMan 덕분에 25 바이트로 줄어든 1 바이트 제거

VQ=:Q"<>|\[]|{}|\(\)"k;!

여기 사용해보십시오 : 테스트 스위트 !

나는 여전히 Pyth 초보자이며 도움을 주시면 감사하겠습니다.

설명

VQ                         For N in range(0, len(z)), with Q being the evaluated input.
                           Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
  =:Q"<>|\[]|{}|\(\)"k     assign Q without {}, [], <> nor () (regex replacement) to Q
                      ;    End of For loop
                       !   Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
                           This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise

BTW, 다른 Pyth 답변 (현재 20 바이트)을 축하합니다.

Pyth, 20 바이트

!uuscNTc"[](){}<>"2G

온라인으로 사용해보십시오 : Test Suite

반복의 발생을 제거 [], (), <>및 {}분할 및 재 병합에 의해. 결과 문자열이 비어 있는지 확인합니다.

자바 스크립트 ES6, 54 바이트

f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_

재귀 교체 구현을 사용합니다. 충분히 간단합니다.

정규식 (PCRE 플레이버), 41 37 바이트

^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$

재귀 정규 표현식이있는 표준 솔루션입니다.

4 바이트를 제거해 주셔서 감사합니다 jimmy23013

펄, 34 33 바이트

에 +2 포함 -lp

STDIN의 입력으로 실행 :

./brackets.pl <<< "{<>()}"

brackets.pl:

#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_

첫 번째 대괄호 쌍을 찾고 그 사이에 아무 것도없는 한 쌍을 찾습니다. 그런 다음 최종 문자열이 비어 있는지 확인합니다.

Brain-Flak , 204 바이트

(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})

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

Nitroden의 답변 만큼 짧지는 않지만 매우 다른 접근법을 사용합니다. 이것은 입력을 반복적으로 실행하여 남아있을 때까지 매번 일치하는 대괄호 쌍을 제거합니다. 이 시점에서 스택에 남아있는 것이 있으면 문자열이 완전히 일치하지 않습니다.

설명:

(())  Push 1 to simulate the check at the start of the loop
{  While check
	{}           Pop check
	{({}<>)<>}<> Reverse input
	({           Loop over input
		< Don't push the values of these calculations
		(<(({})<>)>)  Create a copy of the top of the input and push to the other stack
		(((((
		((([(())()()()]){}){}){}())
		(()))
		(((())()){}()){})
		){})          Push the differences in values of the end brackets 
		(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))  If the copy is the same as any of these, push the difference between the other bracket twice
		<>{}<>  Pop copy
		{  If this character is a start bracket
			{}({}[({})]<>({}))  Check if the next character is the end bracket
			{(<>)(<>)}{}          If not, push a 0 to each stack as buffer
			{}       Pop the top of the input stack, either the start bracket if they matched or the buffer 0
			(<>)     Push 0 to other stack to end check
		}{}>
		{}   Pop the top of the other stack
		         If the character was not an end bracket, pop the copy of check, which is 0
		         If it was, but didn't match the next character, pop the buffer 0
		         If the brackets matched, pop the end bracket and add it to the loop total
	<>}	Repeat with the rest of the input
	<>)	Push the loop total
		If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1

Brainfuck, 132 바이트

+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.

형식화 :

+>,
[
  [<-> >+>[-]<<-]
  <
  [
    not matching closing bracket
    >+>[<+<+>> >+<-]
    +++++[>--------<-]
    >
    [
      not open paren
      <<+>
      ++++[>-----<-]>
      [
        not open angle bracket
        <+++++[>------<-]>-
        [
          not open square bracket
          <++++[>--------<-]>
          [
            not open brace
            ,>
          ]
        ]
      ]
    ]
    <
  ]
  ,
]
<<[>]
>.

후행 줄 바꿈없이 입력을 예상합니다. \x00거짓과 \x01참으로 인쇄 합니다.

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

접근 :로 시작하여 스택을 유지하고 \x01여는 브래킷이 생길 때마다 해당하는 닫는 브래킷을 밉니다. 현재 문자가 여는 괄호인지 확인하기 전에 먼저 스택 맨 위에있는 닫는 괄호와 같은지 확인한 다음 팝업하십시오. 올바른 닫는 괄호 나 여는 괄호가 아닌 경우 포인터를 오른쪽으로 움직이면서 나머지 입력을 사용하십시오. 마지막으로 포인터가 이니셜 옆에 있는지 확인하십시오 \x01.

Grime v0.1, 34 바이트

M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M

1일치하고 0일치하지 않는 인쇄 합니다 . 온라인으로 사용해보십시오!

설명

Grime 은이 과제를 위해 고안된 2D 패턴 일치 언어입니다 . 1D 문자열을 일치시키는 데 사용할 수도 있습니다. 이것이 나의 첫 번째 대답입니다. 나는 오늘 Grime을 수정했지만 하나의 구문 요소 ( `대신 ,) 의 문자 만 변경하기 때문에 점수에 영향을 미치지 않습니다.

M=                         Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\>      a smaller M inside matched brackets,
|MM                          or two smaller Ms concatenated,
|_                           or the empty pattern.
e`M                        Match the entire input against M.

Reng v.3.3, 137 바이트, 비경쟁

여기 사용해보십시오!

aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2<       <       <     +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
   \$2+)1z+#z/   ~n1/

골프를 조금 더해야하지만 적어도 작동합니다. ð원격으로 가능하고 쉽게하기 위해이 도전 후에 스택을 추적 하는 명령 을 추가 했습니다. 나는 이것을 조금 설명하지만 일반적으로 반복되는 모든 문자열을 추적하고 반복을 찾습니다. 반복이 있으면 문자열을 되돌릴 수 없습니다. 그렇지 않으면 문자열이 빈 문자열 / 스택으로 축소되어 출력 1됩니다. 그렇지 않으면 출력이 생성되지 않습니다.

PowerShell v2 +, 63 62 바이트

param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a

JavaScript를 잡을 수는 없지만 현재 다른 비 언어 언어를 사용하고 있습니다.

다른 답변으로 비슷한 접근 방식 : 그래서 우리가 하나 제거 할 수 있습니다로 계속 간단한 루프 [], ()또는 <>(우리는 정규식 스페셜을 탈출해야하기 때문에 여러 가지 필요없는 문자를). 우리는 $b이전 루프의 $a설정 을 기억하기 위해 도우미 로 사용합니다. 초기화되지 않은 변수는 $null이므로 루프가 처음 발생했을 때와 $a같지 않습니다 $null.

루프가 끝날 때 $a비어 있거나 비어 있지 않으며 해당 문자열의 부울 비는 True또는 False입니다.

예

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False

C, 121 (122) 114 바이트

@xsot 덕분에 8 바이트가 줄었습니다!

a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}

스택을 사용합니다.

자바 7 156 151 바이트

class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}

나는 이것이 어떤 상을 수상 할 것으로 기대하지는 않지만 아직 Java 답변을 보지 못했습니다. 또한, 나는 PPCG 주위에 숨어 있고 다른 답변에 투표 / 댓글을 작성하는 것을 좋아합니다.

입력은 프로그램 매개 변수로 제공됩니다. 이것은 루프에서 정규식 대체를 수행한다는 점에서 다른 답변과 동일한 형식을 따릅니다. 원래 N은 원래 문자열의 길이이지만 N Integer.MAX_VALUE은 더 짧습니다 :]. Java Integer.MAX_VALUE의 최대 길이 String이므로 입력 길이가 Java에서 처리 할 수 ​​있다는 암시 적 가정이 있기 때문에 괜찮습니다 . 루프 때문에 런타임이 꽤 나쁩니다 (내 랩탑에서 약 20 분이 걸렸습니다).하지만 그것에 대한 제한은 보지 못했습니다.

하스켈 , 151 바이트

infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0

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

파이썬 2.7, 96 바이트

def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])

파이썬 2, 80 바이트

def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s

줄리아, 51 바이트

~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n

몇 가지 옵션 중에서 가장 미쳤다. 놀랍게도 정규 표현식의 힘을 활용하는 것이 문자열 일치의 최단 경로이지만 일치하는 패턴이 규칙적인 경우에만 적용됩니다. PCRE 재귀 패턴을 시도하면 전체 문자열이 일치하는지 확인하거나 끝을 고정한 다음 정규식 재귀에 대한 내부 본문을 지정하는 구문을 만들어 코드 크기를 크게 만듭니다. 둘 중 어느 것도 골프를 코딩하는 데 도움이되지 않습니다.

설명:

~z=                            # Define ~z to be the following:
    z==(                       # If z is equal to                                     
        n=replace(z,           # z with the replacement of 
            r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
            ""                 # with empty strings
        )                      # (which is assigned to n)
    )?z==""                    # whether z is an empty string
    :~n                        # else ~ applied to the substituted string

이 함수는 유일한 인수에서 인접한 괄호 쌍을 반복적으로 제거하고이 방법으로 빈 문자열을 파생시킬 수 있으면 true를 리턴합니다.

sed, 39 36 바이트 (코드는 34, -r은 2)

:a
s/\(\)|\[]|<>|\{}//;ta
/./c0
c1

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

표준 접근법으로 보이는 것의 sed 버전. 확장 정규식이 필요합니다 ( sed -r)

Cows quack 덕분에 3 바이트 절약

05AB1E, 9 바이트

žu2ôõ:g2Q

입력은 따옴표로 제공됩니다.

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

설명:

žu          # Push "()<>[]{}"
  2ô        # Split into pieces of size 2
    õ       # Push empty string
            # Implicit input
      :     # Infinite replacement
       g2Q  # Is length equal to 2?
            # Implicit print

클로저, 153 바이트

C와 Brainfuck보다 긴 답변 : o

(defn f[[s & r]](if s(let[[a b](split-at(.indexOf(reductions + 1(for[c r](get(zipmap[s({\(\)\[\]\{\}\<\>}s)][1 -1])c 0)))0)r)](and(not=()a)(f(butlast a))(f b))))1)

정규 표현식을 사용하지 않고 첫 번째 문자를 사용하여 닫는 태그가 무엇인지 확인하고 해당 대괄호가 균형을 이루는 첫 번째 인덱스를 찾습니다 (누적 합계는 0 임). 그런 다음 대괄호 안에 있고 대괄호 안에 무엇이 유효한지 반복적으로 확인합니다.

더 나은 접근 방식이 있는지 확인해야합니다 ...

루아 , 295 바이트

f = false g = string.gsub t=table s={}b=io.read()for c in b:gmatch('.')do if c:find("[%[<{%(]")then s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")")elseif c:find("[%]>}%)]")then if t.remove(s)~=c then print(f)return end else print(f)return end end if#s>0 then print(f)else print(1)end

언 골프 버전

f = false
g = string.gsub
t=table
s={} --Define a stack of opening brackets
b=io.read() --get the input
for c in b:gmatch('.') do   --for every character
    if c:find("[%[<{%(]") then
        s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")") --if the current character is an opening bracket, push the closing bracket onto the stack
    elseif c:find("[%]>}%)]") then
        if t.remove(s)~=c then
            print(f) --if the character is a closing bracket, pop the closing bracket off the stack and test if they match, if not print false
            return
        end
    else 
        print(f) --if the character is not a bracket print false
        return
    end
end
if #s>0 then
    print(f) --if there are still brackets on the stack print false
else
    print(1) --print 1 there are no brackets on the stack
end

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

Japt v2.0a0 -!, 16 바이트

e/\[]|<>|\(\)|{}

시도 해봐

R, 298

function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}

여기서 접근 방법은 시퀀스를 R 코드로 변환 한 다음 구문 분석하고 평가하는 것입니다. 오류가 발생하면를 반환하십시오 FALSE.

그러나 사소한 문제가 ... 브래킷 R의 규칙은, 그래서 다른 <과 >브래킷은 전혀하지 않고, 다른 종류의 자신의 규칙이있다. 이것은 머리와 꼬리가 다른 방식으로 삐걱 거리면 오류를 알리는 기능 만하는 혁신적인 접근 방식 인 삐걱 거리는 기능으로 해결됩니다.

예를 들어, []로 변환된다 S('[', {}, ']')S는 다음과 같이 정의된다, ...

S=function(H,B,T)if(H!=T)stop() 

헤드 스 퀴크와 테일 스 퀴크가 일치하기 때문에 오류가 발생하지 않습니다.

다른 몇 가지 예 (왼쪽 부분은 일련의 대괄호이고 오른쪽 부분은 평가할 수있는 유효한 R 코드로의 변환입니다) :

[}     -->  S('[', {}, '}')     # squeaks an error
[()]   -->  S('[', {S('(',{},'(')}, "[")
({[]}) -->  S('(',{S('{',{S('[',{},'[');},'{');},'(');

다른 일련의 대괄호는 구문 분석 오류를 발생시킵니다.

[[)    -->   S('[',{S('[',{},'('); 

따라서 나머지 부분은 오류를 포착하고 FALSE가 있으면 FALSE를 반환하고 없으면 TRUE를 반환합니다.

사람이 읽을 수있는 코드 :

 sqk <- function(.){
   s=strsplit;u=paste0
   .=s(.,"")[[1]]            # break the argument up into 1-character pieces
   p=s("><)(}{][","")[[1]]   # vector of brackets
   .[!.%in%p]="§"            # replace anything besides brackets by § (--> error)
   for(i in 1:4*2){     
     .[.==p[i]]=sprintf("S('%s',{",p[i])    # '<' -->   S('<',{     ... etc
     .[.==p[i-1]]=sprintf("},'%s');",p[i])  # '>' -->   },'<');     ... etc  
   }
   S=function(H,B,T)if(H!=T)stop()          # define the working horse
   r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
   if(inherits(r,"try-error"))FALSE else TRUE   # any errors?
   }

샘플 케이스에 적용 :

truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
                      ()                 [](){}<>                 (((()))) 
                    TRUE                     TRUE                     TRUE 
                ({[<>]})             [{()<>()}[]] [([]{})<{[()<()>]}()>{}] 
                    TRUE                     TRUE                     TRUE 
> sapply(falsy,sqk)
           (            }        (<2)> (()()foobar)     [({}<>)>      (((())) 
       FALSE        FALSE        FALSE        FALSE        FALSE        FALSE