Chúng tôi gọi một nhóm parens là paren mở (, paren gần giống với nó )và mọi thứ bên trong chúng.

Một nhóm Parens hoặc chuỗi được gọi là parenthesly cân nếu nó có chứa một trong hai không có gì hoặc chỉ có 2 sự cân parenthesly nhóm Parens.

Ví dụ:

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.

Tương tự như vậy:

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.

Vì vậy, một chuỗi cân bằng ngoặc hoặc nhóm parens nên:

• Không chứa gì cả.
• Hoặc chỉ chứa và chính xác 2 nhóm parens cân bằng ngoặc đơn. Nó không chứa gì khác.

Bài tập:

Nhiệm vụ của bạn là viết một hàm hoặc chương trình kiểm tra xem một chuỗi đã cho có phải là một chuỗi cân bằng hay không.

Đầu vào:

Đầu vào sẽ là một chuỗi hoặc danh sách các ký tự hoặc một cái gì đó tương tự. Bạn có thể giả định rằng chuỗi sẽ chỉ bao gồm các ký tự '('và ')'. Bạn cũng có thể giả định rằng mỗi mở paren (sẽ phải phù hợp với paren gần của nó ), do đó, không lo lắng về chuỗi như "((("hoặc ")("hoặc "(())("...

^{Lưu ý: Như đã đề cập bởi @DigitalTrauma ở dưới bình luận của mình, đó là ok để subtitute sự ()kết hợp của các nhân vật khác (ví dụ như <>, [], ...), nếu nó gây ra việc bổ sung như thoát trong một số ngôn ngữ}

Đầu ra:

Bất cứ điều gì để báo hiệu cho dù chuỗi có cân bằng ngoặc hay không (đúng hay sai, 1 hoặc 0, ...). Vui lòng bao gồm trong câu trả lời của bạn những gì chức năng / chương trình của bạn dự kiến ​​sẽ mang lại.

Ví dụ:

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

^{Hai ví dụ cuối cùng thực sự tạo ra sự khác biệt!}

May mắn nhất!

Japt v2, 20 byte

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

Kiểm tra nó trực tuyến!

Mọi người ban đầu đã hiểu sai về thử thách và mặc dù mỗi cặp dấu ngoặc đơn phải chứa một số cặp chẵn , trong khi thực tế, thử thách thực sự yêu cầu 0 hoặc 2 cặp phụ. Vì vậy, đây là câu trả lời sửa đổi của tôi, sử dụng kỹ thuật tương tự như trước đây.

Chúng tôi vẫn có thể giải quyết thách thức với sự thay thế đệ quy. Vấn đề là, thay vì chỉ loại bỏ tất cả các lần xuất hiện ()(), chúng ta cần đảm bảo rằng không có gì khác trong cùng một trình bao bọc ngoài ()()(nói cách khác, không ()()()()hoặc bất cứ điều gì tương tự). Chúng ta có thể làm điều này bằng cách thay thế đệ quy (()())bằng ().

Vấn đề mới là bản thân đầu vào không có một cặp dấu ngoặc ngoài (vì điều đó sẽ làm cho nó không phải là một chuỗi cân bằng trong ngoặc đơn), buộc chúng ta phải bọc nó trong một cặp bổ sung để giảm hoàn toàn. Cuối cùng, kết quả cuối cùng cho các chuỗi cân bằng bây giờ ()thay vì chuỗi trống, vì vậy chúng tôi kiểm tra sự bằng nhau thay vì chỉ lấy logic KHÔNG của đầu ra.

sed 4.2.2, 30

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

Hãy thử trực tuyến .

Điều này trả về mã thoát shell là 1 cho True và 0 cho false.

:               # 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 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Chỉnh sửa: Đã lưu 2 byte nhờ @JoKing. Giải thích: Chỉ là một regex đệ quy. Nhóm chụp bên ngoài đại diện cho một chuỗi cân bằng <theo sau là một chuỗi cân bằng tùy chọn theo sau là một >, hai lần. Lưu ý rằng hầu hết các câu trả lời khác đều có thể sử dụng ()s nhưng điều này tốn thêm hai byte:

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm.

Thường trình mã máy 6502 , 48 byte

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

