सभी ब्रेन-फ्लैक स्निपेट्स बनाएं


14

यह सवाल ब्रेन-फ्लैक के पहले जन्मदिन को मनाने के लिए डिज़ाइन की गई कई ब्रेन-फ्लैक बर्थडे चुनौतियों में से दूसरा है! आप ब्रेन-आलोचना का जन्म-दिन के बारे में अधिक जानकारी पा सकते हैं यहाँ

चुनौती

इस चुनौती के लिए आप कोष्ठक की सूची से पूरी तरह से मेल खाते हुए तार पैदा करेंगे। पूरी तरह से मिलान स्ट्रिंग की डीजेएमकेमहेम की परिभाषा उधार लेने के लिए :

  • इस चुनौती के प्रयोजन के लिए, एक "ब्रैकेट" इन पात्रों में से किसी प्रकार है: ()[]{}<>

  • ब्रैकेट की एक जोड़ी को "मिलान" माना जाता है यदि उद्घाटन और समापन ब्रैकेट सही क्रम में हैं और उनके अंदर कोई वर्ण नहीं है, जैसे कि

    ()
    []{}
    

    या अगर इसके अंदर का हर सबमेलमेंट भी मैच हो जाए।

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

    घनीभूत परतों को भी कई परतों में घोंसला बनाया जा सकता है।

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • एक स्ट्रिंग को "पूरी तरह से मिलान" माना जाता है यदि और केवल अगर ब्रैकेट के प्रत्येक जोड़े में सही क्रम में सही उद्घाटन और समापन ब्रैकेट है।


इनपुट

आपका कार्यक्रम या फ़ंक्शन किसी भी सुविधाजनक, सुसंगत प्रारूप में चार गैर-ऋणात्मक संख्याओं की एक सूची लेगा। इसमें पूर्णांक, एक गैर-अंक सीमांकित स्ट्रिंग, या अलग-अलग तर्कों की सूची शामिल है (लेकिन यह सीमित नहीं है)। ये चार संख्याएं प्रत्येक प्रकार के ब्रैकेट के मिलान जोड़े की संख्या को दर्शाती हैं। उदाहरण के लिए, [1,2,3,4]प्रतिनिधित्व करेंगे:

  • की 1 जोड़ी ()

  • के 2 जोड़े {}

  • के 3 जोड़े []और

  • के 4 जोड़े <>

आप चुन सकते हैं कि प्रत्येक इनपुट कोष्ठक की किस जोड़ी से संगत है।

उत्पादन

आपको सभी पूरी तरह से मिलान वाले स्ट्रिंग का उत्पादन करना चाहिए जो कि डुप्लिकेट के बिना कोष्ठक की इस सूची से बन सकते हैं। आउटपुट किसी भी उचित प्रारूप में हो सकता है जिसमें एक गैर-ब्रैकेट सीमांकित स्ट्रिंग को STDOUT या किसी फ़ंक्शन से वापसी मान के रूप में स्ट्रिंग की सूची शामिल करना शामिल है।

आपका एल्गोरिथ्म किसी भी मनमाने इनपुट के लिए काम करना चाहिए, लेकिन आपको मेमोरी, समय या पूर्णांक आकार सीमाओं के बारे में चिंता करने की आवश्यकता नहीं है (जैसे कि यदि आपका उत्तर C में है तो आपको इनपुट के रूप में 2 33 नहीं मिलेगा )।

यह , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।

उदाहरण इनपुट और आउटपुट

इन उदाहरणों के लिए मैं ऊपर के समान इनपुट ऑर्डर का उपयोग करूंगा।

प्रत्येक उदाहरण के लिए, पहली पंक्ति इनपुट होगी और निम्नलिखित लाइनें आउटपुट होंगी

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]

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

जवाबों:


6

हास्केल , 128 बाइट्स

