Kami menyebut grup paren paren terbuka (, paren dekat yang cocok) dan semua yang ada di dalamnya.

Grup atau string parens disebut tanda kurung seimbang jika tidak mengandung apa-apa atau hanya 2 kelompok parens seimbang murni.

Sebagai contoh:

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.

Juga:

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.

Jadi, string atau grup parens seimbang harus:

• Tidak mengandung apa pun.
• Atau hanya berisi dan persis 2 grup parens seimbang yang disusun dalam tanda kurung. Seharusnya tidak mengandung yang lain.

Tugas:

Tugas Anda adalah menulis fungsi atau program yang memeriksa apakah string yang diberikan adalah tanda kurung yang seimbang atau tidak.

Memasukkan:

Input akan berupa string atau daftar karakter atau yang serupa. Anda dapat mengasumsikan bahwa string hanya akan terdiri dari karakter '('dan ')'. Anda juga dapat mengasumsikan bahwa setiap paren terbuka (akan memiliki cocok paren penutupan ), jadi jangan khawatir tentang string seperti "((("atau ")("atau "(())("...

^{Catatan: Seperti yang disebutkan oleh @DigitalTrauma dalam komentarnya di bawah, tidak apa-apa untuk mengganti ()kombo dengan karakter lain (seperti <>,[] , ...), jika itu menyebabkan pekerjaan tambahan seperti melarikan diri dalam beberapa bahasa}

Keluaran:

Apa pun untuk memberi sinyal apakah string tersebut diseimbangkan dengan tanda kurung atau tidak (benar atau salah, 1 atau 0, ...). Harap sertakan dalam jawaban Anda apa fungsi / program Anda diharapkan untuk menghasilkan.

Contoh:

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

^{Dua contoh terakhir benar-benar membuat perbedaan!}

Semoga berhasil!

Japt v2, 20 byte

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

Uji secara online!

Setiap orang salah memahami tantangan pada awalnya dan meskipun setiap pasang tanda kurung harus mengandung jumlah sub-pasangan yang genap , padahal sebenarnya tantangan itu sebenarnya meminta 0 atau 2 sub-pasangan. Jadi inilah jawaban saya yang telah direvisi, menggunakan teknik yang sama seperti sebelumnya.

Kita masih bisa menyelesaikan tantangan dengan penggantian rekursif. Masalahnya adalah, alih-alih hanya menghilangkan semua kejadian ()(), kita perlu memastikan bahwa tidak ada yang lain di bungkus yang sama selain ()()(dengan kata lain, tidak ada ()()()()atau semacamnya). Kita dapat melakukan ini dengan rekursif mengganti (()())dengan() .

Masalah baru adalah bahwa input itu sendiri tidak memiliki sepasang tanda kurung luar (karena itu akan membuatnya bukan string yang diimbangi dengan tanda kurung), memaksa kita untuk membungkusnya dalam pasangan ekstra untuk sepenuhnya menguranginya. Akhirnya, hasil akhir untuk string seimbang sekarang ()bukan string kosong, jadi kami memeriksa kesetaraan daripada hanya mengambil BUKAN logis dari output.

sed 4.2.2, 30

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

Cobalah online .

Ini mengembalikan kode keluar shell 1 untuk Benar dan 0 untuk Salah.

:               # 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})?$/

Cobalah online! Tautan termasuk kasus uji. Sunting: Disimpan 2 byte berkat @ JoKing. Penjelasan: Hanya regex rekursif. Grup tangkapan luar mewakili string seimbang sebagai <diikuti oleh string seimbang opsional diikuti oleh >, dua kali. Perhatikan bahwa sebagian besar jawaban lain dapat digunakan ()tetapi ini membutuhkan tambahan dua byte:

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

Cobalah online! Tautan termasuk kasus uji.

6502 rutin kode mesin , 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

