우리는 parens 그룹 을 열린 paren (, 그와 일치하는 close paren )및 그 안의 모든 것을 호출 합니다.

괄호 그룹 또는 문자열이 괄호로 균형을 이룬 2 개의 괄호 그룹이 없거나 괄호로 묶인 경우 괄호 그룹 또는 문자열을 괄호 밸런싱 이라고 합니다.

예를 들면 다음과 같습니다.

The string   "(()())()"      is parenthesly balanced
              (    )()       Because it contains exactly 2 parenthesly balanced parens groups
               ()()          The left one is parenthesly balanced because it contains 2 parenthesly balanced parens groups (balanced because they are empty). The right one is parenthesly balanced because it contains nothing.

마찬가지로:

The string   "(()(()))()"    is not parenthesly balanced
              (      )()     Because it contains a parens group that is not parenthesly balanced: the left one
               ()(  )        The left one is not balanced because it contains a parens group that is not balanced: the right one
                  ()         The right one is not balanced because it only contains one balanced group.

따라서 괄호로 묶인 문자열 또는 파 렌스 그룹은 다음 중 하나 여야합니다.

• 전혀 포함하지 않습니다.
• 또는 정확히 2 개의 괄호로 균형 잡힌 parens 그룹을 포함하십시오. 다른 것은 포함하지 않아야합니다.

직무:

당신의 임무는 주어진 문자열이 괄호로 균형이 잡힌 문자열인지 확인하는 함수 또는 프로그램을 작성하는 것입니다.

입력:

입력은 문자열 또는 문자 목록 또는 이와 유사한 것입니다. 문자열은 '('및 문자로만 구성되어 있다고 가정 할 수 있습니다 ')'. 또한 각 열린 paren (이 일치하는 close paren을 가질 것이라고 가정 할 수 )있으므로 "((("or ")("또는 "(())("... 와 같은 문자열에 대해 걱정하지 마십시오 .

^{참고 : 로 자신의 의견 우는 소리에 @DigitalTrauma 언급, 그것은 subtitute 괜찮은지 ()(예 : 다른 문자로 콤보를 <>, []그 어떤 언어로 탈출과 같은 추가 작업을 일으키는 경우, ...)}

산출:

문자열이 괄호로 균형을 이루는 지 여부를 나타내는 모든 것 (true 또는 false, 1 또는 0, ...). 귀하의 기능 / 프로그램이 기대하는 결과를 답에 포함 시키십시오.

예 :

""                                        => True
"()()"                                    => True
"()(()())"                                => True
"(()(()(()())))(()())"                    => True
"(((((((()())())())())())())())()"        => True
"()"                                      => False
"()()()"                                  => False
"(())()"                                  => False
"()(()(())())"                            => False
"(()())(((((()())()))())())"              => False
"()(()()()())"                            => False
"()(()(()())()())"                        => False

^{마지막 두 예는 실제로 차이를 만들었습니다!}

행운을 빌어 요!

Japt v2, 20 바이트

V="()"V¥iU1 eViV²1 V

온라인으로 테스트하십시오!

처음에는 도전 과제를 오해했지만 각 괄호 쌍에는 짝수 의 하위 쌍이 포함되어 있어야했지만 실제로 도전 과제는 실제로 0 또는 2 개의 하위 쌍을 요구합니다. 이전과 동일한 기술을 사용하여 수정 된 답변이 있습니다.

우리는 여전히 재귀 교체로 문제를 해결할 수 있습니다. 문제는 모든 발생을 제거하는 대신 ()()동일한 래퍼에 ()()(즉, 없음 ()()()()또는 이와 유사한 것) 외에 다른 것이 없는지 확인해야합니다 . 재귀 적으로로 바꾸면 (()())됩니다 ().

새로운 문제는 입력 자체에 한 쌍의 외부 괄호가 없기 때문에 (괄호로 묶인 문자열이 아니므로) 여분의 쌍으로 감싸서 입력을 완전히 줄입니다. 마지막으로, 균형 잡힌 문자열의 최종 결과는 이제 ()빈 문자열 대신에 출력의 논리적 NOT을 취하는 것이 아니라 평등을 검사합니다.

sed 4.2.2, 30

:
s/(()())/()/
t
/^()()$\|^$/q1

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

이것은 True의 경우 쉘 종료 코드 1을, False의 경우 0을 리턴합니다.

:               # label
s/(()())/()/    # replace "(()())" with "()"
t               # jump back to label if above replacement matched
/^()()$\|^$/q1  # exit code 1 if remaining buffer is exactly "()()" or empty
                # otherwise exit with code 0

