Bir parens grubuna açık paren (, buna uygun yakın paren )ve içindeki her şeyi diyoruz .

Bir parens grubu veya dizesi, hiçbir şey içermiyorsa veya yalnızca 2 parantez içinde dengelenmiş parens grubu içeriyorsa parantez içinde denir .

Örneğin:

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.

Aynı şekilde:

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.

Bu nedenle, parantez içinde dengeli bir dize veya parens grubu şunlardan birini yapmalıdır:

• Hiçbir şey içermez.
• Veya sadece ve tam olarak 2 parantez içinde dengelenmiş ebeveyn grubu içerir. Başka bir şey içermemelidir.

Görev:

Göreviniz, belirli bir dizenin parantez içinde dengelenmiş bir işlev olup olmadığını kontrol eden bir işlev veya program yazmaktır.

Giriş:

Giriş, bir dize veya karakter listesi veya benzer bir şey olacaktır. Sen dize sadece karakterlerden oluşacak varsayabiliriz '('ve ')'. Ayrıca her aç parantez varsayabiliriz (onun eşleşen yakın paren olacak )şöyle dizeleri hakkında endişe yok, "((("ya ")("ya "(())("...

^{Not: As onun comment Körükteki @DigitalTrauma bahsettiği, bu saydırmak için ok ()(gibi diğer karakterler tarafından açılan <>, []bazı dillerde kaçan gibi ek işleri neden ise, ...)}

Çıktı:

Dizenin parantez içinde dengeli olup olmadığını gösteren herhangi bir şey (doğru veya yanlış, 1 veya 0, ...). Lütfen cevabınıza fonksiyonunuzun / programınızın ne vermesi beklediğinizi ekleyin.

Örnekler:

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

^{Son iki örnek gerçekten bir fark yarattı!}

İyi şanslar!

Japt v2, 20 bayt

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

Çevrimiçi test edin!

Herkes ilk başta ve parantez her çifti bir içermek zorunda olsa meydan yanlış bile aslında zorluk aslında sorduğunda, alt çiftlerinin sayısını 0 veya 2 alt çiftleri. İşte daha önce olduğu gibi aynı tekniği kullanarak gözden geçirilmiş cevabım.

Sorunu yine de yinelemeli değiştirme ile çözebiliriz. Mesele şu ki, sadece tüm oluşumlarını kaldırmak yerine ()(), aynı paketleyicide ()()(başka bir deyişle, hayır ()()()()veya böyle bir şey) dışında başka bir şey olmadığından emin olmalıyız . Biz yinelemeli değiştirerek bunu yapabilirsiniz (()())ile ().

Yeni sorun, girdinin kendisinin bir çift dış parantez içermemesidir (parantez içinde dengeli bir dize olmayacaktır), bizi tamamen azaltmak için ekstra bir çifti sarmaya zorlar. Son olarak, dengeli dizgiler için sonuç artık ()boş dizge yerine, bu yüzden çıktının mantıksal DEĞİL değerini almak yerine eşitliği kontrol ediyoruz.

sed 4.2.2, 30

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

Çevrimiçi deneyin .

Bu, True için 1 ve False için 0 kabuk çıkış kodunu döndürür.

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

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir. Düzenleme: @JoKing sayesinde 2 bayt kaydedildi. Açıklama: Sadece özyinelemeli bir normal ifade. Dış yakalama grubu dengeli bir ipi ve <bunu takiben isteğe bağlı dengeli ipi ve ardından >iki kez temsil eder. Diğer yanıtların çoğunun ()s kullanabildiğini unutmayın, ancak bu fazladan iki bayttır:

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

Çevrimiçi deneyin! Bağlantı, test senaryolarını içerir.

6502 makine kodu rutini, 48 bayt

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