Mengharapkan pointer ke string di $fb/ $fcyang diharapkan hanya berisi (dan ). Hapus C (Carry) flag jika string "paranthesely balance", atur sebaliknya (yang merupakan idiom khas pada 6502, atur carry "on error"). Tidak ada yang masuk akal pada input yang tidak valid.

Meskipun algoritma ini bersifat rekursif, ia tidak menyebut dirinya sendiri (yang akan membutuhkan lebih banyak byte dan membuat posisi kode bergantung) tetapi sebaliknya mempertahankan kedalaman rekursi itu sendiri dan menggunakan percabangan "sederhana".

Komentar pembongkaran

; 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

Contoh program assembler C64 menggunakan rutin:

Demo online

Kode dalam sintaksis 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

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

Cobalah online! atau Verifikasi semua kasus uji!

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

Cobalah online!

Penjelasan

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

Cobalah online!

Penjelasan

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

Cobalah online!

MATL , 26 25 byte

oo~`tnw52B5LZttnb<]XB10X-

Cobalah online!

Terima kasih atas jawaban @ETHProductions untuk ide "replace (() ()) dengan ()", dan komentar pertanyaan @JungHwan Min untuk gagasan melihat tanda kurung sebagai digit biner.

Output adalah array kosong untuk kebenaran, angka positif untuk falsey - yang saya pikir diizinkan oleh komentar OP: "Bisa jadi kategori. Yaitu nilai-nilai kebenaran untuk menandakan kebenaran dan nilai-nilai palsu untuk memberi sinyal sebaliknya." Jika tidak, kita dapat menambahkan ndi akhir untuk +1 byte, untuk memiliki 0 sebagai output yang sebenarnya dan 1 sebagai output falsey.

Dengan komentar:

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

Cobalah online!

Haskell , 82 59 byte

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

Cobalah online!

Saya menganggap itu bisa bermain golf lebih jauh karena ini pertama kalinya saya bermain golf di haskell, jadi semua trik atau komentar lebih dari diterima.

EDIT - Terima kasih @nimi karena telah menghemat 23 byte (lebih dari 28% dari pengiriman asli :)

JavaScript (ES6), 63 byte

Mengambil input sebagai array karakter. Mengembalikan nilai false untuk parenthesly balance, true untuk tidak parenthesly balance.

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

Cobalah online!

Berkomentar

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

Rekursif, 54 byte

Namun, menggunakan penggantian rekursif (seperti dalam jawaban Japt produk ETH ) jauh lebih singkat.

Mengambil input sebagai string. Mengembalikan 1 untuk tanda kurung seimbang, 0 untuk tanda tanda kurung tidak seimbang.

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

Cobalah online!

Rekursif, 46 byte

Yang ini melempar kesalahan rekursi karena tidak diseimbangkan dengan parenthesly:

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

Cobalah online!

Perl 6 ,  43 41  37 byte

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

Menguji

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

Menguji

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

Menguji

Diperluas:

{  # 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))

Cobalah online!

• porting dari solusi Japt rekursif dari @ETHproductions
• -2 byte terima kasih kepada @JayCe

Solusi lain - lebih lama - tetapi menarik untuk pendekatan yang berbeda

R , 85 byte

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

Cobalah online!

Penjelasan:

Ambil string input dan ganti:

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

kemudian mengevaluasi ekspresi yang dihasilkan. Jika sama dengan nol seimbang, sebaliknya tidak. Penggunaansum hanya diperlukan untuk menangani kasus string kosong, karena evaluasinya kembaliNULL .

misalnya

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

Bahasa Wolfram (Mathematica) , 65 byte

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

Cobalah online!

05AB1E , 18 16 13 byte

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

Pelabuhan @ETHproductions 's Japt jawaban untuk memperbaiki kasus uji()(()()(()())(()())) .
-2 byte terima kasih kepada @Adnan .

Berdasarkan komentar OP yang saya gunakan sekarang() nilai kebenaran, dan yang lainnya sebagai falsey. Jika kedua nilai perlu konsisten, bukan hanya satu, itu akan menjadi jawaban 16-byte lama sebagai gantinya (…(ÿ)…(()∞„()©:®Q ), kembali 0untuk 1kasus uji kebenaran dan falsey.

Cobalah online atau verifikasi semua kasus uji .

Penjelasan

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

(Jawaban 18-byte lama yang gagal untuk kasus uji ()(()()(()())(()())) ..):

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

Cobalah secara online atau verifikasi semua kasus uji .

APL (Dyalog Classic) , 27 byte

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

Cobalah online!

Prolog , 46 byte

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

Cobalah online! atau Verifikasi semua kasus uji!

Menggunakan daftar ldan rsebagai input, misalnya "()()"diuji sebagaif([l,r,l,r]). .

Tiga baris pertama adalah tata bahasa string yang valid dalam sintaksis Tata Bahasa Prolog's Definite Clause . a(A,B).mengembalikan truekapan Adaftar yang mengikuti tata bahasa dan Bkosong. Jadi fungsi utama fmengambil beberapa Xdan memeriksa apakah a(X,[])tahan.

Python 2 , 73 71 byte

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

Cobalah online!

brainfuck, 50 byte

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

Diformat:

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

Mengharapkan string dari (dan )tanpa baris baru, dan output \x01untuk benar dan \x00salah. (Untuk keterbacaan, Anda dapat misalnya menambahkan 48 +detik sebelum final .untuk membuatnya dicetak 1dan 0sebagai gantinya.)

Cobalah online

Ini memelihara tumpukan dengan jumlah grup di setiap kedalaman, membedakan karakter berdasarkan paritas dan memeriksa apakah jumlah grup dalam {0, 2} setelah setiap kurung tutup; jika kondisi tidak terpenuhi, mengkonsumsi sisa input dan menetapkan bendera; kemudian periksa kembali kondisi di akhir program.

Jika kami diizinkan menghentikan aliran input dengan karakter aneh, kami dapat menghilangkan pemeriksaan akhir <[--[>->]]untuk menghemat 10 byte. (Jika\n bahkan tidak merepotkan, saya mungkin telah mengusulkan varian ini sebagai jawaban utama.)

(Kita juga bisa menyimpan beberapa byte dengan mengubah format output menjadi \x00true dan non- \x00for false, yang tampaknya diizinkan (mungkin secara tidak sengaja) oleh pernyataan masalah seperti yang tertulis, tetapi bagaimanapun itu tidak akan sangat menarik, dan saya lebih suka bukan untuk membuat perubahan itu.)

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)

Cobalah online!

f () mentransformasikan string menjadi tuple bersarang, yang diteruskan ke g ().

g () secara rekursif menavigasi tuple dan mengembalikan False jika elemen apa pun tidak memiliki 0 atau 2 anak.

Disimpan satu byte dengan menggunakan pemformatan string.

Stax , 13 11 byte

₧aaS▐îî»Å·╢

Jalankan dan debug itu

Saya menyimpan dua byte ketika saya menyadari input secara kebetulan bisa secara implisit disebut sebagai array literal. Dengan menghapus tanda kutip ganda, input disederhanakan.

Gagasan umum adalah untuk mengevaluasi input sebagai array literal, dan memetakan elemen secara rekursif untuk memeriksa keseimbangan parethesly. Jika pernyataan terakhir pernah gagal, maka akan ada pop berikutnya pada tumpukan kosong. Dalam keadaan stax, bermunculan dengan tumpukan kosong segera menghentikan program.

Dibongkar, tidak diserang, dan dikomentari, sepertinya ini.

        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

Jalankan yang ini

Java 10, 99 96 95 83 byte

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

Port jawaban 05AB1E saya (begitu juga kembali ()sebagai kebenaran dan apa pun sebagai falsey).

Cobalah online.

Penjelasan:

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;bisa return"()".equals(s);jika hasil boolean yang sebenarnya diperlukan.