Perl 5 -lp, 24 22 바이트

$_=/^((<(?1)?>){2})?$/

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 편집 : @JoKing 덕분에 2 바이트가 절약되었습니다. 설명 : 재귀 정규식입니다. 외부 캡처 그룹은 <균형 잡힌 문자열 다음에 옵션으로 균형 잡힌 문자열 뒤에을 >두 번 나타냅니다. 대부분의 다른 답변은 ()s 를 사용할 수 있지만 추가 2 바이트가 필요합니다.

$_=/^((\((?1)?\)){2})?$/

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다.

6502 머신 코드 루틴, 48 바이트

A0 00 84 FD A2 00 B1 FB F0 0E C8 C9 29 18 F0 06 8A 48 E6 FD 90 EE B0 0A E0 01
90 06 E0 02 38 D0 01 18 A5 FD F0 09 C6 FD 68 AA E8 B0 F5 90 D7 60

문자열에 대한 포인터 기대 $fb/ $fc만이 포함되는 (과 ). 문자열이 "paranthesely balance"인 경우 C (Carry) 플래그를 지우고 그렇지 않은 경우 설정합니다 (6502의 일반적인 관용구, "cary on on error"로 설정). 유효하지 않은 입력에는 아무런 의미가 없습니다.

알고리즘은 재귀이지만, (자세한 바이트를 필요하는 자체를 호출하지 않습니다 및 의존 코드 위치를 확인) 대신 재귀 깊이 자체 사용 "간단한"분기를 유지한다.

주석 처리 된 분해

; function to determine a string is "paranthesly balanced"
;
; input:
;   $fb/$fc: address of the string
; output:
;   C flag set if not balanced
; clobbers:
;   $fd:     recursion depth
;   A,X,Y

 .isparbal:
A0 00       LDY #$00            ; string index
84 FD       STY $FD             ; and recursion depth
 .isparbal_r:
A2 00       LDX #$00            ; set counter for parantheses pairs
 .next:
B1 FB       LDA ($FB),Y         ; load next character
F0 0E       BEQ .done           ; end of string -> to final checks
C8          INY                 ; increment string index
C9 29       CMP #$29            ; compare with ')'
18          CLC                 ; and reset carry
F0 06       BEQ .cont           ; if ')' do checks and unwind stack
8A          TXA                 ; save counter ...
48          PHA                 ; ... on stack
E6 FD       INC $FD             ; increment recursion depth
90 EE       BCC .isparbal_r     ; and recurse
 .cont:
B0 0A       BCS .unwind         ; on previous error, unwind directly
 .done:
E0 01       CPX #$01            ; less than one parantheses pair
90 06       BCC .unwind         ; -> ok and unwind
E0 02       CPX #$02            ; test for 2 parantheses pairs
38          SEC                 ; set error flag
D0 01       BNE .unwind         ; if not 2 -> is error and unwind
18          CLC                 ; clear error flag
 .unwind:
A5 FD       LDA $FD             ; check recursion depth
F0 09       BEQ .exit           ; 0 -> we're done
C6 FD       DEC $FD             ; otherwise decrement
68          PLA                 ; get "pair counter" ...
AA          TAX                 ; ... from stack
E8          INX                 ; and increment
B0 F5       BCS .unwind         ; continue unwinding on error
90 D7       BCC .next           ; otherwise continue reading string
 .exit:
60          RTS

루틴을 사용하는 예제 C64 어셈블러 프로그램 :

온라인 데모

ca65 구문의 코드 :

.import isparbal   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
linebuf:        .res    256

.data
prompt:         .byte   "> ", $0
truestr:        .byte   "true", $0
falsestr:       .byte   "false", $0

.code
inputloop:
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #0              ; effectively 256
                jsr     readline

                lda     #<linebuf       ; address of string to $fb/fc
                sta     $fb
                lda     #>linebuf
                sta     $fc
                jsr     isparbal        ; call function

                bcs     isfalse
                lda     #<truestr
                ldy     #>truestr
                bne     printresult
isfalse:        lda     #<falsestr
                ldy     #>falsestr
printresult:    jmp     $ab1e           ; output true/false and exit

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

V , 21 , 20 바이트

é(Á)òÓ(“()()…)òø^()$

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

é(                      " Insert '(' at the beginning of the line
  Á)                    " Append ')' at the end
    ò         ò         " Recursively...
     Ó                  "   Remove...
      (                 "     '('
       “    …           "     (Limit the part that is removed to this section of the match)
        ()()            "     '()()'
             )          "     ')'
                        " (effectively, this replaces '(()())' with '()', but it's one byte shorter than the straightforward approach
               ø        " Count...
                ^()$    "   Lines containing exactly '()' and nothing more

