Pertanyaan ini adalah yang kedua dari beberapa tantangan Ulang Tahun Brain-flak yang dirancang untuk merayakan Ulang Tahun pertama Brain-Flak! Anda dapat menemukan informasi lebih lanjut tentang Ulang Tahun Brain-Flak di sini

Tantangan

Untuk tantangan ini, Anda akan menghasilkan semua string yang sepenuhnya cocok dari daftar tanda kurung. Untuk meminjam definisi DJMcMayhem tentang string yang sepenuhnya cocok:

• Untuk tujuan tantangan ini, "braket" adalah salah satu karakter: ()[]{}<>.

• Sepasang tanda kurung dianggap "cocok" jika tanda kurung buka dan tutup berada dalam urutan yang benar dan tidak memiliki karakter di dalamnya, seperti

  ()
  []{}
  

  Atau jika setiap subelemen di dalamnya juga cocok.

  [()()()()]
  {<[]>}
  (()())
  

  Subelemen juga dapat disarungkan beberapa lapisan.

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• Sebuah string dianggap "Sepenuhnya cocok" jika dan hanya jika setiap pasangan braket memiliki braket pembuka dan penutup yang benar dalam urutan yang benar.

Memasukkan

Program atau fungsi Anda akan mencatat empat angka non-negatif dalam format apa pun yang nyaman dan konsisten. Ini termasuk (tetapi tidak terbatas pada) daftar bilangan bulat, string dibatasi non-digit, atau argumen terpisah. Keempat angka ini mewakili jumlah pasangan yang cocok dari setiap jenis braket. Sebagai contoh, [1,2,3,4]akan mewakili:

• 1 pasang ()

• 2 pasang {}

• 3 pasang []dan

• 4 pasang <>

Anda dapat memilih pasangan kurung yang sesuai dengan masing-masing input selama konsisten.

Keluaran

Anda harus menampilkan semua string yang sepenuhnya cocok yang dapat dibentuk dari daftar kurung ini tanpa duplikat. Output dapat dalam format wajar apa pun yang mencakup pencetakan string yang dibatasi non-braket ke STDOUT, atau daftar string sebagai nilai balik dari suatu fungsi.

Algoritma Anda harus bekerja untuk setiap masukan sewenang-wenang, tetapi Anda tidak perlu khawatir tentang memori, waktu atau batas ukuran bilangan bulat (misalnya jika jawaban Anda adalah di C Anda tidak akan mendapatkan 2 ³³ sebagai input).

Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.

Contoh Input dan Output

Untuk contoh ini saya akan menggunakan urutan input yang sama seperti di atas.

Untuk setiap contoh, baris pertama akan menjadi input dan baris berikut akan menjadi output

Example 0:
[0,0,0,0]


Example 1:
[1,0,0,0]
()

Example 2:
[0,2,0,0]
{}{}
{{}}

Example 3:
[0,0,1,1]
[]<>
[<>]
<[]>
<>[]

Example 4:
[0,1,2,0]
{}[][]  {}[[]]  {[]}[]  {[][]}  {[[]]} 
[{}][]  [{}[]]  [{[]}]  []{}[]  []{[]} 
[][{}]  [][]{}  [[{}]]  [[]{}]  [[]]{}

Example 5:
[1,0,0,3]
()<><><>  ()<><<>>  ()<<>><>  ()<<><>>  ()<<<>>>  (<>)<><>  (<>)<<>>
(<><>)<>  (<><><>)  (<><<>>)  (<<>>)<>  (<<>><>)  (<<><>>)  (<<<>>>)
<()><><>  <()><<>>  <()<>><>  <()<><>>  <()<<>>>  <(<>)><>  <(<>)<>>
<(<><>)>  <(<<>>)>  <>()<><>  <>()<<>>  <>(<>)<>  <>(<><>)  <>(<<>>)
<><()><>  <><()<>>  <><(<>)>  <><>()<>  <><>(<>)  <><><()>  <><><>()
<><<()>>  <><<>()>  <><<>>()  <<()>><>  <<()><>>  <<()<>>>  <<(<>)>>
<<>()><>  <<>()<>>  <<>(<>)>  <<>>()<>  <<>>(<>)  <<>><()>  <<>><>()
<<><()>>  <<><>()>  <<><>>()  <<<()>>>  <<<>()>>  <<<>>()>  <<<>>>()

Example 6:
[1,1,1,1]

