Tüm Brain-Flak Parçacıklarını Oluştur


14

Bu soru, Brain-Flak'ın ilk Doğum Günü'nü kutlamak için tasarlanmış birkaç Brain-Flak Doğum Günü mücadelesinin ikincisidir! Brain-Flak'ın Doğum Günü hakkında daha fazla bilgiyi burada bulabilirsiniz

Meydan okuma

Bu meydan okuma için, tam olarak eşleşen tüm dizeleri bir parantez listesinden oluşturacaksınız. DJMcMayhem'in tamamen eşleşen bir dize tanımını ödünç almak için :

  • Bu meydan okuma amacıyla bir "parantez" bu karakterlerin herhangi biridir: ()[]{}<>.

  • Açılış ve kapanış köşeli ayraçlar doğru sıradaysa ve içinde hiçbir karakter yoksa, bir çift köşeli parantez "eşleştirilmiş" olarak kabul edilir.

    ()
    []{}
    

    Veya içindeki her alt öğe de eşleşirse.

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

    Alt öğeler ayrıca birkaç kat derinliğe yuvalanabilir.

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • Bir dize, yalnızca her bir çift parantez doğru açılış ve kapanış braketine doğru sırada sahipse "Tamamen eşleşir" olarak kabul edilir.


Giriş

Programınız veya işleviniz, uygun ve tutarlı herhangi bir biçimde dört negatif olmayan sayının bir listesini alacaktır. Bu, tamsayıların listesini, basamaksız sınırlandırılmış dizeyi veya ayrı bağımsız değişkenleri içerir (ancak bunlarla sınırlı değildir). Bu dört sayı, her bir braket türünün eşleşen çiftlerinin sayısını temsil eder. Örneğin, aşağıdakileri [1,2,3,4]temsil eder:

  • 1 çift ()

  • 2 çift {}

  • 3 çift []ve

  • 4 çift <>

Her girişin tutarlı olduğu sürece hangi parantez çiftine karşılık geleceğini seçebilirsiniz.

Çıktı

Bu parantez listesinden oluşturulabilen tümüyle eşleşen dizelerin çoğunu çoğaltmadan çıkarmalısınız. Çıktı, STDOUT'a köşeli ayraçla sınırlandırılmamış bir dize veya bir işlevden dönüş değeri olarak dize listesi yazdırmayı içeren makul herhangi bir biçimde olabilir.

Algoritmanız herhangi bir rastgele giriş için çalışmalıdır, ancak bellek, zaman veya tamsayı boyut sınırları hakkında endişelenmenize gerek yoktur (örneğin cevabınız C ise giriş olarak 2 33 alamazsınız ).

Bu , bu yüzden bayttaki en kısa cevap kazanır.

Örnek Giriş ve Çıkış

Bu örnek için yukarıdakiyle aynı giriş sırasını kullanacağım.

Her örnek için ilk satır girilecek ve aşağıdaki satırlar verilecektir

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]

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

Yanıtlar:


6

Haskell , 128 bayt

fana işlev, Ints listesini alır ve s listesini döndürür String.

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)

Çevrimiçi deneyin!

Nasıl çalışır

  • fgirdi listesini, her bir demet bir braket çifti içeren, her bir braket türü kendi alt listesinde olacak şekilde, tuples listelerine dönüştürür. Örneğin [1,2,0,0]olur [[('{','}')],[('[',']'),('[',']')]]. Sonra gdönüştürülmüş liste ile çağırır .
  • Kalan işlevler liste manipülasyonu ile iç içe kısmen devam eden bir stil kullanır. Her devam işlevi kalan parantez demet listelerinin clistesini alır lve önceden oluşturulmuş olana eklenecek olası dizelerin listesini döndürür.
  • g liçindeki tüm köşeli parantezler kullanılarak oluşturulabilen tam eşleşen dizelerin listesini oluşturur l.
    • Bunu bir l#gparantez ile başlayan dizeler üretmeye çağırarak yapar . Özyinelemeli gparametrenin kendisi #, ilk parantezli alt öğeden sonra gelenleri oluşturmak için bir devamı olarak kullanılır .
    • Böyle bir dizenin olmadığı durumda ( liçeride parantez olmadığı için) gbunun yerine [""], yalnızca boş dizeyi içeren liste döner . Yana [""]listeleri ile oluşturulabilen tüm boş olmayan daha küçük karşılaştırır #, biz uygulayarak bunu yapabilirsiniz max.
  • l#clen az bir köşeli ayraçlı alt cöğeyle baştan başlayarak dizeler oluşturur ve öğeyi neyin takip ettiğini belirlemek için devam eder.
    • bve ebaşlığın parantez seçilmiş bir çifti xve raynı aparatı tip kalan dizilerini listesidir.
    • r:filter(/=x:r)lolan lbaşlığın ile xçıkarıldı, biraz yeniden düzenlenmiş.
    • ?arasındaki olası alt öğeleri oluşturmak için çağrılır bve e. Ürettiği sonek dizelerinin her birine map(e:).cönek eekleyen kendi devamını alır c.
    • #kendisi, ilk opsiyonlar btarafından oluşturulan tüm şeritlerine ?ve c.
  • l?csıfır veya daha fazla köşeli parantez kullanarak biçimlendirilebilen tam eşleşen dizeleri oluşturur lve sonra ckalanları işlemek için devam eder. c lBölüm doğrudan gider ciken, herhangi bir alt öğeleri eklemeden l#(?c)kullanımları #tek cihazmda oluşturmak ve sonra çağırmak (?c)mümkün ileri olanlar için yinelemeli.

