সমস্ত ব্রেন-ফ্ল্যাক স্নিপেট তৈরি করুন rate


14

এই প্রশ্নটি ব্রেন-ফ্লাকের প্রথম জন্মদিন উদযাপনের জন্য ডিজাইন করা বেশ কয়েকটি ব্রেন-ফ্লাক জন্মদিনের চ্যালেঞ্জগুলির মধ্যে দ্বিতীয়! আপনি ব্রেন-বিমানবিধ্বংসী কামান এর জন্মদিন সম্পর্কে আরও তথ্য পেতে পারেন এখানে

চ্যালেঞ্জ

এই চ্যালেঞ্জের জন্য আপনি বন্ধনীগুলির তালিকা থেকে সমস্ত সম্পূর্ণ মিলিত স্ট্রিংগুলি তৈরি করবেন। সম্পূর্ণ মিলিত স্ট্রিংয়ের ডিজেএমসিএমহেমের সংজ্ঞা ধার করতে :

  • এই চ্যালেঞ্জের উদ্দেশ্যে, একটি "বন্ধনী" এই অক্ষরের কোন হল: ()[]{}<>

  • খোলার এবং বন্ধ করার বন্ধনীগুলি যদি সঠিক ক্রমে থাকে এবং তাদের ভিতরে কোনও অক্ষর না থাকে তবে বন্ধনগুলির একটি জোড়া "মিলিত" হিসাবে বিবেচিত হয় as

    ()
    []{}
    

    বা এর অভ্যন্তরে প্রতিটি প্রতিবিম্বের সাথে যদি মিলও হয়।

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

    সুবিলিমেটগুলি বেশ কয়েকটি স্তরকে গভীরভাবে নেস্ট করা যায়।

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • একটি স্ট্রিংকে "সম্পূর্ণ মিলিত" হিসাবে বিবেচনা করা হয় এবং কেবল যদি প্রতিটি বন্ধনীটির সঠিক ক্রমে সঠিক খোলার এবং বন্ধ বন্ধনী থাকে।


ইনপুট

আপনার প্রোগ্রাম বা ফাংশনটি কোনও সুবিধাজনক, ধারাবাহিক বিন্যাসে চারটি অ-নেতিবাচক সংখ্যার একটি তালিকা নেবে। এর মধ্যে পূর্ণসংখ্যার একটি তালিকা, একটি অ-অঙ্কের বিস্মৃত স্ট্রিং বা পৃথক যুক্তি অন্তর্ভুক্ত রয়েছে (তবে সীমাবদ্ধ নয়)। এই চারটি সংখ্যা প্রতিটি ধরণের বন্ধুর সংযুক্ত মিলের সংখ্যার প্রতিনিধিত্ব করে। উদাহরণস্বরূপ, [1,2,3,4]উপস্থাপন করবে:

  • 1 জোড়া ()

  • 2 জোড়া {}

  • 3 জোড়া []এবং

  • 4 জোড়া <>

প্রতিটি ইনপুট যতক্ষণ সঙ্গতিপূর্ণ ততক্ষণ কোনও জোত বন্ধনী নির্বাচন করতে পারে।

আউটপুট

আপনার সমস্ত সম্পূর্ণ মিলিত স্ট্রিং আউটপুট করা উচিত যা ব্রেকেটের তালিকা থেকে সদৃশ ছাড়াই গঠিত হতে পারে। আউটপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে থাকতে পারে যার মধ্যে স্টাডউউটে একটি নন-ব্র্যাকেট সীমিত স্ট্রিং মুদ্রণ করা বা কোনও ফাংশন থেকে ফেরত মান হিসাবে স্ট্রিংগুলির তালিকা অন্তর্ভুক্ত রয়েছে।

আপনার অ্যালগরিদম কোনও যথেচ্ছ ইনপুট জন্য কাজ করতে হবে, কিন্তু আপনি মেমরি, সময় বা পূর্ণসংখ্যার আকার সীমা সম্পর্কে উদ্বিগ্ন হওয়ার দরকার নেই (যেমন আপনার উত্তর সিতে থাকে তবে আপনি ইনপুট হিসাবে 2 33 পাবেন না )।

এটি , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins

উদাহরণ ইনপুট এবং আউটপুট

এই উদাহরণের জন্য আমি উপরের মত একই ইনপুট অর্ডার ব্যবহার করব।

প্রতিটি উদাহরণের জন্য, প্রথম লাইনটি ইনপুট হবে এবং নিম্নলিখিত লাইনগুলি আউটপুট হবে

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

Haskell, , 128 বাইট