(){}[]<>  (){}[<>]  (){}<[]>  (){}<>[]  (){[]}<>  (){[]<>}  (){[<>]}
(){<[]>}  (){<>}[]  (){<>[]}  ()[{}]<>  ()[{}<>]  ()[{<>}]  ()[]{}<>
()[]{<>}  ()[]<{}>  ()[]<>{}  ()[<{}>]  ()[<>{}]  ()[<>]{}  ()<{}[]>
()<{}>[]  ()<{[]}>  ()<[{}]>  ()<[]{}>  ()<[]>{}  ()<>{}[]  ()<>{[]}
()<>[{}]  ()<>[]{}  ({})[]<>  ({})[<>]  ({})<[]>  ({})<>[]  ({}[])<>
({}[]<>)  ({}[<>])  ({}<[]>)  ({}<>)[]  ({}<>[])  ({[]})<>  ({[]}<>)
({[]<>})  ({[<>]})  ({<[]>})  ({<>})[]  ({<>}[])  ({<>[]})  ([{}])<>
([{}]<>)  ([{}<>])  ([{<>}])  ([]){}<>  ([]){<>}  ([])<{}>  ([])<>{}
([]{})<>  ([]{}<>)  ([]{<>})  ([]<{}>)  ([]<>){}  ([]<>{})  ([<{}>])
([<>{}])  ([<>]){}  ([<>]{})  (<{}[]>)  (<{}>)[]  (<{}>[])  (<{[]}>)
(<[{}]>)  (<[]{}>)  (<[]>){}  (<[]>{})  (<>){}[]  (<>){[]}  (<>)[{}]
(<>)[]{}  (<>{})[]  (<>{}[])  (<>{[]})  (<>[{}])  (<>[]){}  (<>[]{})
{()}[]<>  {()}[<>]  {()}<[]>  {()}<>[]  {()[]}<>  {()[]<>}  {()[<>]}
{()<[]>}  {()<>}[]  {()<>[]}  {([])}<>  {([])<>}  {([]<>)}  {([<>])}
{(<[]>)}  {(<>)}[]  {(<>)[]}  {(<>[])}  {}()[]<>  {}()[<>]  {}()<[]>
{}()<>[]  {}([])<>  {}([]<>)  {}([<>])  {}(<[]>)  {}(<>)[]  {}(<>[])
{}[()]<>  {}[()<>]  {}[(<>)]  {}[]()<>  {}[](<>)  {}[]<()>  {}[]<>()
{}[<()>]  {}[<>()]  {}[<>]()  {}<()[]>  {}<()>[]  {}<([])>  {}<[()]>
{}<[]()>  {}<[]>()  {}<>()[]  {}<>([])  {}<>[()]  {}<>[]()  {[()]}<>
{[()]<>}  {[()<>]}  {[(<>)]}  {[]()}<>  {[]()<>}  {[](<>)}  {[]}()<>
{[]}(<>)  {[]}<()>  {[]}<>()  {[]<()>}  {[]<>()}  {[]<>}()  {[<()>]}
{[<>()]}  {[<>]()}  {[<>]}()  {<()[]>}  {<()>}[]  {<()>[]}  {<([])>}
{<[()]>}  {<[]()>}  {<[]>()}  {<[]>}()  {<>()}[]  {<>()[]}  {<>([])}
{<>}()[]  {<>}([])  {<>}[()]  {<>}[]()  {<>[()]}  {<>[]()}  {<>[]}()
[(){}]<>  [(){}<>]  [(){<>}]  [()]{}<>  [()]{<>}  [()]<{}>  [()]<>{}
[()<{}>]  [()<>{}]  [()<>]{}  [({})]<>  [({})<>]  [({}<>)]  [({<>})]
[(<{}>)]  [(<>){}]  [(<>)]{}  [(<>{})]  [{()}]<>  [{()}<>]  [{()<>}]
[{(<>)}]  [{}()]<>  [{}()<>]  [{}(<>)]  [{}]()<>  [{}](<>)  [{}]<()>
[{}]<>()  [{}<()>]  [{}<>()]  [{}<>]()  [{<()>}]  [{<>()}]  [{<>}()]
[{<>}]()  [](){}<>  [](){<>}  []()<{}>  []()<>{}  []({})<>  []({}<>)
[]({<>})  [](<{}>)  [](<>){}  [](<>{})  []{()}<>  []{()<>}  []{(<>)}
[]{}()<>  []{}(<>)  []{}<()>  []{}<>()  []{<()>}  []{<>()}  []{<>}()
[]<(){}>  []<()>{}  []<({})>  []<{()}>  []<{}()>  []<{}>()  []<>(){}
[]<>({})  []<>{()}  []<>{}()  [<(){}>]  [<()>{}]  [<()>]{}  [<({})>]
[<{()}>]  [<{}()>]  [<{}>()]  [<{}>]()  [<>(){}]  [<>()]{}  [<>({})]
[<>{()}]  [<>{}()]  [<>{}]()  [<>](){}  [<>]({})  [<>]{()}  [<>]{}()
<(){}[]>  <(){}>[]  <(){[]}>  <()[{}]>  <()[]{}>  <()[]>{}  <()>{}[]
<()>{[]}  <()>[{}]  <()>[]{}  <({})[]>  <({})>[]  <({}[])>  <({[]})>
<([{}])>  <([]){}>  <([])>{}  <([]{})>  <{()}[]>  <{()}>[]  <{()[]}>
<{([])}>  <{}()[]>  <{}()>[]  <{}([])>  <{}[()]>  <{}[]()>  <{}[]>()
<{}>()[]  <{}>([])  <{}>[()]  <{}>[]()  <{[()]}>  <{[]()}>  <{[]}()>
<{[]}>()  <[(){}]>  <[()]{}>  <[()]>{}  <[({})]>  <[{()}]>  <[{}()]>
<[{}]()>  <[{}]>()  <[](){}>  <[]()>{}  <[]({})>  <[]{()}>  <[]{}()>
<[]{}>()  <[]>(){}  <[]>({})  <[]>{()}  <[]>{}()  <>(){}[]  <>(){[]}
<>()[{}]  <>()[]{}  <>({})[]  <>({}[])  <>({[]})  <>([{}])  <>([]){}
<>([]{})  <>{()}[]  <>{()[]}  <>{([])}  <>{}()[]  <>{}([])  <>{}[()]
<>{}[]()  <>{[()]}  <>{[]()}  <>{[]}()  <>[(){}]  <>[()]{}  <>[({})]
<>[{()}]  <>[{}()]  <>[{}]()  <>[](){}  <>[]({})  <>[]{()}  <>[]{}()