16 진 덤프 :

00000000: e928 c129 f2d3 2893 2829 2829 8529 f2f8  .(.)..(.()().)..
00000010: 5e28 2924                                ^()$

Brachylog , 28 바이트

Ẹ|~c["(",A,")(",B,")"]∧A;B↰ᵐ

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

설명

                                    --  The string perfectly balanced iff
Ẹ                                   --      the string is empty
 |                                  --  or
  ~c["(",A,")(",B,")"]              --      the string can be written id the format of "($A)($B)"
                      ∧             --          where
                       A;B ᵐ        --          both A and B
                          ↰         --          are perfectly balanced

C (gcc) , 113 바이트

p(a,r,e,n)char*a;{if(*a-40)return 1;for(r=1,e=0;e<2;r&=e++||*a==40)for(r*=n=p(++a);n+=*a++-40?~0:1;);r=r&&*a-40;}

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

설명

p(a,r,e,n)char*a;{   // function and variable declaration
 if(*a-40)return 1;  // string does not start with '(', thus is empty
 for(r=1,e=0;e<2;    // r: return value, e: group id (look for exactly two groups)
 r&=e++||*a==40)     // after the first group, a second shall follow
  for(r*=n=p(++a);   // check that the group is itself balanced
  n+=*a++-40?~0:1;); // skip group
 r=r&&*a-40;}        // additionally, after those two groups there shall follow none

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

MATL , 26 25 바이트

oo~`tnw52B5LZttnb<]XB10X-

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

@ETHProductions의 답변으로 "(replace (() ()) with ()") 아이디어와 @JungHwan Min의 대괄호를 이진수로 보는 아이디어에 감사드립니다.

출력은 진실에 대한 빈 배열이며, 거짓에 대한 양수입니다. OP의 의견에서 허용되는 것으로 생각합니다. "카테고리가 될 수 있습니다. 그렇지 않은 경우 n+1 바이트의 끝에 추가 하여 0을 출력으로, 1을 출력으로 설정할 수 있습니다.

의견 :

o         % Convert the parantheses to their ASCII codes
          %  40 for '(', 41 for ')'
o         % Parity - 1 for odd, 0 for even
~         % Not - change 0 to 1 and vice versa, so '(' is now 1 and ')' 0
          % Input char array is now a binary array B
`         % Do-while loop
  tn          % Get the length of the array 
  w           % Bring the array B back on top
  52B         % Push the binary value of 52 on stack
              %  [1 1 0 1 0 0] (equivalent to '(()())')
  5L          % Push the constant [1 0] for '()'
  Zt          % Replace the sequence [1 1 0 1 0 0] in array B
              %  with [1 0]
  tn          % Get the length of the array after replacement 
  b<          % Has it decreased? If so, continue loop
  ]       % end loop
          % Final value for balanced input will be
          %  either [1 0 1 0] for the remaining outer '()()'
          %  or an empty array [] for empty '' input
XB        % Convert the final binary array back to decimal
10X-      % Set difference, remove 10 from that result 
          % Result is [] empty array for balanced input, otherwise 
          %  some decimal number ≠ 10 for unbalanced input

C # (. NET 코어) , 78 71 바이트

f=s=>{var r=s.Replace("(()())","()");return r==s?s==""|s=="()()":f(r);}

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

하스켈 , 82 59 바이트

