Dấu ngoặc bình thường ( (), [], <>và {}) là tốt đẹp và rõ ràng, tuy nhiên có người nghĩ rằng nó sẽ là một ý tưởng tốt để sử dụng ký tự khung phi như dấu ngoặc đơn. Những nhân vật này, |và ", mơ hồ. Ví dụ

""""

tương ứng với

(())

hoặc là

()()

Nó là không thể để nói.

Mọi thứ bắt đầu trở nên thú vị khi bạn trộn các loại dấu ngoặc mơ hồ, ví dụ:

"|""||""|"

Có thể là một trong những điều sau đây

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

Bài tập

Nhiệm vụ của bạn là lấy một chuỗi được tạo thành từ các ký tự mơ hồ và xuất ra tất cả các chuỗi cân bằng có thể có mà tác giả có thể dự định.

Cụ thể hơn bạn đầu ra tất cả các chuỗi cân bằng có thể được thực hiện thay thế |với một trong hai [hoặc ]và "với một trong hai (hoặc ). Bạn không nên xuất bất kỳ chuỗi cân bằng hai lần.

Tôi

Là đầu vào, bạn nên lấy một chuỗi bao gồm |và ". Nếu bạn muốn chọn hai ký tự riêng biệt khác |và "dùng làm vật thay thế, bạn có thể làm như vậy. Bạn nên xuất một thùng chứa các chuỗi cân bằng. Bạn có thể chọn để thay thế []và ()trong đầu ra với bất kỳ hai cặp khung khác ( (), [], <>hoặc {}) bạn muốn. Định dạng đầu ra của bạn phải nhất quán trong các lần chạy.

Chấm điểm

Đây là môn đánh gôn, vì vậy câu trả lời sẽ được tính bằng byte với ít byte hơn.

Các trường hợp thử nghiệm

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

Python 2 , 135 byte

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

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

Mong đợi đầu vào như 2002thay vì "||", và được gói trong dấu ngoặc kép.

Lặp lại trên tất cả 2 ^N phép gán "mở" và "đóng" cho chuỗi, tạo các chuỗi cnhư:

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

Nếu eval-ing chuỗi này ném một ngoại lệ, nó là vô song. Nếu không, chúng tôi in c[::2], đưa ra:

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

Võng mạc , 59 56 55 byte

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

A`_

Hãy thử trực tuyến! Thật không may, việc kiểm tra hai bộ dấu ngoặc trùng khớp vượt quá mức độ chính xác của một biểu thức .NET duy nhất, do đó nó tiết kiệm được 15 byte để kiểm tra thủ công. Chỉnh sửa: Đã lưu 3 4 byte nhờ @ H.PWiz. Giải trình:

0`"
<$%">

Tìm a "và tạo hai bản sao của dòng, một với a <và một với a >. Làm điều này "cùng một lúc, sao cho mỗi lần nhân "đôi số dòng.

}0`'
{$%"}

Tương tự với ', {và }. Sau đó, tiếp tục thay thế cho đến khi tất cả các "s và 's trên tất cả các bản sao đã được thay thế.

.+
$&_$&

Tạo một bản sao của dấu ngoặc, cách nhau bởi a _.

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

Trong bản sao, lặp lại xóa dấu ngoặc trùng khớp, cho đến khi không còn dấu nào, trong trường hợp này _cũng xóa dấu ngoặc .

A`_

Xóa tất cả các dòng vẫn còn a _.

Võng mạc , 74 71 70 byte

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

Hãy thử trực tuyến! Giải thích: Hai giai đoạn đầu như trên. Giai đoạn thứ ba in trực tiếp kết quả khớp hai bộ dấu ngoặc phù hợp. Điều này sử dụng các nhóm cân bằng của .NET. Ở mỗi giai đoạn trong trận đấu, regex cố gắng khớp một ký tự, sau đó nhìn lại một cặp dấu ngoặc phù hợp, sau đó kiểm tra xem đỉnh của ngăn xếp có khớp với dấu ngoặc mở không. Nếu nó có thể làm điều này, điều đó có nghĩa là khung cân bằng và khung mở được bật ra khỏi ngăn xếp. Mặt khác, giả định là chúng ta đang ở một khung mở cần được đẩy lên ngăn xếp. Nếu các giả định này không giữ thì ngăn xếp sẽ không trống ở cuối và trận đấu sẽ thất bại.

Cách tiếp cận khác, cũng 74 71 byte:

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

Ở đây, chúng tôi nhìn về phía trước để <... >hoặc {... }, sau đó nhìn phía sau để đẩy khung đóng vào ngăn xếp. Mặt khác, chúng ta cần khớp và bật khung đóng mà chúng ta đã chụp trước đó. Trong phiên bản này, regex thậm chí có thể không đi đến cuối chuỗi, nhưng một số chuỗi như <<<>sẽ trượt qua mạng nếu chúng ta không kiểm tra ngăn xếp trống.

Husk , 19 byte

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

Hãy thử trực tuyến! Sử dụng các ký tự dstrong đầu vào, và các cặp ngoặc tương ứng devà sttrong đầu ra.

Giải trình

Ý tưởng là tạo ra tất cả các dấu ngoặc có thể có của đầu vào và giữ cho các chuỗi giảm xuống chuỗi trống khi chúng ta liên tục xóa các dấu ngoặc liền kề. Đây ¨÷₂¨là một chuỗi nén mở rộng thành một chuỗi "dest"được chọn bởi vì nó có dạng nén ngắn và bao gồm các cặp ký tự với các điểm mã liền kề. Do đó chương trình tương đương như sau.

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.

Perl, 56 55 53 byte

Bao gồm +1chon

sử dụng [cho []và {cho{}

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

Tạo tất cả 2 ^ N khả năng, sau đó sử dụng perl evalđể kiểm tra xem một chuỗi như '+ [+ {}]' có phải là mã hợp lệ hay không và nếu vậy sẽ loại bỏ +và in kết quả

APL (Dyalog Classic) , 55 53 byte

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

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

Sạch , 203 186 179 byte

?['(':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]

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

Chỉ sử dụng khớp mẫu và hiểu.

Perl, 56 byte

Bao gồm +chon

Sử dụng đầu vào [cho đầu ra [hoặc]

Sử dụng đầu vào {cho đầu ra {hoặc}

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

Sử dụng một regex mở rộng perl để phù hợp với niềng răng trong khi theo dõi các lựa chọn được thực hiện trong quá trình quay lại. Điều này có thể hiệu quả hơn nhiều so với việc tạo ra tất cả 2 ^ N ứng viên vì nó đã từ chối nhiều nhiệm vụ bất khả thi trong khi giữa chừng chuỗi đầu vào

Kotlin , 240 236 234 byte

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}

Làm đẹp

    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
    }

Kiểm tra

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")
        }
    }

Chỉnh sửa

• -4 jrtapsell - Làm lại vị từ kiểm tra
• -2 jrtapsell - true-> 1>0và == 0->< 1

C (gcc) , 315 byte

• Nhờ trần nhà cho 19 byte.

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

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

C (gcc) , 334 byte (phiên bản cũ)

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

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

Giải thích (phiên bản cũ)

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

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