^{ここからもここからも挑戦}

n個の括弧配列は、から成り、N (、S及びN ) S。

有効な括弧シーケンスは、次のように定義されています。

隣接する括弧「（）」が空になるまで繰り返し消去する方法を見つけることができます。

たとえば、(())は有効な括弧であり、2番目と3番目の位置のペアを消去して()それをにしてから、空にすることができます。 )()(は有効な括弧ではありません。2番目と3番目の位置のペアを消去すると、ペアになり、それ)(以上消去できなくなります

仕事

番号nを指定すると、辞書式順序ですべての正しい括弧シーケンスを生成する必要があります

出力は、配列、リスト、または文字列（この場合は行ごとのシーケンス）です。

あなたは括弧などの異なるペアを使用することができ{}、[]、()または任意の開閉サイン

例

• n = 3

  ((()))    
  (()())    
  (())()    
  ()(())    
  ()()()
  

• n = 2

  (())
  ()()
  

Perl 6、36バイト

{grep {try !.EVAL},[X~] <[ ]>xx$_*2}

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

字句的にソートされたのすべての組み合わせを見つけ、それを正しくフィルタリングします。すべての有効な組み合わせ（のようなものも含む）は（誤った結果ですが、戻り値と区別するために（）と評価されます）$2n$ []EVAL[][][]not!tryNil

説明：

{                                  }  # Anonymous code block
                        <[ ]>         # Create a list of ("[", "]")
                             xx$_*2   # Duplicate this 2n times
                   [X~]               # Find all possible combinations
 grep {          },                   # Filter from these
            .EVAL                     # The EVAL'd strings
       try !                          # That do not throw an error

R、112 107 99バイト

非再帰的なアプローチ。「<」と「>」を使用するのは、正規表現でエスケープ文字を回避するためです。ASCII範囲のより短い仕様を使用できるようにするために、expand.grid（ASCIIコード60、61、62 を使用して）「<」、「=」、「>」の3 ^ 2n 2n文字の文字列を生成し、次にgrepを実行します。開き括弧と閉じ括弧のバランスが取れている組み合わせを確認してください。もちろん、「=」の可能性は無視されます。

経由http://rachbelaid.com/recursive-regular-experession/

function(n)sort(grep("^(<(?1)*>)(?1)*$",apply(expand.grid(rep(list(60:62),2*n)),1,intToUtf8),,T,T))

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

説明

"^(<(?1)*>)(?1)*$" = regex for balanced <> with no other characters
^ # match a start of the string
  ( # start of expression 1
    < # open <>
       (?1)* # optional repeat of any number of expression 1 (recursive)
  # allows match for parentheses like (()()())(()) where ?1 is (\\((?1)*\\))
    > # close <>
  ) # end of expression 1
  (?1)* # optional repeat of any number of expression 1
$ # end of string

function(n)
  sort(
    grep("^(<(?1)*>)(?1)*$", # search for regular expression matching open and close brackets
      apply(
        expand.grid(rep(list(60:62),2*n)) # generate 3^(2n) 60,61,62 combinations
      ,1,intToUtf8) # turn into all 3^(2n) combinations of "<","=",">"
    ,,T,T) # return the values that match the regex, so "=" gets ignored
  ) # sort them

R、107バイト

通常の再帰的アプローチ。

-1ありがとう@Giuseppe

f=function(n,x=0:1)`if`(n,sort(unique(unlist(Map(f,n-1,lapply(seq(x),append,x=x,v=0:1))))),intToUtf8(x+40))

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

C（gcc）、114バイト

f(n,x,s,a,i){char b[99]={};n*=2;for(x=1<<n;x--;s|a<0||puts(b))for(s=a=i=0;i<n;)a|=s+=2*(b[n-i]=41-(x>>i++&1))-81;}

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

n <= 15で機能するはずです。

説明

f(n,x,s,a,i){
  char b[99]={};   // Output buffer initialized with zeros.
  n*=2;            // Double n.
  for(x=1<<n;x--;  // Loop from x=2**n-1 to 0, x is a bit field
                   // where 1 represents '(' and 0 represents ')'.
                   // This guarantees lexicographical order.
      s|a<0||puts(b))  // Print buffer if s==0 (as many opening as
                       // closing parens) and a>=0 (number of open
                       // parens never drops below zero).
    for(s=a=i=0;i<n;)  // Loop from i=0 to n-1, note that we're
                       // traversing the bit field right-to-left.
      a|=              // a is the or-sum of all intermediate sums,
                       // it becomes negative whenever an intermediate
                       // sum is negative.
        s+=            // s is the number of closing parens minus the
                       // number of opening parens.
                        x>>i++&1   // Isolate current bit and inc i.
                    41-(        )  // ASCII code of paren, a one bit
                                   // yields 40 '(', a zero bit 41 ')'.
             b[n-i]=               // Store ASCII code in buffer.
          2*(                    )-81;  // 1 for ')' and -1 for '(' since
                                        // we're going right-to-left.
}

パイソン2、91の 88 84 81バイト

f=lambda n:n and sorted({a[:i]+'()'+a[i:]for a in f(n-1)for i in range(n)})or['']

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

_{pizzapants184のおかげで-3バイト}

05AB1E、13 バイト

„()©s·ãʒ®õ:õQ

オンラインそれを試してみてくださいまたはいくつかのより多くのテストケースを検証します。

説明：

„()            # Push string "()"
   ©           # Store it in the register without popping
    s·         # Swap to get the (implicit) input, and double it
      ã        # Cartesian product that many times
       ʒ       # Filter it by:
        ®      #  Push the "()" from the register
         õ:    #  Infinite replacement with an empty string
           õQ  #  And only keep those which are empty after the infinite replacement

Ruby、70バイト

f=->n{n<1?['']:(0...n).flat_map{|w|f[n-1].map{|x|x.insert w,'()'}}|[]}

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

Japt、15 13バイト

ç>i<)á Ôke/<>

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

