大括弧のストリングを取り、そのストリングが完全に一致するかどうかを出力するプログラムまたは関数を作成する必要があります。プログラムは真実または偽の値を出力する必要があり、IOは任意の妥当な形式にすることができます。

ルールと定義：

• この課題のために、「括弧」は次の文字のいずれかです()[]{}<>。

• 次のように、開始ブラケットと終了ブラケットが正しい順序であり、その中に文字がない場合、一対のブラケットは「一致」とみなされます。

  ()
  []{}
  

  または、その中のすべてのサブ要素も一致する場合。

  [()()()()]
  {<[]>}
  (()())
  

  サブエレメントは、いくつかのレイヤーの深さにネストすることもできます。

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• 次の場合にのみ、文字列は「完全一致」と見なされます。

  1. すべての文字は角かっこです。

  2. ブラケットの各ペアには正しい開始ブラケットと終了ブラケットがあり、正しい順序であり、

  3. 各ブラケットが一致します。

• 入力には印刷可能なASCIIのみが含まれると想定できます。

テストIO

以下は、真の値を返す必要のある入力です。

()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]

そして、ここに偽の値を返すはずの出力があります：

(               Has no closing ')'
}{              Wrong order
(<)>            Each pair contains only half of a matched element
(()()foobar)    Contains invalid characters
[({}<>)>        The last bracket should be ']' instead of '>'
(((()))         Has 4 opening brackets, but only 3 closing brackets.

いつものように、これはコードゴルフなので、標準の抜け穴が適用され、バイト単位の最短回答が勝ちます。

05AB1E、19バイト

入力は引用符で囲みます。コード：

"[](){}<>"2÷)"":g2Q

がらくた、多くのバグと未実装の機能が見つかりました。説明：

"[](){}<>"           # Push this string
          2÷         # Split into pieces of two
            )        # Wrap it into an array (which should not be needed)
             ""      # Push an empty string
               :     # Infinite replacement

これは実際には難しい部分です。これが擬似コードでどのように見えるかは次のとおりです。

input().replace(['[]', '()', '{}', '<>'], "")

これは05AB1Eコードのこの部分でカバーされています：

if type(b) is list:
    temp_string = temp_string_2 = str(a)
    while True:
        for R in b:
            temp_string = temp_string.replace(R, c)
        if temp_string == temp_string_2:
            break
        else:
            temp_string_2 = temp_string
    stack.append(temp_string)

ご覧のとおり、これは無限の置換です（文字列が変更されなくなるまで行われます）。そのため、置換が既に組み込まれているため、置換をループに設定することを心配する必要はありません。その後：

                g    # Take the length of the final string
                 2Q  # Check if equal with 2 (which are the quotes at the end)

CP-1252エンコードを使用します。オンラインでお試しください！（上記のバージョンは非推奨であるため、少し変更されています）。

脳フラック、1101年、1085年、981のバイト

{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}

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

これは980バイトのソースコードであり+1、-aASCII入力を許可するフラグ（ただし、10進出力）

これは、私が非常に長い間書きたいと思っていた答えです。少なくとも6か月。私はこれを投稿するのを待っていました。なぜなら、この挑戦​​に答えることは頭脳の中で非常に難しいことだとわかっていたからです。しかし、1つの非常に重要な理由から価値があります。ソースコード自体は真実の入力であり、この言語自体の要点です。

そして、私がここで書いたように、この質問は私に頭脳を書くきっかけになりました。

「かっこは完全に一致していますか？」と書いた直後に、一致したかっこだけでどのくらいの情報を保存できるのかと思いました。私が際立っていたことの1つは、4つの「原子」しか持っていないということです。

(){}[]<>

これらの各ブラケットタイプは空であるか、基本的に異なる情報である他のブラケットが間にあるため、実際に伝達する情報は8ユニットです。そこで、一致した括弧のみを許可し、空の括弧が他の括弧を含む括弧とは異なる何かを伝える言語を記述することにしました。

この回答は、書くのにおよそ2時間かかりました。主にブラケットの種類ごとに多くのコードが繰り返されているため、ゴルフがかなり不十分だと認めます。しかし、特にBrain-Flakがそうであることを考えると、答えを書くことができたことにほとんど驚いています

使いにくいように設計されたシンプルなエソラン

後でゴルフをしようとするつもりですが、とにかくそこに行きたいと思いました。

詳細な説明はありますが、長さは約6000文字なので、この答えにすべてを貼り付けるのは賢明ではないと思います。必要に応じて、ここで一読できます。ここで簡単な説明を追加します。

基本的な考え方は、スタック上のすべてのキャラクターに対して次のステップを繰り返すということです。

• 各文字をチェックして、ブラケットに一致するかどうかを確認します。それが開始ブラケットである場合、次のマッピングに従って番号を他のスタックにプッシュします。

  ( = 1
  < = 2
  [ = 3
  { = 4
  

• 次に、閉じかっこに一致するかどうかを確認します。存在する場合は、括弧を開く場合と同様に、同等の番号を代替スタックにプッシュします。次に、上位2つの数値が等しいかどうかを確認します。存在する場合、両方がポップされ、プログラムは通常どおり続行されます。そうでない場合は、両方のスタックをクリアして（ループを停止する）、1つを代替スタックにプッシュします。これは基本的に「ブレーク」ステートメントです。

• 8つのブラケットタイプを確認した後、この実行の値をループにプッシュします。そのほとんどをゼロにするので、任意の値を持つスニペットは、かっこと比較するときの条件のみです。したがって、いずれかのブラケットが一致した場合、ループ全体の値は1になります。いずれも一致しなかった場合、ループ全体の値は0になります。この場合、両方のスタックをクリアし、代替スタックに0をプッシュします。繰り返しますが、これは「break」ステートメントのようなものです。

このメインループの実行後、残りは非常に簡単です。（空の）メインスタックにあり、代替スタックは空（ブラケットが一致した場合）であるか、そうでない場合は空ではありません。したがって、これを実行します。

#Toggle to the alternate stack
<>

#Push this stack-height onto main-stack
([]<>)

#Logical not
({}<(())>){((<{}{}>))}{}

これにより、0または1がメインスタックにプッシュされ、プログラムが終了すると暗黙的に印刷されます。

• 優れたスタッククリーンな「等しい」および「論理的ではない」スニペットを作成し、有用な例でgithub wikiを定期的に更新してくれた@WheatWizardに感謝します。

• このプログラムの作成に大いに役立ったオンライン整数メタゴルファを書いてくれた@ ASCII-onlyに感謝します。

改訂

• プッシュポップの冗長性を削除

• ゼロカウンターロジックを変更しました

脳フラック、204の 196 190バイト

{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})

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

Wheat Wizardのおかげで-8バイト。ジョー・キングのおかげで-6バイト。

説明

このプログラムは、現在のすべての閉じていない括弧の文字コードを2番目のスタックに保存します。ブラケットのペア<>、[]と{}それぞれがちょうど2で異なる文字コードを持っているので、特に彼らのためにチェックする必要はありません。ペア()は1だけ異なるので(、続行する前にそのバイトを具体的にチェックし、効果的にデクリメント（実際には1バイトおきにインクリメント）します。

# While there are bytes left to process
{

 # Move byte to second stack
 ({}<>)<>

 # Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
 ((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())

 ((

   # For each opening bracket type:
   {

    # Evaluate as zero
    <

     # Compute difference between bracket type and input byte
     ({}<>[({})])

    >

    # Evaluate loop iteration as -1 if equal, 0 otherwise
    [()]{()(<{}>)}{}<>

   }

   # Remove the 0 that was inserted to terminate that loop
   {}

   # Add 1 to result
   ()

   # Evaluate rest of this expression as zero
   <

    # Determine whether the byte is open parenthesis
    ({}<>[({})])

    # If not:
    {

     # Add 1 to byte and break if
     (<{}({}())>)

    }{}

    # Return to main stack
    <>

   >

 # Push result twice (0 if matched an opening bracket, 1 otherwise)
 ))

 # If byte was not an opening bracket:
 {

  # Push zero to break out of if
  (<

    # Push (open bracket + 2 - byte) below that zero
    ({}{}<>[{}]{}<>)

  >)

 }{}

 # If byte was neither an opening bracket nor the appropriate closing bracket:
 {

  # Clear alternate stack and stay there to break out of main loop early
  <>{{}}

 }{}

# End of main loop
}

# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket.  If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.

# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})

JavaScript（ES6）、52 50バイト

f=s=>(t=s.replace(/\(\)|\[]|{}|<>/,''))==s?!s:f(t)

結果が元の結果と同じになるまでブラケットを繰り返し削除し、文字列が空にならない限りfalseを返します。

編集：@ edc65のおかげで2バイト保存されました。

網膜、20バイト

+`\(\)|\[]|{}|<>

^$

オンラインで試す

CJam、25 24 23 21バイト

2バイトを節約してくれたSp3000に感謝します。
2バイトを節約してくれたjimmy23013に感謝します。

q_,{()<>}a`$2/*{/s}/!

テストスイート。

基本的に他の回答と同じように動作します：私たちは繰り返し取り外し()、[]、<>および{}文字列から、我々は空の文字列で終わるかどうかを確認。終了時に確認する必要を避けるために、ペアのN時間を削除します。ここNで、文字列の長さは常に十分です（終了しない限り、各反復で少なくとも2文字が削除されるため）。これがRetinaに勝るものではないことを嬉しく思います。:)（PythまたはJellyは...かもしれませんが）

ここには、楽しいゴルフトリックが1つあります。文字列()<>[]{}を取得するには、次のものを使用します。

{()<>}a`$

は、{()<>}単なるブロック（関数）であり、コードとして他の括弧を含みます。a私たちは、アレイ内のブロックを包みます。は`その配列を文字列化し、を与え"[{()<>}]"ます。最後に、を使用して文字列をソートします。$これにより、ブラケットがに再配置され()<>[]{}ます。

Python、67バイト

lambda s:eval("s"+".replace('%s','')"*4%([],(),{},'<>')*len(s))==''

次のような式を生成して評価します

s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')

結果が空かどうかを確認します。

Sp3000 [],(),{}は、Pythonオブジェクトであるため引用符なしでサブインでき、2つの括弧が不要であることを指摘することで8バイトを節約しました。

Yacc、119バイト

正規表現/置換を使用しません。

%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}

非ゴルフ

%%                              # Grammar in BNF
input:
  r;
r:
  %empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%%                              # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}

編集

yacc -o bracket.c bracket.y
cc -o bracket bracket.c

使用法

~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 %                                                                         :(

Pyth、31 25 24バイト

FryAmTheEggManが1バイトを削除したおかげで、25バイトになりました

VQ=:Q"<>|\[]|{}|\(\)"k;!

ここで試してみてください：テストスイート！

私はまだPythの初心者です。どんな助けでも大歓迎です。

説明

VQ                         For N in range(0, len(z)), with Q being the evaluated input.
                           Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
  =:Q"<>|\[]|{}|\(\)"k     assign Q without {}, [], <> nor () (regex replacement) to Q
                      ;    End of For loop
                       !   Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
                           This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise

ところで、他のPythの回答におめでとう（現在は20バイトです）

Pyth、20バイト

!uuscNTc"[](){}<>"2G

オンラインで試す：テストスイート

繰り返しの発生を取り除き[]、()、<>および{}分割および再マージで。結果の文字列が空かどうかを確認します。

Javascript ES6、54バイト

f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_

再帰的な置換実装を使用します。簡単です。

正規表現（PCREフレーバー）、41 37バイト

^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$

再帰的な正規表現を使用した標準ソリューションです。

4バイトを削ってくれてありがとうjimmy23013

Perl、34 33バイト

+2を含む -lp

STDINの入力で実行：

./brackets.pl <<< "{<>()}"

brackets.pl：

#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_

間に何もない最初のブラケットペアを検索し、存在する限り削除します。次に、最終文字列が空かどうかを確認します。

Brain-Flak、204バイト

(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})

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

Nitrodenの答えほど短くはありませんが、非常に異なるアプローチを使用します。これは、入力を繰り返し実行し、残りがなくなるまで、隣接するブラケットのペアを毎回削除します。その時点で、スタックに何か残っている場合、文字列は完全には一致しませんでした。

説明：

(())  Push 1 to simulate the check at the start of the loop
{  While check
	{}           Pop check
	{({}<>)<>}<> Reverse input
	({           Loop over input
		< Don't push the values of these calculations
		(<(({})<>)>)  Create a copy of the top of the input and push to the other stack
		(((((
		((([(())()()()]){}){}){}())
		(()))
		(((())()){}()){})
		){})          Push the differences in values of the end brackets 
		(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))  If the copy is the same as any of these, push the difference between the other bracket twice
		<>{}<>  Pop copy
		{  If this character is a start bracket
			{}({}[({})]<>({}))  Check if the next character is the end bracket
			{(<>)(<>)}{}          If not, push a 0 to each stack as buffer
			{}       Pop the top of the input stack, either the start bracket if they matched or the buffer 0
			(<>)     Push 0 to other stack to end check
		}{}>
		{}   Pop the top of the other stack
		         If the character was not an end bracket, pop the copy of check, which is 0
		         If it was, but didn't match the next character, pop the buffer 0
		         If the brackets matched, pop the end bracket and add it to the loop total
	<>}	Repeat with the rest of the input
	<>)	Push the loop total
		If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1

Brainfuck、132バイト

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

フォーマット済み：

+>,
[
  [<-> >+>[-]<<-]
  <
  [
    not matching closing bracket
    >+>[<+<+>> >+<-]
    +++++[>--------<-]
    >
    [
      not open paren
      <<+>
      ++++[>-----<-]>
      [
        not open angle bracket
        <+++++[>------<-]>-
        [
          not open square bracket
          <++++[>--------<-]>
          [
            not open brace
            ,>
          ]
        ]
      ]
    ]
    <
  ]
  ,
]
<<[>]
>.

末尾の改行なしで入力を期待します。プリント\x00偽のためと\x01真のために。

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

アプローチ：で始まるスタックを維持し、開始\x01ブラケットが検出されるたびに対応する終了ブラケットを押します。現在の文字が開き括弧であるかどうかを確認する前に、最初にスタックの一番上にある閉じ括弧と等しいかどうかを確認し、等しい場合はポップします。適切な閉じ括弧でも開始括弧でもない場合は、ポインターを右に移動しながら残りの入力を消費します。最後に、ポインターがinitialの隣にあるかどうかを確認します\x01。

Grime v0.1、34バイト

M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M

1一致する場合と一致0しない場合に印刷します。 オンラインでお試しください！

説明

グライムは、この課題のために設計された私の2Dパターンマッチング言語です。また、1D文字列の照合にも使用できます。これが私の最初の答えです。今日はGrimeを変更しましたが、1つの構文要素の文字（の`代わりに,）を変更するだけなので、スコアには影響しません。

M=                         Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\>      a smaller M inside matched brackets,
|MM                          or two smaller Ms concatenated,
|_                           or the empty pattern.
e`M                        Match the entire input against M.

Reng v.3.3、137バイト、非競合

ここで試してみてください！

aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2<       <       <     +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
   \$2+)1z+#z/   ~n1/

もう少しゴルフをする必要がありますが、少なくともうまくいきます。ðこれをリモートで/簡単に行えるように、このチャレンジの後にスタックを追跡するコマンドを追加しました。これについては少し説明しますが、通常は繰り返し処理されるすべての文字列を追跡し、繰り返しを探します。繰り返しがある場合、文字列は既約です。それ以外の場合、文字列は空の文字列/スタックに縮小され、出力されます1。それ以外の場合、出力は生成されません。

PowerShell v2 +、63 62バイト

param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a

JavaScriptを完全にキャッチすることはできませんが、現在、他の非esolangを削除しています。

他の回答と同様のアプローチ：限り、我々はのいずれかを削除することができますように継続単純なループ[]、()または<>（私たちは正規表現スペシャルをエスケープする必要があるため、いくつかの余分な文字で）。$b途中でヘルパーとして使用して、以前のループの$a設定を記憶します。初期化されていない変数は$nullですので、最初にループに遭遇したとき$aは明らかにに等しくありません$null。

ループの終わりでは、$aは空またはそうではなく、その文字列のブール否定はまたはのいずれTrueかFalseです。

例

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False

C、121 122 114バイト

@xsotのおかげで8バイト削りました！

a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}

スタックを使用します。

Java 7、156 151バイト

class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}

私はこれが賞を獲得することを期待していませんが、Javaの答えはまだ見ていません。さらに、PPCGの周りに潜むのが好きで、他の答えに投票/コメントできることを楽しみにしています。

入力はプログラムパラメータとして与えられます。これは、ループで正規表現の置換を行うという点で、他の多くの回答と同じ形式に従います。もともと私はそれをN回ループさせました。ここで、Nは元の文字列の長さですが、ループInteger.MAX_VALUEは短くなります：]。Java Integer.MAX_VALUEのaの最大長であるため、これは問題ないはずです。そのためString、入力の長さはJavaで処理可能なものであるという暗黙の仮定があります。ループのため、ランタイムはかなり悪いです（lapippoで約20分かかりました）が、制限はありませんでした。

Haskell、151バイト

infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0

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

Python 2.7、96バイト

def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])

Python 2、80バイト

def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s

ジュリア、51バイト

~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n

いくつかのオプションの中で最も正気でない。当然のことながら、正規表現の力を活用することが文字列照合への最短パスですが、これは実際に照合するパターンが規則的な場合にのみ適用されます。PCRE再帰パターンを実行しようとすると、文字列全体が一致するかどうかを確認するか、両端を固定してから正規表現再帰の内部本体を指定する構造を作成することにより、コードのサイズが大きくなります。どちらもきれいでもなく、ゴルフをコード化するのにも役立ちません。

説明：

~z=                            # Define ~z to be the following:
    z==(                       # If z is equal to                                     
        n=replace(z,           # z with the replacement of 
            r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
            ""                 # with empty strings
        )                      # (which is assigned to n)
    )?z==""                    # whether z is an empty string
    :~n                        # else ~ applied to the substituted string

この関数は、唯一の引数から隣接する括弧のペアを繰り返し削除し、この方法で空の文字列を導出できる場合はtrueを返します。

sed、39 36バイト（コードの場合は34、-rの場合は2）

:a
s/\(\)|\[]|<>|\{}//;ta
/./c0
c1

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

標準的なアプローチと思われるもののsedバージョン。拡張正規表現が必要（sed -r）

Cows quackのおかげで3バイト節約

05AB1E、9バイト

žu2ôõ:g2Q

入力は引用符で囲みます。

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

説明：

žu          # Push "()<>[]{}"
  2ô        # Split into pieces of size 2
    õ       # Push empty string
            # Implicit input
      :     # Infinite replacement
       g2Q  # Is length equal to 2?
            # Implicit print

Clojure、153バイト

CやBrainfuckの回答よりも長い：o

(defn f[[s & r]](if s(let[[a b](split-at(.indexOf(reductions + 1(for[c r](get(zipmap[s({\(\)\[\]\{\}\<\>}s)][1 -1])c 0)))0)r)](and(not=()a)(f(butlast a))(f b))))1)

正規表現を使用せず、代わりに最初の文字を使用して終了タグが何であるかを判断し、その括弧のバランスがとられている最初のインデックスを見つけます（累積合計はゼロです）。次に、括弧内および括弧の後が有効かどうかを繰り返しチェックします。

より良いアプローチがあるかどうかを参照してください...

Lua、295バイト

f = false g = string.gsub t=table s={}b=io.read()for c in b:gmatch('.')do if c:find("[%[<{%(]")then s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")")elseif c:find("[%]>}%)]")then if t.remove(s)~=c then print(f)return end else print(f)return end end if#s>0 then print(f)else print(1)end

非ゴルフバージョン

f = false
g = string.gsub
t=table
s={} --Define a stack of opening brackets
b=io.read() --get the input
for c in b:gmatch('.') do   --for every character
    if c:find("[%[<{%(]") then
        s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")") --if the current character is an opening bracket, push the closing bracket onto the stack
    elseif c:find("[%]>}%)]") then
        if t.remove(s)~=c then
            print(f) --if the character is a closing bracket, pop the closing bracket off the stack and test if they match, if not print false
            return
        end
    else 
        print(f) --if the character is not a bracket print false
        return
    end
end
if #s>0 then
    print(f) --if there are still brackets on the stack print false
else
    print(1) --print 1 there are no brackets on the stack
end

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

Japt v2.0a0、16 -!バイト

e/\[]|<>|\(\)|{}

それを試してみてください

R、298

function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}

ここでのアプローチは、シーケンスをRコードに変換し、解析して評価することです。エラーが発生した場合、を返しFALSEます。

しかし、小さな問題があります...括弧に関するRの規則は異なるため<、>まったく括弧ではなく、他のタイプには独自の規則があります。これは、革新的なアプローチ-頭と尻尾が異なる方法でキーキーを鳴らした場合にエラーを通知する機能のみを持つキーキー機能によって解決されます。

たとえば、[]はに変換されS('[', {}, ']')、Sは...

S=function(H,B,T)if(H!=T)stop() 

ヘッドキーキーとテールキーキーが一致するため、エラーはスローされません。

他のいくつかの例（左の部分は括弧のシーケンスで、右の部分は評価可能な有効なRコードへの変換です）：

[}     -->  S('[', {}, '}')     # squeaks an error
[()]   -->  S('[', {S('(',{},'(')}, "[")
({[]}) -->  S('(',{S('{',{S('[',{},'[');},'{');},'(');

括弧の他のいくつかのシーケンスは、解析エラーになります。

[[)    -->   S('[',{S('[',{},'('); 

したがって、残りの部分はエラーをキャッチし、エラーがある場合はFALSEを返し、エラーがない場合はTRUEを返します。

人間が読めるコード：

 sqk <- function(.){
   s=strsplit;u=paste0
   .=s(.,"")[[1]]            # break the argument up into 1-character pieces
   p=s("><)(}{][","")[[1]]   # vector of brackets
   .[!.%in%p]="§"            # replace anything besides brackets by § (--> error)
   for(i in 1:4*2){     
     .[.==p[i]]=sprintf("S('%s',{",p[i])    # '<' -->   S('<',{     ... etc
     .[.==p[i-1]]=sprintf("},'%s');",p[i])  # '>' -->   },'<');     ... etc  
   }
   S=function(H,B,T)if(H!=T)stop()          # define the working horse
   r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
   if(inherits(r,"try-error"))FALSE else TRUE   # any errors?
   }

サンプルケースに適用する：

truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
                      ()                 [](){}<>                 (((()))) 
                    TRUE                     TRUE                     TRUE 
                ({[<>]})             [{()<>()}[]] [([]{})<{[()<()>]}()>{}] 
                    TRUE                     TRUE                     TRUE 
> sapply(falsy,sqk)
           (            }        (<2)> (()()foobar)     [({}<>)>      (((())) 
       FALSE        FALSE        FALSE        FALSE        FALSE        FALSE