fमुख्य कार्य है, यह Ints की सूची लेता है और s की सूची लौटाता है 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)

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

  • fअपनी इनपुट सूची को टुपल्स की सूची में बदल देता है, प्रत्येक टपल को ब्रैकेट पेयर से युक्त किया जाता है, जिसमें प्रत्येक प्रकार की ब्रैकेट अपने स्वयं के सबलिस्ट में होती है। जैसे [1,2,0,0]बन जाता है [[('{','}')],[('[',']'),('[',']')]]। फिर यह gतब्दील सूची के साथ कहता है ।
  • शेष कार्य सूची हेरफेर के साथ आंशिक रूप से निरंतर-गुजर शैली का उपयोग करते हैं। प्रत्येक निरंतरता फ़ंक्शन शेष ब्रैकेट टपल सूचियों की cएक सूची लेता है lऔर संभावित स्ट्रिंग की एक सूची देता है जिसे पहले से ही उत्पन्न होने के लिए प्रत्यय दिया जा सकता है।
  • g lमें सभी कोष्ठक का उपयोग करके पूरी तरह से मिलान तार की सूची उत्पन्न करता है l
    • यह l#gकुछ ब्रैकेट के साथ शुरुआत उत्पन्न करने के लिए कॉल करके ऐसा करता है । पुनरावर्ती gपैरामीटर का उपयोग एक निरंतरता के रूप में किया जाता है #, यह उत्पन्न करने के लिए कि पहले ब्रैकेट के बाद क्या होता है।
    • ऐसे मामले में जहां इस तरह के तार नहीं हैं (क्योंकि lअंदर कोई कोष्ठक नहीं बचा है) gरिटर्न के बजाय [""], केवल खाली स्ट्रिंग वाली सूची। चूँकि [""]उत्पादक से छोटी सभी गैर-रिक्त सूची की तुलना की जाती है #, हम इसे लागू करके कर सकते हैं max
  • l#cतत्व का अनुसरण lकरने के लिए निरंतरता cको छोड़कर, कम से कम एक ब्रैकेट वाले सबलेमेंट के साथ शुरुआत से तार उत्पन्न करता है।
    • bऔर eट्यूपल में कोष्ठक की एक चयनित जोड़ी है x, और rउसी ब्रैकेट प्रकार के शेष ट्यूपल्स की सूची है।
    • r:filter(/=x:r)lहै lटपल साथ xहटा दिया, थोड़ा पुन: व्यवस्थित।
    • ?के बीच bऔर संभव उप-निर्माण उत्पन्न करने के लिए कहा जाता है e। यह अपनी निरंतरता प्राप्त करता है map(e:).c, जो eउत्पन्न होने वाले प्रत्येक प्रत्यय के प्रत्येक उपसर्ग करता है c
    • #खुद के bद्वारा उत्पन्न सभी तार के लिए प्रारंभिक प्रस्तुत करता है ?और c
  • l?cशून्य या अधिक ब्रैकेट जोड़े का उपयोग करके पूरी तरह से मिलान किए गए तार उत्पन्न करता है l, और फिर cजो बचा है उसे संभालने के लिए अपनी निरंतरता को छोड़ देता है। यह c lहिस्सा cबिना किसी सबलेमेंट को जोड़े सीधे चला जाता है , जबकि एक सबलेमेंट को जेनरेट करने के लिए l#(?c)उपयोग करता #है और फिर संभवत: (?c)आगे के लिए पुनरावर्ती कॉल करता है।

4

जेली , 50 40 34 बाइट्स

-6 बाइट्स लीकी नून की बदौलत (काम करना कम कर देना जहां मैं नहीं कर सका)

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

सादा और अकुशल।

इसे ऑनलाइन आज़माएं! (टीआईओ में [1,1,1,1] के लिए समय - हां, अक्षम)

कैसे?

पुनरावर्ती मिलान करने वाले कोष्ठकों के जोड़े निकालता है जो एक दूसरे के ठीक बगल में रहते हैं जब तक कि हर संभव स्ट्रिंग के लिए कोई और हटाया नहीं जा सकता है, ऐसे तार रखते हुए जो कुछ भी नहीं घटाते (इसलिए सभी मिलान सामग्री होती है)।

