^{여기 와 여기 에서 가져온 도전}

N 개의 괄호 시퀀스 구성 N ( S 및 N ) (S).

유효한 괄호 시퀀스는 다음과 같이 정의됩니다.

인접한 괄호 "()"가 비워 질 때까지 지우기를 반복하는 방법을 찾을 수 있습니다.

예를 들어, (())유효한 괄호입니다. 두 번째와 세 번째 위치에서 쌍을 지우면이됩니다 (). 그런 다음 비워 둘 수 있습니다. )()(유효한 괄호가 아닙니다. 두 번째와 세 번째 위치에서 쌍을 )(지우면 더 이상 지워지지 않습니다.

직무

숫자 n 이 주어지면 사전 순으로 모든 올바른 괄호 시퀀스를 생성해야합니다.

출력은 배열, 목록 또는 문자열 일 수 있습니다 (이 경우 줄당 시퀀스).

당신은 괄호와 같은 다른 쌍 사용할 수 있습니다 {}, [], ()또는 개폐 기호를

예

• n = 3

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

• n = 2

  (())
  ()()
  

펄 6 , 36 바이트

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

온라인으로 사용해보십시오!

사전 순으로 정렬 된 모든 조합을 찾습니다. $2n$ []s를 EVAL올바르게 필터링 합니다. 유효한 모든 조합 (조차도 같은 [][])은 다음 과 같이 평가됩니다 [](거짓이지만 우리는 not( !)를 try반환 과 구별합니다 Nil)

설명:

{                                  }  # 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.gridASCII 코드 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 바이트

일반적인 재귀 접근.

감사합니다-@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

루비 , 70 바이트

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

온라인으로 사용해보십시오!

apt, 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을 인덱스로 사용

펄 5 -n , 41 39 바이트

꺾쇠 괄호가있는 -2 바이트

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

온라인으로 사용해보십시오!

내 Perl 6 답변 포트.

펄 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?

레티 나 0.8.2 , 50 바이트

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

온라인으로 사용해보십시오! <>s를 사용 합니다. 설명:

.+
$*

단항으로 변환합니다.

1
11

결과를 두 배로 늘리십시오.

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

모든 2²ⁿ 2n 비트 이진수를 열거하고 숫자를로 매핑합니다 <>.

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

균형 잡힌 시퀀스 만 유지하십시오. 이것은 @MartinEnder가 발견 한 균형 괄호 트릭을 사용합니다.

자바 스크립트 (ES6) 112 102 바이트

이것은 nwellnhof의 C answer 에 크게 기반합니다 .

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, 184136 바이트

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]

온라인으로 사용해보십시오!

Jo King의 접근 방식을 사용합니다. 재귀를 사용하여 가능한 모든 브레이크 배열을 찾고 (어휘 순서대로 생성됨) 배열이 유효한 블록으로 평가되면이를 인쇄합니다.

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

TIO를 통해 출력이 명확 해졌습니다.