Haskell , 128 byte

fadalah fungsi utama, dibutuhkan daftar Ints dan mengembalikan daftar Strings.

f=g.($zip"({[<"")}]>").zipWith replicate
g=max[""].(#g)
l#c=[b:s|x@(b,e):r<-l,s<-(r:filter(/=x:r)l)?(map(e:).c)]
l?c=c l++l#(?c)

Cobalah online!

Bagaimana itu bekerja

• fmengubah daftar inputnya menjadi daftar daftar tupel, masing-masing tupel berisi sepasang braket, dengan masing-masing jenis braket di sublistnya sendiri. Misalnya [1,2,0,0]menjadi [[('{','}')],[('[',']'),('[',']')]]. Kemudian ia memanggil gdengan daftar yang diubah.
• Fungsi yang tersisa menggunakan gaya kelanjutan kelanjutan sebagian yang bercampur dengan manipulasi daftar. Setiap fungsi lanjutan cmengambil daftar daftar ltuple braket yang tersisa dan mengembalikan daftar string yang mungkin untuk di-suffix ke apa yang sudah dihasilkan.
• g lmenghasilkan daftar string sepenuhnya cocok dapat dibentuk dengan menggunakan semua tanda kurung di l.
  • Ini dilakukan dengan menelepon l#guntuk menghasilkan string yang dimulai dengan beberapa braket. gParameter rekursif itu sendiri digunakan sebagai kelanjutan oleh #, untuk menghasilkan apa yang muncul setelah subelemen kurung pertama.
  • Dalam kasus di mana tidak ada string seperti itu (karena ltidak memiliki tanda kurung di dalam) gsebagai gantinya kembali [""], daftar berisi hanya string kosong. Karena [""]membandingkan lebih kecil dengan semua daftar kosong yang dapat dihasilkan oleh #, kita dapat melakukan ini dengan menerapkan max.
• l#cmenghasilkan string dari lawal dengan setidaknya satu subelemen kurung, membiarkan kelanjutan cuntuk menentukan apa yang mengikuti elemen.
  • bdan emerupakan pasangan kurung terpilih dalam tupel x, dan rmerupakan daftar tupel yang tersisa dari jenis braket yang sama.
  • r:filter(/=x:r)ladalah ldengan tupel xdihapus, sedikit disusun ulang.
  • ?dipanggil untuk menghasilkan subelemen yang mungkin antara bdan e. Ia mendapatkan kelanjutannya sendiri map(e:).c, yang awalan euntuk setiap string sufiks yang dihasilkan oleh c.
  • #itu sendiri menambahkan awal buntuk semua string yang dihasilkan oleh ?dan c.
• l?cmenghasilkan string yang sepenuhnya cocok yang dapat dibentuk dengan menggunakan nol atau lebih pasang braket dari l, dan kemudian melanjutkan cke kelanjutannya untuk menangani apa yang tersisa. Bagian c lberjalan langsung ke ctanpa menambahkan subelemen apa pun, sementara l#(?c)menggunakan #untuk menghasilkan satu subelemen dan kemudian memanggil (?c)secara rekursif untuk kemungkinan yang lebih lanjut.

Jelly , 50 40 34 byte

-6 byte terima kasih kepada Leaky Nun (mendapatkan pengurangan untuk bekerja di tempat saya tidak bisa)

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ

Polos dan tidak efisien.

Cobalah online! (waktu habis di TIO untuk [1,1,1,1] - ya, tidak efisien.)

Bagaimana?

Secara rekursif menghilangkan pasangan kurung yang cocok yang berada tepat di sebelah satu sama lain sampai tidak ada lagi yang dapat dihapus untuk setiap string yang mungkin terbentuk, menjaga string tersebut yang tidak berkurang (sehingga memiliki semua konten yang cocok).

“()“{}“[]“<>”©ẋ"FŒ!QµW;®œṣF¥/µÐLÐḟ - Main link: list: [n(), n{}, n[], n<>]
“()“{}“[]“<>”                      - literal ["()", "{}", "[]", "<>"]
             ©                     - copy to register
               "                   - zip with:
              ẋ                    -   repeat list
                F                  - flatten
                 Œ!                - all permutations (yeah, it's inefficient!)
                   Q               - de-duplicate
                    µ              - monadic chain separation
                                Ðḟ - filter discard if (non empty is truthy):
                             µÐL   -   loop until no change:
                       ®           -     recall value from register
                     W             -     wrap loop variable in a list
                      ;            -     concatenate
                           ¥/      -     reduce with last two links as a dyad:
                        œṣ         -       split left on occurrences of sublist on the right
                          F        -       flatten the result

Pyth - 83 74 71 63 byte

K("\[]""{}""\(\)""<>")Fd{.psm*:@Kd*\\2k@QdU4JdVldFHK=:JHk))I!Jd

Cobalah

1 : Kc "[] {} () <>") Fd {.ps * VR \ KQJdVldFHK =: JHk)) I! Jd