fএটি মূল ফাংশন, এটি Ints এর একটি তালিকা নেয় এবং 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#clধারাবাহিকতায় রেখে কমপক্ষে একটি বন্ধনীযুক্ত সাবলিমেন্ট দিয়ে শুরু থেকে স্ট্রিং তৈরি করেc করে, উপাদানটি কী অনুসরণ করে তা নির্ধারণের ।
    • bএবং eটিউপলে একটি নির্বাচিত জোড়া বন্ধনী xএবংr একই বন্ধনী ধরনের অবশিষ্ট tuples তালিকা।
    • r:filter(/=x:r)lহয় ltuple সঙ্গে xমুছে সামান্য পুনর্বিন্যাস।
    • ?bএবং এর মধ্যে সম্ভাব্য সংযোজন উত্পন্ন করতে বলা হয় e। এটি তার নিজস্ব ধারাবাহিকতা পায় map(e:).cযা eপ্রতিটি প্রত্যয়যুক্ত স্ট্রিং দ্বারা উপস্থাপিত হয় c
    • #নিজেই এবং এর bদ্বারা উত্পাদিত সমস্ত স্ট্রিংয়ের প্রাথমিকটি সংশোধন করে ।?c
  • l?cশূন্য বা আরও বন্ধনী জোড় জোড় ব্যবহার করে পুরোপুরি ম্যাচ করা স্ট্রিংগুলি ফরমেবল তৈরি করে lএবং তারপরে cযা অবশিষ্ট রয়েছে তা পরিচালনা করতে এর ধারাবাহিকতায় চলে যায়। c lঅংশ সরাসরি যায় c, কোনো subelements যোগ ছাড়া যখন l#(?c)ব্যবহারসমূহ #এক subelement জেনারেট করতে এবং তারপর কল (?c)সম্ভব আরও বেশী জন্য যাও recursively।

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
ইভাল ট্রিকস ব্যবহার করার দরকার নেই ... পরিবর্তে হ্রাস ব্যবহার করুন। 35 বাইট
লিকি নুন

1
প্রথম লাইনটি দ্বিতীয়টিতে সরিয়ে নেওয়া হচ্ছে ... 34 বাইট
লিকি নুন

টুইটারে আমি চেষ্টা করেছি কিন্তু কাজ কমিয়ে আনতে পারি না (সুতরাং এভাল ব্যবহার করে অবলম্বন করা হয়)।
জোনাথন অ্যালান

নাইস, আমি একই পদ্ধতির ব্যবহার œṣ- F- µÐLমধ্যে একটি কিছুটা সংশ্লিষ্ট সমস্যা
জাকারি

3

পাইথ - 83 74 71 63 বাইট

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

এটি চেষ্টা করুন

1 : কেসি "[] {} () <>") এফডি {.ps * ভিআর \ কেকিজেডিভিल्डএফএইচকে =: জেএইচকি)) আমি! জেডি

এছাড়াও, এই 53-বাইট সংস্করণটি লিকি নুনকে ধন্যবাদ জানায়

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

এখানে


জিলি পিঠে পিটিয়েছে? এই জাদু কি?
গণিত জাঙ্কি

@ মাথজানকি আমি জেলিকে মারিনি; আমি ইনপুট সিনট্যাক্স স্ক্রু আপ।
মারিয়া

... এবং আমি মনে করি আমি উন্নতি করতে পারি: ডি
জোনাথন অ্যালান

@ জোনাথন অ্যালান তাই এই উত্তরটি দিতে পারে।
ফাঁস নুন

1
পদক্ষেপ 1: পরিবর্তে ("\[]""{}""\(\)""<>"), আমরা করি c"\[] \{} \(\) <>")(হোয়াইটস্পেসে বিভক্ত); পরিবর্তে :@Kd*\\2k, আমরা -@Kdদুটি ব্যাকস্ল্যাশ অনুসরণ করি ; তারপরে, ম্যাপিংয়ের পরিবর্তে U4আমরা করি *V-R\\KQ(সমান্তরালে দুটি অ্যারে গুণ করি )। প্রথম অ্যারে ব্যবহার করে তৈরি করা হয়েছে R, -R\\kএটি আপনাকে 54-বাইট সংস্করণ দেবে
Leaky Nun

2

05 এ বি 1 ই , 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. আমার মনে হয় :ভেক্টরাইজ করা হয়েছে (আপনি বেশিরভাগ অসীম লুপ এড়িয়ে যেতে পারেন)। ২. এটি UXশুরুতে ব্যবহার করতে 1 বাইট কম হয় এবং Xযখন আপনার আবার বন্ধনীর তালিকার প্রয়োজন হয়।
রিলে 14

@ রিলে: আমি :প্রথমে চেষ্টা করেছি , তবে আমরা ইতিমধ্যে সমস্ত প্রতিস্থাপনের চেষ্টা করেছি বলে উদাহরণস্বরূপ প্রতিস্থাপনগুলি {}সম্ভাব্য প্রতিস্থাপন তৈরি করার সময় আমরা সমস্যাগুলি ()পাই ()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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.