일반 브래킷 ( (), [], <>및 {}) 그러나 누군가는 괄호로 비 괄호 문자를 사용하는 좋은 아이디어가 될 것이라고 생각, 좋은 모호하다. 이러한 문자는, |및 ", 모호한 있습니다. 예를 들어

""""

에 해당

(())

또는

()()

말할 수 없습니다.

예를 들어 모호한 유형의 대괄호를 혼합하면 상황이 흥미로워지기 시작합니다.

"|""||""|"

다음 중 하나 일 수 있습니다.

([(([]))]),([()[]()]),([()][()])

직무

당신의 임무는 모호한 문자로 구성된 문자열을 가져 와서 저자가 의도 한 모든 가능한 균형 잡힌 문자열을 출력하는 것입니다.

보다 구체적으로 출력 할 대체 할 수있는 모든 균형있는 문자열 |중 하나와 함께 [또는 ]과 "와 하나 (또는 ). 균형 잡힌 문자열을 두 번 출력해서는 안됩니다.

IO

입력으로 |and 로 구성된 문자열을 가져와야 "합니다. 당신이 아닌 다른 두 가지 문자를 선택하려는 경우 |와 "그렇게 할 수 있습니다 대체 역할을 할 수 있습니다. 균형 잡힌 문자열의 컨테이너를 출력해야합니다. 당신은 대체하도록 선택할 수 있습니다 []및 ()다른 두 개의 브래킷 쌍 출력에 ( (), [], <>또는 {}) 당신 바랍니다. 실행마다 출력 형식이 일관되어야합니다.

채점

이것은 코드 골프 이므로 바이트 수가 적을수록 답이 바이트로 표시됩니다.

테스트 사례

"" -> ["()"]
"|"| -> []
||| -> []
"""" -> ["(())","()()"]
""|| -> ["()[]"]
"|"||"|" -> ["([([])])"]    
"|""||""|" -> ["([(([]))])","([()[]()])","([()][()])"]    

파이썬 2 , 135 바이트

s=input()
for k in range(2**len(s)):
 try:c=''.join("[]() , ,"[int(c)|k>>i&1::4]for i,c in enumerate(s));eval(c);print c[::2]
 except:0

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

2002대신 입력을 예상 "||"하고 따옴표로 묶습니다.

문자열에 "open"및 "close"의 ^2N 가능한 모든 할당을 반복 하여 다음 c과 같은 문자열을 만듭니다 .

"( [ ( ),],[ ( ),],),( ),"

eval-ing이 문자열에서 예외가 발생 하면 일치하지 않습니다. 그렇지 않은 경우 c[::2]다음을 제공하여 인쇄합니다 .

([()][()])()

망막 , 59 56 55 바이트