Yêu cầu một con trỏ tới một chuỗi trong $fb/ $fcdự kiến ​​chỉ chứa (và ). Xóa cờ C (Carry) nếu chuỗi là "cân bằng ngang nhau", đặt nó khác (đó là một thành ngữ điển hình trên 6502, đặt carry "có lỗi"). Không có gì hợp lý trên đầu vào không hợp lệ.

Mặc dù thuật toán là đệ quy, nó không gọi chính nó (sẽ cần nhiều byte hơn và làm cho vị trí mã phụ thuộc) mà thay vào đó duy trì độ sâu đệ quy và sử dụng phân nhánh "đơn giản".

Bình luận tháo gỡ

; 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

Ví dụ chương trình biên dịch chương trình C64 sử dụng thường trình:

Bản demo trực tuyến

Mã theo cú pháp 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 byte

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

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

é(                      " 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

Hexdump:

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

Brachylog , 28 byte

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

Hãy thử trực tuyến!

Giải trình

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

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;}

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

MATL , 26 25 byte

oo~`tnw52B5LZttnb<]XB10X-

Hãy thử trực tuyến!

Cảm ơn câu trả lời của @ETH Productstions cho ý tưởng "thay thế (() ()) bằng ()" và nhận xét câu hỏi của @JungHwan Min cho ý tưởng xem dấu ngoặc là chữ số nhị phân.

Đầu ra là một mảng trống cho tính trung thực, một số dương cho falsey - mà tôi nghĩ được cho phép bởi nhận xét của OP: "Có thể là các danh mục. Tức là các giá trị trung thực để báo hiệu sự trung thực và giá trị giả để báo hiệu khác." Nếu không, chúng ta có thể thêmn vào cuối cho +1 byte, để có 0 là đầu ra trung thực và 1 là đầu ra falsey.

Với nhận xét:

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 Core) , 78 71 byte

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

Hãy thử trực tuyến!

Haskell , 82 59 byte

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

Hãy thử trực tuyến!

Tôi cho rằng nó có thể được chơi gôn hơn nữa vì đây là lần đầu tiên tôi chơi golf ở haskell, vì vậy mọi thủ thuật hay bình luận đều được chào đón nhiều hơn.

EDIT - Cảm ơn @nimi vì đã lưu 23 byte (hơn 28% số lần gửi ban đầu :)

JavaScript (ES6), 63 byte

Đưa đầu vào như một mảng các ký tự. Trả về false cho cân bằng ngoặc, đúng cho không cân bằng ngoặc.

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

Hãy thử trực tuyến!

Đã bình luận

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()

Đệ quy, 54 byte

Tuy nhiên, sử dụng thay thế đệ quy (như trong câu trả lời Japt của ETHproductions ) ngắn hơn đáng kể.

Đưa đầu vào dưới dạng một chuỗi. Trả về 1 cho cân bằng ngoặc, 0 cho không cân bằng ngoặc.

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

Hãy thử trực tuyến!

Đệ quy, 46 byte

Điều này đưa ra một lỗi đệ quy cho không cân bằng ngoặc:

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

Hãy thử trực tuyến!

Perl 6 ,  43 41  37 byte

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

Kiểm tra nó

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

Kiểm tra nó

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

Kiểm tra nó

Mở rộng:

{  # 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
    /
}

R , 71 byte

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

Hãy thử trực tuyến!

• porting giải pháp Japt đệ quy của @ETHproductions
• -2 byte nhờ @JayCe

Một giải pháp khác - dài hơn nhưng thú vị cho cách tiếp cận khác

R , 85 byte

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

Hãy thử trực tuyến!

Giải trình :

Lấy chuỗi đầu vào và thay thế:

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

sau đó đánh giá biểu thức kết quả. Nếu nó bằng 0 được cân bằng, nếu không thì không. Việc sử dụng sumchỉ cần thiết để xử lý trường hợp chuỗi rỗng, bởi vì đánh giá của nó trả về NULL.

ví dụ

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

Ngôn ngữ Wolfram (Mathicala) , 65 byte

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

Hãy thử trực tuyến!

05AB1E , 18 16 13 byte

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

Cảng @ETHproductions 's Japt câu trả lời để sửa chữa các trường hợp thử nghiệm ()(()()(()())(()())).
-2 byte nhờ @Adnan .

Dựa trên nhận xét này của OP, bây giờ tôi sử dụng ()như một giá trị trung thực và bất cứ thứ gì khác như falsey. Nếu cả hai giá trị cần nhất quán thay vì chỉ một, thì đó sẽ là câu trả lời 16 byte cũ thay thế ( …(ÿ)…(()∞„()©:®Q), trả về 0cho sự thật và1 cho các trường hợp kiểm tra falsey.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

…(ÿ)             # 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)

(Câu trả lời 18 byte cũ không thành công cho trường hợp thử nghiệm ()(()()(()())(()()))..):

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

APL (Dyalog Classic) , 27 byte

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

Hãy thử trực tuyến!

Prolog , 46 byte

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

Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm!

Danh sách sử dụng của l và rnhư là đầu vào, ví dụ như "()()"được kiểm tra như f([l,r,l,r])..

Ba dòng đầu tiên là ngữ pháp của các chuỗi hợp lệ trong cú pháp Ngữ pháp xác định mệnh đề của Prolog . a(A,B).trả về truekhi Amột danh sách theo ngữ pháp và Btrống. Do đó, chức năng chính fmất một số Xvà kiểm tra xem a(X,[])có giữ không.

Python 2 , 73 71 byte

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

Hãy thử trực tuyến!

Brainfuck, 50 byte

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

Định dạng:

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

Yêu cầu một chuỗi có (và )không có dòng mới, và kết quả đầu ra \x01là đúng và \x00sai. (Đối với mức độ dễ đọc, bạn có thể thêm 48 +giây trước trận chung kết .để thực hiện in 1và 0thay vào đó.)

Dùng thử trực tuyến

Điều này duy trì một ngăn xếp với số lượng nhóm ở mỗi độ sâu, phân biệt các ký tự theo tính chẵn lẻ và kiểm tra xem số lượng nhóm có trong {0, 2} sau mỗi dấu ngoặc đơn đóng không; nếu điều kiện không được đáp ứng, tiêu thụ phần còn lại của đầu vào và đặt cờ; sau đó kiểm tra lại điều kiện một lần nữa vào cuối chương trình.

Nếu chúng ta được phép chấm dứt luồng đầu vào với một ký tự lẻ, chúng ta có thể bỏ qua kiểm tra cuối cùng <[--[>->]]để lưu 10 byte. (Nếu\n thậm chí không bất tiện, tôi có thể đã đề xuất biến thể này là câu trả lời chính.)

(Chúng tôi cũng có thể lưu một số byte bằng cách thay đổi định dạng đầu ra thành \x00đúng và không \x00sai, dường như được cho phép (có thể vô tình) bởi câu lệnh vấn đề như đã viết, nhưng dù sao nó sẽ không thú vị, và tôi thích không tạo ra sự thay đổi đó.)

Python2, 95 94 byte

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

Hãy thử trực tuyến!

f () biến đổi chuỗi thành một tuple lồng nhau, nó chuyển đến g ().

g () điều hướng đệ quy bộ dữ liệu và trả về Sai nếu bất kỳ phần tử nào không có chính xác 0 hoặc 2 con.

Đã lưu một byte bằng cách sử dụng định dạng chuỗi.

Stax , 13 11 byte

₧aaS▐îî»Å·╢

Chạy và gỡ lỗi nó

Tôi đã lưu hai byte khi tôi nhận ra các đầu vào có thể ngẫu nhiên được gọi là mảng bằng chữ. Bằng cách loại bỏ các dấu ngoặc kép, đầu vào được đơn giản hóa.

Ý tưởng chung là đánh giá đầu vào dưới dạng một mảng bằng chữ và ánh xạ đệ quy các phần tử để kiểm tra sự cân bằng ngang nhau. Nếu xác nhận cuối cùng từng thất bại, thì sẽ có một cửa sổ bật lên tiếp theo trên một ngăn xếp trống. Trong stax, popping với ngăn xếp trống ngay lập tức chấm dứt chương trình.

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

        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

Chạy cái này

Java 10, 99 96 95 83 byte

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

Cổng câu trả lời 05AB1E của tôi (cũng trả về() là sự thật và bất cứ điều gì khác như falsey).

Hãy thử trực tuyến.

Giải trình:

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;có thể return"()".equals(s);nếu một kết quả boolean thực tế được yêu cầu.