all(`elem`[0,2]).foldl(#)[0]
b#'('=0:b
(x:y:z)#_=y+1:z++[x]

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

하스켈에서 처음으로 골프를 타기 때문에 골프를 훨씬 더 할 수 있다고 생각하므로 트릭이나 의견은 환영 이상입니다.

편집 -23 바이트 를 절약 해 주신 @nimi에게 감사드립니다 (원래 제출의 28 % 이상)

자바 스크립트 (ES6), 63 바이트

문자 배열로 입력을받습니다. 괄호 균형 이 맞지 않으면 false 를, 괄호 가 맞지 않으면 true 를 반환 합니다.

a=>[...a,k=0].some(c=>c<')'?!(a[k]=-~a[k++]):a[k]=~5>>a[k--]&1)

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

댓글

a =>                     // a[] = input array of characters; we are going to reuse it to
  [                      // store the number of parenthesis groups at each depth
    ...a,                // append all characters
    k = 0                // initialize k = current depth to 0 and append a value that will
  ]                      // be treated as a final closing parenthesis for the root level
  .some(c =>             // for each character c in this array:
    c < ')' ?            //   if c is an opening parenthesis:
      !(                 //     increment the number of groups at the current depth
        a[k] = -~a[k++]  //     increment the depth
      )                  //     yield false
    :                    //   else:
      a[k] = ~5          //     make sure that the current depth contains either 0 or 2
             >> a[k--]   //     groups, by shifting the 1-complement of 5 (101 in binary)
             & 1         //     and testing the least significant bit
                         //     it resets the number of groups to 0 if the bit is not set
                         //     otherwise, it forces some() to return true
                         //     decrement the depth
  )                      // end of some()

재귀, 54 바이트

그러나 ETHproductions의 Japt answer 에서와 같이 재귀 대체를 사용하는 것이 훨씬 짧습니다.

입력을 문자열로받습니다. 괄호 균형 이 맞지 않으면 1 을, 괄호 균형 이 맞지 않으면 0 을 반환 합니다.

f=s=>s==(s=s.split`(()())`.join`()`)?!s|s=='()()':f(s)

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

재귀, 46 바이트

이것은 괄호로 균형이 맞지 않으면 재귀 오류가 발생합니다.

f=s=>!s|s=='()()'||f(s.split`(()())`.join`()`)

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

펄 6 ,  43 41  37 바이트

{my rule f{\([<&f>**2]?\)};?/^<&f>**2$|^$/}

그것을 테스트

{(my$f)=/\([<$f>**2]?\)/;?/^[<$f>**2]?$/}

그것을 테스트

{$!=/\([<$!>**2]?\)/;?/^[<$!>**2]?$/}

그것을 테스트

넓히는:

{  # bare block lambda with implicit parameter $_

  $! = # store regex into $! (no need to declare it)
  /
    \(

      [
        <$!> ** 2 # recurse into regex twice
      ]?          # optionally

    \)
  /;


  ?      # boolify (causes it to be run against $_)

    /
      ^         # beginning of string

      <$!> ** 2 # match using regex twice

      $         # end of string

    |           # or

      ^ $       # empty string
    /
}

아르 자형 , 71 바이트

f=function(s,r=sub('(()())','()',s,f=T))'if'(r==s,s==''|s=='()()',f(r))

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

• @ETHproductions의 재귀 Japt 솔루션 포팅
• @JayCe 덕분에 -2 바이트

더 길지만 더 길지만 다른 접근 방식에 흥미로운 솔루션

R , 85 바이트

g=gsub;!sum(eval(parse(t=g('\\)\\(',')-(',g('\\)','-1)',g('\\(','(2+',scan(,'')))))))

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

설명 :

입력 문자열을 가져와 다음을 바꿉니다.

'('  with '(2+'
')'  with '-1)'
')(' with ')-('

그런 다음 결과 표현식을 평가합니다. 0과 같으면 균형이 맞지 않습니다. sum평가는 다음을 반환하므로 빈 문자열 케이스를 처리하는 데만 사용해야 합니다.NULL .

예 :

()(()()) => (2+-1)-(2+(2+-1)-(2+-1)-1) = 0
(()())   => (2+(2+-1)-(2+-1)-1)        = 1

Wolfram Language (Mathematica) , 65 바이트

#=={}||{1,1}==(#//.{a___,"(",i:1...,")",b___}/;1!=+i<3:>{a,1,b})&

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

05AB1E , 18 16 13 바이트

…(ÿ)…(()∞„()©:®Q

포트 @ETHproductions 의 JAPT의 대답은 테스트 케이스를 고정합니다 ()(()()(()())(()())). @Adnan
덕분에 -2 바이트 .

이 OP 에 대한 의견을 바탕으로 나는 이제 ()진실한 가치로 사용 하고 다른 것은 거짓으로 사용합니다. 두 값이 하나가 아닌 일관성이 있어야하는 경우, 이전 16 바이트 응답 ( …(ÿ)…(()∞„()©:®Q)이 0되어 진실되고 1잘못된 테스트 사례 로 돌아갑니다 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오. .

설명

…(ÿ)             # Take the input (implicitly) and surround it with "(" and ")"
            :    # Infinite replacement of:
    …(()∞        #  "(()())"    ("(()" mirrored)
         „()     #  with "()"
                 # After the infinite replacement: return the result
                 # ("()" for truthy; falsey otherwise)

(테스트 사례 ()(()()(()())(()()))..에 실패한 이전 18 바이트 답변 ) :

ΔD„()∞©6∍å_i®õ.:]Ā

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

APL (Dyalog Classic) , 27 바이트

3>≢'<<><>>'⎕r'<>'⍣≡1⌽'><',⎕

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

프롤로그 , 46 바이트

a-->p,p.
a-->[].
p-->[l],a,[r].
f(X):-a(X,[]).

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

입력 l및 목록을 사용합니다 ( r예 : "()()"로 테스트) f([l,r,l,r])..

처음 세 줄은 Prolog의 Definite Clause Grammar 구문 에서 유효한 문자열의 문법입니다 . 문법 뒤에 오는 목록 이 비어 있을 때를 a(A,B).반환합니다 . 따라서 주요 기능 은 일부를 가져 와서 보유 여부를 확인합니다 .trueABfXa(X,[])

파이썬 2 , 73 71 바이트

f=lambda s,P='(()())':P in s and f(s.replace(P,'()'))or s in['()()','']

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

brainfuck, 50 바이트

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

형식화 :

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

문자열 예상 (과 )후행 바꿈을없이하여 출력 \x01참과 \x00거짓 대. (가독성을 위해 예를 들어 +결선 전에 48 초를 추가 .하여 인쇄 1하고 0대신 인쇄 할 수 있습니다 .)

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

이는 각 깊이에서 그룹 수를 갖는 스택을 유지하고, 패리티로 문자를 구별하고 각 닫는 괄호 후에 그룹 수가 {0, 2}인지 여부를 확인합니다. 조건이 충족되지 않으면 나머지 입력을 소비하고 플래그를 설정합니다. 그런 다음 프로그램 종료시 조건을 다시 확인하십시오.

홀수 문자로 입력 스트림을 종료 할 수있는 경우 최종 점검 <[--[>->]]을 생략하여 10 바이트를 절약 할 수 있습니다 . ( \n불편하게 고르지 않았다면 이 변형을 주된 대답으로 제안했을 수도 있습니다.)

(우리는 출력 형식을 \x00true와 non- \x00false 로 변경하여 바이트를 절약 할 수 있습니다 . 이것은 문제의 진술에 의해 서면으로 허용 된 것처럼 보일 수 있지만 어쨌든 흥미롭지는 않습니다. 변경하지 마십시오.)

Python2, 95 94 바이트

f=lambda i:g(eval("(%s)"%i.replace(")","),")))
g=lambda i:len(i)in(0,2)and all(g(j)for j in i)

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

f ()는 문자열을 중첩 된 튜플로 변환하여 g ()로 전달합니다.

g ()는 튜플을 재귀 적으로 탐색하고 요소에 정확히 0 또는 2 개의 자식이없는 경우 False를 반환합니다.

문자열 형식을 사용하여 1 바이트를 저장했습니다.

Stax , 13 11 바이트

₧aaS▐îî»Å·╢

실행 및 디버깅

입력이 우연히 배열 리터럴로 무시 될 수 있음을 깨달았을 때 2 바이트를 절약했습니다. 큰 따옴표를 제거하면 입력이 단순화됩니다.

일반적인 아이디어는 입력을 배열 리터럴로 평가하고 요소를 재귀 적으로 매핑하여 균형을 확인합니다. 최종 어설 션이 실패하면 빈 스택에 후속 팝업이 나타납니다. stax에서 빈 스택으로 팝하면 프로그램이 즉시 종료됩니다.

포장을 풀고 포장을 풀고 주석을 달았습니다.

        input is implicitly treated as array literals
L       wrap entire input stack in an array
G       jump to the trailing '}', and come back when done
}       terminate the program, the rest is a recursive call target
{Gm     map array on top of the stack by using the recursive call target
%       get the length of the mapped array
02\#    is the length one of [0, 2]?
|c      assert value is truthy, pop if not

이것을 실행

자바 10, 99 96 95 83 바이트

s->{s="("+s+")";for(var p="";!p.equals(s);s=s.replace("(()())","()"))p=s;return s;}

내 05AB1E 답변 포트 (따라서 ()진실로, 다른 것으로 거짓으로 반환).

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

설명:

s->{                 // Method with String as both parameter and return-type
  s="("+s+")";       //  Surround the input-String between "(" and ")"
  for(var p="";      //  Previous-String, starting empty
      !p.equals(s)   //  Loop as long as the previous and current Strings differ
      ;              //    After every iteration:
       s=s.replace("(()())","()"))
                     //     Replace all "(()())" with "()"
    p=s;             //   Set the previous String with the current
  return s;}         //  Return the modified input-String
                     //  (if it's now "()" it's truthy; falsey otherwise)

return s;return"()".equals(s);실제 부울 결과가 필요한 경우 일 수 있습니다 .