^{Thử thách được thực hiện từ đây và cũng ở đây}

Một chuỗi n ngoặc đơn bao gồm n ( s và n ) s.

Trình tự dấu ngoặc đơn hợp lệ được xác định như sau:

Bạn có thể tìm cách lặp lại việc xóa cặp dấu ngoặc đơn liền kề "()" cho đến khi nó trở nên trống rỗng.

Ví dụ: (())là dấu ngoặc đơn hợp lệ, bạn có thể xóa cặp ở vị trí thứ 2 và thứ 3 và ()sau đó bạn có thể làm cho nó trống. )()(không phải là dấu ngoặc đơn hợp lệ, sau khi bạn xóa cặp ở vị trí thứ 2 và thứ 3, nó sẽ trở thành )(và bạn không thể xóa nữa

Bài tập

Cho một số n bạn cần tạo tất cả các chuỗi ngoặc đơn chính xác theo thứ tự từ điển

Đầu ra có thể là một mảng, danh sách hoặc chuỗi (trong trường hợp này là một chuỗi trên mỗi dòng)

Bạn có thể sử dụng một cặp khác nhau chẳng hạn như dấu ngoặc đơn {}, [], ()hoặc bất kỳ dấu hiệu đóng mở

Thí dụ

• n = 3

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

• n = 2

  (())
  ()()
  

Perl 6 , 36 byte

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

Hãy thử trực tuyến!

$2n$ []EVAL[][][]not!tryNil

Giải trình:

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

Cách tiếp cận không đệ quy. Chúng tôi sử dụng "<" và ">" vì nó tránh các ký tự thoát trong regex. Để cho phép chúng tôi sử dụng thông số kỹ thuật ngắn hơn cho phạm vi ASCII, chúng tôi tạo ra 3 ^ 2n 2n ký tự gồm "<", "=" và ">" bằng cách sử dụng expand.grid(thông qua mã ASCII 60, 61 và 62) và sau đó grep đến xem những kết hợp nào cho dấu ngoặc mở và đóng cân bằng. Tất nhiên, khả năng "=" sẽ bị bỏ qua.

Qua http://rachbelaid.com/recursive-THER-experession/

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

Hãy thử trực tuyến!

Giải trình

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

Phương pháp đệ quy thông thường.

-1 cảm ơn @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))

Hãy thử trực tuyến!

C (gcc) , 114 byte

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

Hãy thử trực tuyến!

Nên làm việc cho n <= 15.

Giải trình

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 byte

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

Hãy thử trực tuyến!

_{-3 byte nhờ pizzapants184}

05AB1E , 13 byte

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

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Giải trình:

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

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

Hãy thử trực tuyến!

Japt, 15 13 byte

ç>i<)á Ôke/<>

Thử nó

Giải trình

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

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

Hãy thử trực tuyến!

+!2|&2*x tất cả các vectơ nhị phân có độ dài 2 * n

(x=+/)# chỉ những người có tổng bằng n

(&/-1<+\1-2*)# chỉ những người có tổng một phần, coi 0/1 là 1 / -1, không có giá trị âm

"()" sử dụng 0/1 làm chỉ số trong chuỗi này

Perl 5 -n , 41 39 byte

-2 byte với dấu ngoặc góc

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

Hãy thử trực tuyến!

Cổng 6 câu trả lời Perl của tôi.

Perl 6 , 42 byte

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

Hãy thử trực tuyến!

Sử dụng một regex đệ quy. Thay thế thay thế:S/[\(<~~>\)]*//

38 byte với 0 và 1 là ký hiệu mở / đóng:

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

Hãy thử trực tuyến!

Giải trình

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

Võng mạc 0.8.2 , 50 byte

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

Hãy thử trực tuyến! Sử dụng <>s. Giải trình:

.+
$*

Chuyển đổi sang unary.

1
11

Nhân đôi kết quả.

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

Liệt kê tất cả các số nhị phân 2²ⁿ 2n bit, ánh xạ các chữ số thành <>.

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

Chỉ giữ các chuỗi cân bằng. Điều này sử dụng thủ thuật dấu ngoặc đơn cân bằng được phát hiện bởi @MartinEnder.

JavaScript (ES6), 112 102 byte

Điều này chủ yếu dựa trên câu trả lời C của nwellnhof .

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)

Hãy thử trực tuyến!

Đỏ , 214, 184 136 byte

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]

Hãy thử trực tuyến!

Sử dụng phương pháp Jo King. Tìm tất cả các sắp xếp có khả năng của nước lợ bằng cách sử dụng đệ quy (chúng được tạo theo thứ tự từ điển) và in nó nếu sự sắp xếp đánh giá là một khối hợp lệ.

Thạch , 19 byte

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

Hãy thử trực tuyến!

Đầu ra được làm rõ qua TIO.