Yalnızca içerdiği ve içinde olması beklenen $fb/ dizesine bir işaretçi bekler$fc() . Eğer dize "parantez içinde dengelenir" ise C (Carry) bayrağını temizler, aksi takdirde ayarlar (6502'de tipik bir deyimdir, "hatada" taşıma kümesini ayarlar). Geçersiz girişte mantıklı bir şey yok.

Algoritma özyinelemeli olmasına rağmen, kendisini çağırmaz (daha fazla bayta ihtiyaç duyar ve kod konumunu bağımlı hale getirir), bunun yerine özyineleme derinliğini korur ve "basit" dallanma kullanır.

Yorumlanan sökme

; 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

Rutini kullanan örnek C64 montaj programı:

Çevrimiçi demo

Ca65 sözdizimindeki kod :

.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 bayt

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

Çevrimiçi deneyin! veya Tüm test senaryolarını doğrulayın!

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

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

açıklama

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

Çevrimiçi deneyin!

MATL , 26 25 bayt

oo~`tnw52B5LZttnb<]XB10X-

Çevrimiçi deneyin!

@ETHProductions'ın "replace (() ()) ile ()" fikrine cevabı ve @JungHwan Min'in köşeli parantezleri ikili basamak olarak görme fikri için yaptığı yorum sayesinde.

Çıktı doğruluk için boş bir dizidir, falsey için pozitif bir sayıdır - bence OP'nin yorumuna izin verilir: "Kategoriler olabilir. Yani doğruluk değerlerini doğrulamak için doğru değerler ve aksi halde sinyal vermek için yanlış değerler." Değilse n, sonuna +1 bayt ekleyebilir , 0 doğru çıktı ve 1 falsey çıktısı alabiliriz.

Yorumlarla:

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 bayt

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

Çevrimiçi deneyin!

Haskell , 82 59 bayt

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

Çevrimiçi deneyin!

Haskell'de ilk kez golf oynadığım için çok daha fazla golf oynayabileceğini varsayıyorum, bu yüzden herhangi bir hile veya yorum hoş geldiniz.

EDIT - 23 bayt kaydettiğiniz için @nimi teşekkürler (orijinal gönderim% 28'den fazla :)

JavaScript (ES6), 63 bayt

Girişi bir karakter dizisi olarak alır. Parantez içinde dengeli için false değerini , parantez içinde dengeli değil için true değerini döndürür .

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

Çevrimiçi deneyin!

Yorumlananlar

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

Özyinelemeli, 54 bayt

Bununla birlikte ( ETHproductions 'Japt cevabında olduğu gibi) tekrarlayan yedeklerin kullanılması önemli ölçüde daha kısadır.

Girişi dize olarak alır. Parantez içinde dengeli için 1 , parantez içinde değil için 0 döndürür .

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

Çevrimiçi deneyin!

Özyinelemeli, 46 bayt

Bu parantez içinde dengelenmemiş bir özyineleme hatası atar:

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

Çevrimiçi deneyin!

Perl 6 ,  43 41  37 bayt

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

Dene

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

Dene

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

Dene

Expanded:

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

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

Çevrimiçi deneyin!

• @ETHproductions özyinelemeli Japt çözümünün taşınması
• @JayCe sayesinde -2 bayt

Başka - daha uzun - çözüm ama farklı yaklaşım için ilginç

R , 85 bayt

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

Çevrimiçi deneyin!

Açıklama:

Giriş dizesini alın ve onun yerini alır:

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

sonra ortaya çıkan ifadeyi değerlendirir. Sıfıra eşitse dengelenir, aksi halde eşit değildir. Kullanımı sumyalnızca boş dize durumunu işlemek için gereklidir, çünkü değerlendirmesi geri dönerNULL .

Örneğin

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

Wolfram Dili (Mathematica) , 65 bayt

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

Çevrimiçi deneyin!

05AB1E , 18 16 13 bayt

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

Port @ETHproductions 'ın Japt cevap test durumu düzeltmek için ()(()()(()())(()())). @Adnan
sayesinde -2 bayt .

OP'nin bu yorumuna dayanarak artık ()doğruluk değeri ve falsey olarak başka bir şey kullanıyorum. Her iki değerin de tek bir değer yerine tutarlı olması gerekiyorsa, bunun yerine eski 16 bayt yanıtı ( …(ÿ)…(()∞„()©:®Q) 0doğruluk ve falsey 1test senaryoları için geri döner .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

açıklama

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

(Test durumu için başarısız olan eski 18 baytlık cevap ()(()()(()())(()()))..):

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

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

APL (Dyalog Klasik) , 27 bayt

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

Çevrimiçi deneyin!

Prolog , 46 bayt

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

Çevrimiçi deneyin! veya Tüm test senaryolarını doğrulayın!

Kullanımları listeleri lve rmesela girdi olarak "()()"olarak test edilmiştir f([l,r,l,r])..

İlk üç satır, Prolog'un Kesin Cümlesi Dilbilgisi sözdizimindeki geçerli dizelerin dilbilgisidir . dilbilgisini izleyen ve boş bir liste olduğunda a(A,B).döner . Böylece ana işlev biraz alır ve bekletip beklemediğini kontrol eder .trueABfXa(X,[])

Python 2 , 73 71 bayt

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

Çevrimiçi deneyin!

brainfuck, 50 bayt

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

biçimlendirilmiş:

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

Sondaki satırsonu olan (ve )olmayan bir dize bekler ve \x01doğru ve \x00yanlış için çıktılar . (Okunabilirliği için, örneğin 48 ekleyebilirsiniz +nihai önce s .o yazdırmak yapmak 1ve 0onun yerine.)

Çevrimiçi deneyin

Bu, karakterleri pariteye göre ayırarak ve grup sayısının her yakın parantezden sonra {0, 2} içinde olup olmadığını kontrol ederek her derinlikte grup sayısı olan bir yığını tutar; koşul karşılanmazsa, girdinin geri kalanını tüketir ve bir bayrak ayarlar; ardından programın sonunda durumu tekrar kontrol eder.

Giriş akışını tek bir karakterle sonlandırmamıza izin verilirse, <[--[>->]]10 bayt kaydetmek için son kontrolü atlayabiliriz . (Eğer\n Rahatsız edici olmasa bile, bu varyantı ana cevap olarak önerebilirdim.)

(Çıktı biçimini \x00doğru ve \x00yanlış için yanlış olarak değiştirerek de bazı baytlar kaydedebiliriz , bu sorun bildirimi tarafından yazıldığı gibi (belki de yanlışlıkla) izin verilmiş gibi görünüyor, ancak yine de çok ilginç olmaz ve tercih ederim bu değişikliği yapmamak.)

Python2, 95 94 bayt

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

Çevrimiçi deneyin!

f (), dizeyi g () 'ye ileten iç içe geçmiş bir tuple dönüştürür.

g (), tekrar tekrar tuple içinde dolaşır ve herhangi bir öğenin tam olarak 0 veya 2 alt öğesi yoksa False değerini döndürür.

Dize biçimlendirme kullanılarak bir bayt kaydedildi.

Stax , 13 11 bayt

₧aaS▐îî»Å·╢

Çalıştır ve hata ayıkla

Girişlerin tesadüfen örtülü olarak dizi değişmezleri olabileceğini fark ettiğimde iki bayt kazandım. Çift tırnak işaretleri kaldırıldığında, giriş basitleştirilir.

Genel fikir, girdiyi bir dizi değişmez değeri olarak değerlendirmek ve parethesly dengesini kontrol etmek için öğeleri özyinelemeli olarak eşlemektir. Son iddia başarısız olursa, boş bir yığın üzerinde müteakip bir pop olacaktır. Stax'ta, boş yığınlarla patlamak programı hemen sonlandırır.

Ambalajından çıkarılmış, golf edilmemiş ve yorum yapılmış gibi görünüyor.

        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

Bunu çalıştır

Java 10, 99 96 95 83 bayt

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

Benim Limanı 05AB1E cevap (şimdiye da döner ()truthy ve Falsey olarak başka bir şey gibi).

Çevrimiçi deneyin.

Açıklama:

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;olabilir return"()".equals(s);gerçek bir boole sonucu gerekli eğer.