4

Jöle , 50 40 34 bayt

Leaky Nun sayesinde -6 bayt (çalışamadığım yerde işe koyuluyorum)

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

Sade ve verimsiz.

Çevrimiçi deneyin! ([1,1,1,1] için TIO'da zaman aşımına uğradı - evet, verimsiz.)

Nasıl?

Birbirinin oluşturabileceği her olası dize için artık kaldırılıncaya kadar birbirinin hemen yanında bulunan eşleşen parantez çiftlerini özyinelemeli olarak kaldırır, böylece bu dizeleri hiçbir şeye indirmez (dolayısıyla eşleşen tüm içeriğe sahip olur).

“()“{}“[]“<>”©ẋ"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

1
Değerlendirme hilelerine gerek yok ... bunun yerine azaltma kullanın. 35 bayt
Leaky Nun

1
İlk satırı ikinci sıraya taşımak ... 34 bytes
Leaky Nun

@LeakyNun Teşekkürler! Denedim ama iş için bir azalma alamadım (dolayısıyla eval kullanmaya başvurdu).
Jonathan Allan

Güzel, ben aynı yaklaşımı kullanılır œṣ- F- µÐLiçinde bir şekilde alakalıdır sorun .
Zacharý

3

Pyth - 83 74 71 63 bayt

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

Dene

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

Ayrıca, bu 53 baytlık sürüm Leaky Nun sayesinde

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

Buraya


Pyth tarafından dövülmüş jöle? Bu büyücülük nedir?
matematik bağımlısı

@mathjunkie Jelly'i dövmedim; Giriş sözdizimini berbat ettim.
Maria

... ve geliştirebileceğimi düşünüyorum: D
Jonathan Allan

@JonathanAllan bu cevap verebilir.
Leaky Nun

1
Adım 1: yerine, (boşlukta bölün) ("\[]""{}""\(\)""<>")yaparız c"\[] \{} \(\) <>"); bunun yerine iki ters eğik çizgi :@Kd*\\2kizliyoruz -@Kd; sonra, eşleme U4yapmak yerine, yaparız *V-R\\KQ(iki diziyi paralel olarak çarparız). İlk dizi kullanılarak üretilir R, -R\\kbu size 54 baytlık bir sürüm verir
Leaky Nun

2

05AB1E , 33 32 30 27 25 bayt

Riley sayesinde 7 bayt kurtardı .

Giriş sırası [(),<>,[],{}]

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

Çevrimiçi deneyin!

açıklama

ž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

1. Sanırım :vektörleşir (sonsuz döngünün çoğunu atlayabilirsiniz). 2. UXBaşlangıçta ve Xparantez listesine tekrar ihtiyacınız olduğunda 1 bayt daha kısadır .
Riley

@Riley: :İlk önce denedim , ancak örneğin üzerindeki {}değiştirmeler, ()zaten değiştirmeyi denediğimiz için olası değiştirmeler oluşturduğunda sorun yaşıyoruz (). UXGerçi iyi bir nokta . Bir bayt daha alabiliriz ©®.
Emigna

UZirveye çıkan gerçeği her zaman sinir bozucuydu. Bilmiyordum ©®.
Riley

Bu cevaba bakıyordum . 05AB1E, onu kıran bir güncelleme aldı mı veya bu yanıt geçerli değil mi?
Riley

Bu cevap işe yarar [([]{})<{[()<()>]}()>{}], ama işe yaramaz [({})<{[()<()>]}()>{}]. Tek fark kaldırıldı []. Bunu TNB'de soracağım.
Riley

2

Ruby , 123 bayt

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

Çevrimiçi deneyin! Yine de verimsizdir, bu nedenle gibi girdiler bile [1,2,1,1]zaman aşımına uğrayacaktır. Listelenen tüm örnekler en azından işe yarayacak!

açıklama

->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
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.