Juga, versi 53-byte ini berkat Leaky Nun

Kc"\[] \{} \(\) <>")Fd{.ps*V-R\\KQJdVldFHK=:JHk))I!Jd

Sini

05AB1E , 33 32 30 27 25 byte

Disimpan 7 byte berkat Riley .

Urutan input adalah [(),<>,[],{}]

žu4äשJœJÙD[D®õ:DŠQ#]€g_Ï

Cobalah online!

Penjelasan

žu                             # push the string "()<>[]{}"
  4ä                           # split in 4 parts
    ©                          # store a copy in register
     ×                         # repeat each bracket a number of times decided by input
      JœJÙ                     # get the unique permutations of the string of brackets
          D                    # duplicate
           [                   # start infinite loop
            D                  # duplicate current list of permutations
             ®õ:               # replace any instance of (), [], <>, {} 
                               # with an empty string
                DŠ             # duplicate and move down 2 places on stack
                  Q#           # if the operation didn't alter the list, exit loop
                    ]          # end loop
                     €g        # get the length of each subtring
                       _Ï      # keep only the strings in the original 
                               # list of unique permutations 
                               # that have a length of 0 in the resulting list

Ruby , 123 byte

->a{"<>{}[]()".gsub(/../){$&*a.pop}.chars.permutation.map(&:join).uniq.grep /^((\(\g<1>\)|\[\g<1>\]|\{\g<1>\}|<\g<1>>)*)$/}

Cobalah online! Ini tidak efisien, jadi input bahkan suka[1,2,1,1] kehabisan waktu online. Semua contoh yang terdaftar akan berfungsi, setidaknya!

Penjelasan

->a{                                        # Procedure with input a
    "<>{}[]()".gsub(/../){                  # For all pairs of brackets
                          $&*a.pop          # Pop last item in input, then repeat
                                            #   the bracket pair by that number
                                  }.chars   # Get characters
        .permutation                        # All permutations of characters
                    .map(&:join)            # For each permutation, join the chars
                                .uniq       # Get unique permutations only
            .grep /^((\(\g<1>\)|\[\g<1>\]|\{\g<1>\}|<\g<1>>)*)$/}
                                            # Only return permutations that match
                                            #   this bracket-matching regex