説明

ç                 :Input times repeat the following string
 >i<              :  ">" prepended with "<"
    )             :End repeat
     á            :Get unique permutations
       Ô          :Reverse
        k         :Remove any that return true (non-empty string)
         e/<>     :  Recursively replace Regex /<>/

K（ngn / k）、36 35バイト

{"()"(&/-1<+\1-2*)#(x=+/)#+!2|&2*x}

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

+!2|&2*x 長さ2 * nのすべてのバイナリベクトル

(x=+/)# 合計がnになるもののみ

(&/-1<+\1-2*)# 0/1を1 / -1として扱い、部分和がどこにも負でないもののみ

"()" この文字列のインデックスとして0/1を使用します

Perl 5の -n、41の 39バイト

山括弧を含む-2バイト

s/<(?R)*>//gr||say for glob'{<,>}'x2x$_

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

私のPerl 6回答の移植。

Perl 6、42バイト

{grep {!S:g/\(<~~>*\)//},[X~] <( )>xx$_*2}

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

再帰正規表現を使用します。代替の代替：S/[\(<~~>\)]*//

オープン/クローズシンボルとして0および1を含む38バイト：

{grep {!S:g/0<~~>*1//},[X~] ^2 xx$_*2}

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

説明

{                                        }  # Anonymous block
                              <( )>         # List "(", ")"
                                   xx$_*2   # repeated 2n times
                         [X~]  # Cartesian product with string concat
                               # yields all strings of length 2n
                               # consisting of ( and )
 grep {                },  # Filter strings
        S:g/             # Globally replace regex match
            \(           #   literal (
              <~~>       #   whole regex matched recursively
                  *      #   zero or more times
                   \)    #   literal )
                     //  # with empty string
       !                 # Is empty string?

Retina 0.8.2、50バイト

.+
$*
1
11
+%1`1
<$'¶$`>
Gm`^(?<-1>(<)*>)*$(?(1).)

オンラインでお試しください！<>sを使用します。説明：

.+
$*

単項に変換します。

1
11

結果を2倍にします。

+%1`1
<$'¶$`>

2²ⁿ2nビットの2進数をすべて列挙し、数字をにマッピングします<>。

Gm`^(?<-1>(<)*>)*$(?(1).)

バランスの取れたシーケンスのみを保持します。これは、@ MartinEnderが発見したバランスのとれた括弧のトリックを使用しています。

JavaScript（ES6）、112 102バイト

これは、nwellnhofのC回答に大きく基づいています。

f=(n,i)=>i>>2*n?'':(g=(o,k)=>o[2*n]?s|m<0?'':o:g('()'[m|=s+=k&1||-1,k&1]+o,k/2))(`
`,i,m=s=0)+f(n,-~i)

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

赤、214、184 136バイト

func[n][g: func[b n][either n = length? b[if not error? try[load b][print b]return 0][g append copy b"["n g append copy b"]"n]]g""2 * n]

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

ジョーキングのアプローチを使用します。再帰を使用してブラケットのすべての可能な配置を検索し（それらは辞書式順序で生成されます）、配置が有効なブロックとして評価された場合に出力します。

ゼリー、19バイト

Ø+xŒ!QÄAƑ>ṪƊ$Ƈ=1ịØ(

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

TIOを介して明確化された出力。