私たちは、呼び出し括弧のグループをオープン括弧(のマッチングの近くの括弧、)およびその中のすべて。

括弧グループまたは文字列は、括弧付きバランスと呼ばれます何も含まないか、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つの括弧グループのみを含む。それ以外には何も含めるべきではありません。

仕事：

あなたの仕事は、与えられた文字列が括弧で囲まれたものであるかどうかをチェックする関数またはプログラムを書くことです。

入力：

入力は、文字列または文字のリスト、または同様のものになります。あなたは、文字列は文字のみで構成されることを想定することができ'('、および')'。また、開いている各括弧(には対応する近い括弧があると仮定することができます)ので、"((("or ")("や"(())("... などの文字列を心配しないでください。

^{注： @DigitalTraumaのコメントの下で述べたように、()コンボを他の文字（など<>、[]それはいくつかの言語でエスケープのような追加作業を引き起こしている場合、...、）}

出力：

文字列が括弧で囲まれているかどうかを示すもの（trueまたはfalse、1または0、...）。あなたの関数/プログラムがもたらすと期待されるものをあなたの答えに含めてください。

例：

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

^{最後の2つの例は本当に違いをもたらしました！}

幸運を祈ります！

Japt v2、20バイト

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

オンラインでテストしてください！

誰もが最初はチャレンジを誤解していましたが、括弧の各ペアには偶数を含める必要がありました実際にはチャレンジが実際に0または2を要求するとき、つの。そこで、以前と同じ手法を使用して、修正した回答を示します。

それでも、再帰的な置換で課題を解決できます。問題は、のすべてのオカレンスを単に削除するの()()ではなく、同じラッパーに他に何もないことを確認する必要があります()()（つまり、no ()()()()またはそのようなもの）。再帰的に置き換えることでこれを行うことができます(()())し()。

新しい問題は、入力自体に1組の外側括弧がないため（括弧で囲まれた文字列ではないため）、完全に削減するために余分なペアでラップする必要があることです。最後に、バランスの取れた文字列の最終結果()は空の文字列ではなく、出力の論理否定を取得するのではなく、等価性をチェックします。

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バイト保存されました。説明：単なる再帰的な正規表現です。外側のキャプチャグループは、バランスの取れた文字列を表し、<その後にオプションのバランスの取れた文字列が続き>、が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だけに期待されている含まれている(と)。文字列が「バランスの取れた」場合はC（キャリー）フラグをクリアし、そうでない場合は設定します（6502の典型的なイディオムで、キャリーを「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

Hexdump：

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の回答と、ブラケットを2進数として表示するアイデアに対する@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 Core）、78 71バイト

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

オンラインでお試しください！

Haskell、82 59バイト

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

オンラインでお試しください！

ハスケルでの初めてのゴルフなので、さらにゴルフができると思うので、トリックやコメントは大歓迎です。

編集-23バイトを保存してくれた@nimiに感謝します（元の提出の28％以上:)

JavaScript（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の回答のように）再帰的な置換の使用は大幅に短縮されます。

入力を文字列として受け取ります。括弧で調整された場合は1、括弧で調整されていない場合は0を返します。

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

オンラインでお試しください！

再帰的、46バイト

これは、括弧のバランスが取れていない場合に再帰エラーをスローします。

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

オンラインでお試しください！

Perl 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
    /
}

R、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 ')-('

次に、結果の式を評価します。ゼロに等しい場合はバランスが取れ、そうでない場合はバランスが取れません。の使用はsum、空の文字列のケースを処理するためにのみ必要です。なぜなら、その評価はNULLです。

例えば

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

Wolfram言語（Mathematica）、65バイト

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

オンラインでお試しください！

05AB1E、18 16 13 バイト

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

港@ETHproductionsのJAPTの答えは、テストケースを修正します()(()()(()())(()()))。@Adnanの
おかげで-2バイト。

OPのこのコメントに基づいて、私は今()、真理値として使用し、その他は偽として使用します。両方の値を1つだけでなく一貫させる必要がある場合、代わりに古い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]).。ます。

最初の3行は、PrologのDefinite Clause Grammar構文の有効な文字列の文法です。when が文法に続き、空のリストである場合を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- \x00for falseに変更することで、バイトを節約することもできます。これは、書かれた問題文によって（誤って）許可されているようですが、とにかくあまり面白くありません。その変更を行わないでください。）

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バイトを保存しました。

スタックス、13 11 バイト

₧aaS▐îî»Å·╢

実行してデバッグする

入力が偶然に配列リテラルとして暗黙的に評価されることに気付いたとき、2バイトを節約しました。二重引用符を削除すると、入力が簡素化されます。

一般的な考え方は、入力を配列リテラルとして評価し、要素を再帰的にマッピングして、バランスの取れたバランスをチェックすることです。最終的なアサーションが失敗すると、空のスタックで後続のポップが発生します。スタックスでは、空のスタックでポップすると、プログラムがすぐに終了します。

開梱されていない、コメントされていない、これはこのように見えます。

        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

これを実行する

Java 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);、実際のboolean型の結果が必要な場合。