“()“{}“[]“<>”©ẋ"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
Eval ट्रिक्स का उपयोग करने की आवश्यकता नहीं है ... इसके बजाय कम का उपयोग करें। 35 बाइट्स
लीकी नून

1
पहली पंक्ति को दूसरे स्थान पर ले जाना ... 34 बाइट्स
लीकी नून

@LeakyNun धन्यवाद! मैंने कोशिश की लेकिन काम करने के लिए कम नहीं हो सका (इसलिए eval का उपयोग करने का सहारा लिया गया)।
जोनाथन एलन

अच्छा, मैंने कुछ हद तक संबंधित समस्या में œṣ- F- के समान दृष्टिकोण का उपयोग किया । µÐL
ज़ाचरी

3

पायथ - 83 74 71 63 बाइट्स

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

कोशिश करो

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

इसके अलावा, यह 53-बाइट संस्करण लीकी नन के लिए धन्यवाद है

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

यहाँ


जेली पीट द्वारा पीटा गया? ये क्या जादू है?
मैथ जंकी

@mathjunkie मैंने जेली को नहीं हराया; मैंने इनपुट सिंटैक्स खराब कर दिया।
मारिया

... और मुझे लगता है कि मैं सुधार कर सकता हूं: डी
जोनाथन एलन

@JonathanAllan तो यह जवाब दे सकता है।
लीक नून

1
चरण 1: के बजाय ("\[]""{}""\(\)""<>"), हम करते हैं c"\[] \{} \(\) <>")(व्हॉट्सएप पर विभाजित); इसके बजाय :@Kd*\\2k, हम -@Kdदो backslashes द्वारा पीछा किया; फिर, मैपिंग के बजाय U4, हम करते हैं *V-R\\KQ(समानांतर में दो सरणियों को गुणा करें)। पहली सरणी का उपयोग करके उत्पन्न किया गया है R, अर्थात् -R\\kयह आपको एक 54-बाइट संस्करण देगा
लीक नून

2

05AB1E , 33 32 30 27 25 बाइट्स

रिले की बदौलत 7 बाइट्स बचाए

इनपुट ऑर्डर है [(),<>,[],{}]

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

इसे ऑनलाइन आज़माएं!

व्याख्या

ž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. मुझे लगता है कि :वेक्टराइज़ (आप अनंत लूप को छोड़ सकते हैं)। 2. यह UXशुरुआत में उपयोग करने के लिए कम बाइट्स है और Xजब आपको फिर से कोष्ठक की सूची की आवश्यकता होती है।
रिले

@Riley: मैं बस की कोशिश की थी :पहले, लेकिन जब उदाहरण के प्रतिस्थापन के लिए पर हम मुद्दों मिल {}पर संभव प्रतिस्थापन बनाता है ()के रूप में हम पहले से ही सब जगह की कोशिश की है ()UXहालांकि अच्छी बात है । हम साथ ©®ही साथ एक और बाइट प्राप्त कर सकते हैं ।
एमिग्ना

तथ्य यह है कि Uशीर्ष चबूतरे हमेशा निराशाजनक था। मैं नहीं जानता था ©®
रिले

मैं इस जवाब को देख रहा था । क्या 05AB1E को एक अपडेट मिला जिसने इसे तोड़ दिया, या क्या यह उत्तर मान्य नहीं है?
रिले

यह उत्तर काम करता है [([]{})<{[()<()>]}()>{}], लेकिन इसके लिए नहीं [({})<{[()<()>]}()>{}]। एकमात्र अंतर हटा दिया गया है []। मैं टीएनबी में इसके बारे में पूछूंगा।
रिले

2

रूबी , 123 बाइट्स

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

इसे ऑनलाइन आज़माएं! हालांकि, यह अक्षम है, इसलिए यहां तक ​​कि इनपुट भी [1,2,1,1]ऑनलाइन टाइम आउट होंगे। सभी सूचीबद्ध उदाहरण काम करेंगे, कम से कम!

व्याख्या

->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
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.