^{Mücadelesi Alındığı burada ve ayrıca burada}

Bir n parantez dizisi n ( s ve n ) s'den oluşur .

Geçerli bir parantez dizisi aşağıdaki gibi tanımlanır:

Bitişik parantez çiftini (") boş olana kadar tekrarlamanın bir yolunu bulabilirsiniz.

Örneğin, (())geçerli bir parantezdir, 2. ve 3. konumdaki çifti silebilirsiniz ve olur (), sonra boş bırakabilirsiniz. )()(geçerli bir parantez değil, 2. ve 3. konumdaki çifti sildikten sonra, olur )(ve daha fazla silemezsiniz

Görev

Bir n sayısı verildiğinde, tüm doğru parantez dizisini sözlük sırasına göre oluşturmanız gerekir

Çıktı bir dizi, liste veya dize olabilir (bu durumda satır başına bir dizi)

Parantez gibi farklı bir çifti kullanabilir {}, [], ()veya herhangi bir açma-kapama işareti

Misal

• n = 3

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

• n = 2

  (())
  ()()
  

Perl 6 , 36 bayt

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

Çevrimiçi deneyin!

s nin sözlüksel olarak sıralanmış tüm kombinasyonlarını bulur ve doğru olanları filtreler . Tüm geçerli kombinasyonların (hatta eşyalar gibi ) değerlendirildiğini (ki bu falsey, ancak biz ( ) geri dönüşten ayırt etmek )$2n$ []EVAL[][][]not!tryNil

Açıklama:

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

Özyineli olmayan yaklaşım. Normal ifade içinde kaçış karakterlerinden kaçındığı için "<" ve ">" kullanıyoruz. Bir ASCII aralığı için daha kısa bir spesifikasyon kullanmamıza izin vermek için, (< expand.gridCC, kodları 60, 61 ve 62 aracılığıyla) kullanarak 3 ^ 2n 2n karakterli "<", "=" ve ">" dizeleri oluşturur ve hangi kombinasyonların dengeli açık ve kapalı parantez verdiğini görün. Elbette "=" olasılıkları yok sayılır.

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

Çevrimiçi deneyin!

açıklama

"^(<(?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 bayt

Her zamanki özyinelemeli yaklaşım.

-1 teşekkürler @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))

Çevrimiçi deneyin!

C (gcc) , 114 bayt

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

Çevrimiçi deneyin!

N <= 15 için çalışmalıdır.

açıklama

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

Python 2 , 91 88 84 81 bayt

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

Çevrimiçi deneyin!

_{Pizzalar sayesinde -3 byte}

05AB1E , 13 bayt

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

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

Açıklama:

„()            # 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 bayt

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

Çevrimiçi deneyin!

Japt, 15 13 bayt

ç>i<)á Ôke/<>

Dene

açıklama

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

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

Çevrimiçi deneyin!

+!2|&2*x 2 * n uzunluğundaki tüm ikili vektörler

(x=+/)# sadece n'ye karşılık gelenler

(&/-1<+\1-2*)# sadece 0 / 1'e 1 / -1 olarak davranan kısmi toplamları hiçbir yerde negatif olmayanlar

"()" bu dizede dizin olarak 0/1 kullanın

Perl 5 -n , 41 39 bayt

Köşeli parantez ile -2 bayt

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

Çevrimiçi deneyin!

Bağlantı noktası Perl 6 cevabım.

Perl 6 , 42 bayt

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

Çevrimiçi deneyin!

Yinelemeli normal ifade kullanır. Alternatif ikame:S/[\(<~~>\)]*//

Açma / kapama sembolleri olarak 0 ve 1 ile 38 bayt :

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin! Kullanır <>s. Açıklama:

.+
$*

Tekli'ye dönüştür.

1
11

Sonucu iki katına çıkarın.

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

2²ⁿ 2n bitlik ikili sayıların tümünü, sayıları eşleştirerek numaralandırın <>.

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

Sadece dengeli sekanslar tutun. @MartinEnder tarafından keşfedilen dengeli bir parantez numarası kullanır.

JavaScript (ES6), 112 102 bayt

Bu ağırlıklı olarak Nwellnhof'un C cevabına dayanmaktadır .

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)

Çevrimiçi deneyin!

Kırmızı , 214, 184136 bayt

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]

Çevrimiçi deneyin!

Jo King'in yaklaşımını kullanır. Özyineleme kullanarak tüm olası parantez düzenlemelerini bulur (sözlükbilimsel sırayla oluşturulur) ve düzenleme geçerli bir blok olarak değerlendirilirse yazdırır.

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Çıktı TIO üzerinden netleştirildi.