0`"
<$%">
}0`'
{$%"}
.+
$&_$&
+m`^_|(<>|{})(?=.*_)

A`_

온라인으로 사용해보십시오! 불행히도 두 세트의 일치하는 괄호 테스트는 단일 .NET 정규식의 골프를 초과하므로 수동으로 확인하기 위해 15 바이트를 절약합니다. 편집 : @ H.PWiz 덕분에 3 4 바이트가 절약되었습니다. 설명:

0`"
<$%">

a를 찾아 한 "줄에 a <와 다른 사본을 만듭니다 >. 한 번 "에 하나씩 이렇게하면 "줄 수가 두 배가됩니다.

}0`'
{$%"}

마찬가지로 함께 ', {그리고 }. 그런 다음 모든 사본의 모든 "s 및 's가 교체 될 때까지 계속 교체하십시오 .

.+
$&_$&

으로 구분하여 대괄호를 복제하십시오 _.

+m`^_|(<>|{})(?=.*_)

중복에서, 일치하는 대괄호가 없을 때까지 반복하여 삭제하십시오 _. 이 경우에도 대괄호를 삭제하십시오 .

A`_

가 여전히있는 모든 행을 삭제하십시오 _.

망막 , 74 71 70 바이트

0`"
<$%">
}0`'
{$%"}
Lm`^(.(?<=(?=\3)(<.*>|{.*}))(?<-3>)|(.))+(?(3)_)$

온라인으로 사용해보십시오! 설명 : 처음 두 단계는 위와 같습니다. 세 번째 단계는 일치하는 두 세트의 대괄호를 일치시킨 결과를 직접 인쇄합니다. 이것은 .NET의 밸런싱 그룹을 사용합니다. 일치하는 각 단계에서 정규 표현식은 문자를 일치시키고 일치하는 괄호 쌍을 다시 찾은 다음 스택의 상단이 열린 괄호와 일치하는지 확인합니다. 이것이 가능하면 브래킷이 균형을 이루고 열린 브래킷이 스택에서 튀어 나오는 것을 의미합니다. 그렇지 않으면, 우리는 스택에 밀려 야하는 열린 브래킷에 있다고 가정합니다. 이러한 가정이 유지되지 않으면 스택이 마지막에 비어 있지 않고 경기가 실패합니다.

대체 접근 방식, 74 71 바이트 :

Lm`^((?=(<.*>|{.*})(?<=(.))).|\3(?<-3>))+(?(3)_)$

여기서 우리는 <... >또는 {... }를 찾고 나서 닫는 괄호를 스택에 밀어 넣습니다 . 그렇지 않으면 앞에서 캡처 한 닫는 괄호를 일치시키고 팝해야합니다. 이 버전에서 정규 표현식은 문자열의 끝까지 만들지 않을 수도 있지만 <<<>빈 스택을 확인하지 않으면 그물을 통해 미끄러질 것입니다.

껍질 , 19 바이트

fo¬ω`ḞoΣx½¨÷₂¨ΠmSe→

온라인으로 사용해보십시오! ds입력 및 해당 대괄호 쌍 de과 st출력 의 문자 를 사용합니다 .

설명

아이디어는 입력의 가능한 모든 브라케팅을 생성하고 인접한 브라켓을 반복적으로 제거 할 때 빈 문자열로 축소되는 브라켓을 유지하는 것입니다. 는 ¨÷₂¨압축 된 문자열로 펼쳐지 "dest"는 짧은 압축 된 형태를 갖고, 인접 코드 포인트와 문자 쌍으로 구성되어 있기 때문에 선택되었다. 따라서 프로그램은 다음과 같습니다.

fo¬ω`ḞoΣx½"dest"ΠmSe→  Implicit input, say "ddssdd".
                 m     Map over the string:
                  Se    pair character with
                    →   its successor.
                       Result: ["de","de","st","st","de","de"]
                Π      Cartesian product: ["ddssdd","ddssde",..,"eettee"]
f                      Keep those strings that satisfy this:
                        Consider argument x = "ddsted".
   ω                    Iterate on x until fixed:
         ½"dest"         Split "dest" into two: ["de","st"]
    `Ḟ                   Thread through this list (call the element y):
        x                 Split x on occurrences of y,
      oΣ                  then concatenate.
                          This is done for both "de" and "st" in order.
                        Result is "dd".
 o¬                    Is it empty? No, so "ddsted" is not kept.
                      Result is ["destde","ddstee"], print implicitly on separate lines.

펄, 56 55 53 바이트

포함 +1을 위해n

사용 [을위한 []및 {대한{}

perl -nE 's%.%"#1$&,+\\$&}"^Xm.v6%eg;eval&&y/+//d+say for< $_>' <<< "[{[[{{[[{["

2 ^ N 가능성을 모두 생성 한 다음 perl eval을 사용 하여 '+ [+ {}]'와 같은 문자열이 유효한 코드인지 확인하고, 그렇다면 코드를 제거 +하고 결과를 인쇄합니다.

APL (Dyalog Classic) , 55 53 바이트

{a/⍨~×≢¨'\(\)|\[]'⎕r''⍣≡a←⊃∘'()[]'¨¨(⊂'".'⍳⍵)+,⍳2⊣¨⍵}

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

면도 , 203 (186) 179 바이트

?['(':l][')':t]= ?l t
?['[':l][']':t]= ?l t
?l[h:t]= ?[h:l]t
?[][]=True
?_ _=False
@['"']=[['('],[')']]
@['|']=[['['],[']']]
@[h:t]=[[p:s]\\[p]<- @[h],s<- @t]
$s=[k\\k<- @s| ?[]k]

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

패턴 일치 및 이해 만 사용합니다.

펄, 56 바이트

포함 +을 위해n

[출력을 위해 입력 을 사용 [하거나]

{출력을 위해 입력 을 사용 {하거나}

perl -nE '/^((.)(?{$^R.$2})(?1)*\2(?{$^R.=$2^v6}))*$(?{say$^R})^/' <<< "[{[[{{[[{["

역 추적 중에 이루어진 선택 사항을 추적하면서 괄호와 일치시키기 위해 perl 확장 정규식을 사용합니다. 입력 문자열을 통해 도중에 불가능한 많은 할당을 이미 거부하므로 모든 2 ^ N 후보를 생성하는 것보다 훨씬 효율적입니다.

코 틀린 , 240 (236) 234 바이트

fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

미화

    fold(listOf("")) {r,c ->
        r.flatMap {i-> when(c) {
            '"'-> "()".map {i+it}
            else -> "[]".map {i+it}
        }}
    }.filter {
        val d = ArrayList<Char>()
        it.all {
            fun f(c:Any)=d.size>1&&d.removeAt(0)==c
            when(it) {
                ')' -> f('(')
                ']' -> f('[')
                else -> {d.add(0,it);1>0}
            }
        } && d.size<1
    }

테스트

private fun String.f(): List<String> =
fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

data class Test(val input: String, val outputs: List<String>)

val tests = listOf(
    Test("""""""", listOf("()")),
    Test(""""|"|""", listOf()),
    Test("""|||""", listOf()),
    Test("""""""""", listOf("(())","()()")),
    Test("""""||""", listOf("()[]")),
    Test(""""|"||"|"""", listOf("([([])])")),
    Test(""""|""||""|"""", listOf("([(([]))])","([()[]()])","([()][()])"))
)

fun main(args: Array<String>) {
    for ((input, output) in tests) {
        val actual = input.f().sorted()
        val expected = output.sorted()
        if (actual != expected) {
            throw AssertionError("Wrong answer: $input -> $actual | $expected")
        }
    }

편집

• -4 jrtapsell- 재 작업 된 점검 술어
• -2 jrtapsell -- true> 1>0및 == 0->< 1

C (gcc) , 315 바이트

• 19 바이트의 ceilingcat 덕분 입니다.

j,b;B(char*S){char*s=calloc(strlen(S)+2,b=1)+1;for(j=0;S[j];b*=(S[j]<62||*--s==60)*(S[j++]-41||*--s==40))S[j]==60?*s++=60:0,S[j]<41?*s++=40:0;return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n<strlen(S))for(k=2;k--;)S[n]==46-k-k?S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k:0;else B(S)&&puts(S);}F(int*S){f(S,0);}

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

C (gcc) , 334 바이트 (이전 버전)

j,b;B(char*S){char*s=calloc(strlen(S)+2,1)+1;for(b=1,j=0;S[j];j++){if(S[j]==60)*s++=60;if(S[j]<41)*s++=40;b*=!(S[j]>61&&*--s!=60)*!(S[j]==41&&*--s!=40);}return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n>=strlen(S))return B(S)&&puts(S);for(k=0;k<2;k++)S[n]==46-k-k&&(S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k);}F(char*S){f(S,0);}

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

설명 (이전 버전)

j,b;B(char*S){                   // determine if string is balanced
 char*s=calloc(strlen(S)+2,1)+1; // array to store matching brackets
 for(b=1,j=0;S[j];j++){          // loop through string (character array)
  if(S[j]==60)*s++=60;           // 60 == '<', opening bracket
  if(S[j]<41)*s++=40;            // 40 == '(', opening bracket
  b*=!(S[j]>61&&*--s!=60)*       // 62 == '>', closing bracket
   !(S[j]==41&&*--s!=40);}       // 41 == ')', closing bracket
 return*s>0&*--s<1&b;}           // no unmatched brackets and no brackets left to match
f(S,n,k)char*S;{                 // helper function, recursively guesses brackets
 if(n>=strlen(S))                // string replaced by possible bracket layout
  return B(S)&&puts(S);          // print if balanced, return in all cases
 for(k=0;k<2;k++)                // 46 == '.', guess 40 == '(',
  S[n]==46-k-k&&(S[n]=40+k*20,   //  guess 41 == '(', restore
   f(S,n+1),S[n]=41+k*21,        // 44 == ',', guess 60 == '<',
   f(S,-~n),S[n]=46-k-k);}       //  guess 62 == '>', restore
F(char*S){f(S,0);}               // main function, call helper function

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