18

সাধারন বন্ধনী ( (), [], <>এবং {}), চমৎকার এবং দ্ব্যর্থহীন হয় তবে কেউ ভেবেছিলাম এটা বন্ধনী অ বন্ধনী অক্ষর ব্যবহার করার জন্য একটি ভাল ধারণা হবে। এই অক্ষরগুলি, |এবং ", দ্ব্যর্থক। উদাহরণস্বরূপ না

""""

মেলানো

(())

অথবা

()()

বলা অসম্ভব।

উদাহরণস্বরূপ, আপনি যখন ধরণের বন্ধুত্বপূর্ণ বন্ধনীগুলির মিশ্রণ করেন তখন জিনিসগুলি আকর্ষণীয় হয়ে উঠতে শুরু করে

"|""||""|"

নিম্নলিখিত যে কোনও হতে পারে

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

কার্য

আপনার কাজটি অস্পষ্ট অক্ষরগুলির তৈরি একটি স্ট্রিং নেওয়া এবং লেখক যে সমস্ত সম্ভাব্য ভারসাম্য স্ট্রিংয়ের ইচ্ছা করতে পারে সেটিকে আউটপুট দেয়।

আরো concretely আপনি আউটপুট সব সুষম স্ট্রিং যে প্রতিস্থাপন করা যেতে পারে |সঙ্গে পারেন [বা ]এবং "সঙ্গে হয় (বা )। আপনার কোনও ভারসাম্য স্ট্রিং দুবার আউটপুট করা উচিত নয়।

আই

ইনপুট হিসাবে আপনার |এবং এর সমন্বয়ে একটি স্ট্রিং নেওয়া উচিত "। আপনি দুটি স্বতন্ত্র ছাড়া অন্য অক্ষর নির্বাচন করতে চান, তাহলে |এবং "প্রতিস্থাপন আপনি এটি করতে পারেন হিসাবে পরিবেশন করা। আপনার ভারসাম্যযুক্ত স্ট্রিংগুলির একটি ধারক আউটপুট করা উচিত। আপনি প্রতিস্থাপন করা চয়ন করতে পারেন []এবং ()কোন অন্য দুটি বন্ধনী জোড়া সঙ্গে আউটপুটে ( (), [], <>বা {}) আপনি ইচ্ছুক। আপনার আউটপুট ফর্ম্যাট রান জুড়ে সামঞ্জস্যপূর্ণ হওয়া উচিত।

স্কোরিং

এটি কোড-গল্ফ তাই কম বাইট ভাল হওয়ার সাথে বাইটে উত্তরগুলি দেওয়া হবে।

পরীক্ষার মামলা

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

code-golf string balanced-string

— গম উইজার্ড
সূত্র

4

একটি ব্রেইনফ্লাক উত্তরের জন্য অপেক্ষা করছে

— কায়ারড কোইনারিংহিং

আমরা স্ট্রিংয়ের পরিবর্তে পূর্ণসংখ্যা ব্যবহার করতে পারি? অঙ্ক বা পূর্ণসংখ্যার তালিকা সম্পর্কে কী?

— জাগারব

@ জাগারব নিশ্চিত যে এটি ঠিক আছে

— গম উইজার্ড

7

পাইথন 2 , 135 বাইট

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

এটি অনলাইন চেষ্টা করুন!

এর 2002পরিবর্তে ইনপুট আশা করে "||"এবং উদ্ধৃতিগুলিতে আবৃত।

স্ট্রিংয়ের "উন্মুক্ত" এবং "বন্ধ" এর সমস্ত 2 ^এন সম্ভাব্য কার্যভারের উপরে আইট্রেটস , স্ট্রিং তৈরি করে c:

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

যদি evalএই স্ট্রিংটি একটি ব্যতিক্রম ছুঁড়ে ফেলে তবে এটি তুলনামূলক মিল নয়। যদি তা না হয় তবে আমরা মুদ্রণ করে c[::2]দিচ্ছি:

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

— লিন
সূত্র

6

রেটিনা , 59 56 55 বাইট

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

A`_

এটি অনলাইন চেষ্টা করুন! দুর্ভাগ্যক্রমে দুটি সেট ম্যাচের বন্ধনীগুলির জন্য পরীক্ষা করা একটি একা। নেট রেজেক্সের গল্ফনেসকে ছাড়িয়ে যায়, তাই এটি ম্যানুয়ালি পরীক্ষা করতে 15 বাইট সংরক্ষণ করে। সম্পাদনা করুন: @ এইচপিউইজকে ধন্যবাদ 3 4 বাইট সংরক্ষিত ব্যাখ্যা:

0`"
<$%">

একটি সন্ধান করুন "এবং লাইনের দুটি অনুলিপি করুন, একটি সাথে একটি <এবং একটি সাথে একটি >। এটি "একবারে করুন, যাতে প্রতিটি "লাইনের সংখ্যা দ্বিগুণ করে।

}0`'
{$%"}

একইভাবে ', {এবং }। তারপরে, সমস্ত অনুলিপিগুলিতে সমস্ত "s এবং 's প্রতিস্থাপন না করা পর্যন্ত প্রতিস্থাপন চালিয়ে যান।

.+
$&_$&

বন্ধনী দ্বারা সদৃশ একটি দ্বারা তৈরি করুন _।

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

সদৃশটিতে, বার বার মিলিত বন্ধনীগুলি মুছুন, যতক্ষণ না কোনওটি না থাকে, সেই ক্ষেত্রে _সেইসাথে মুছুন ।

A`_

এখনও থাকা সমস্ত লাইন মুছুন _।

রেটিনা , 74 71 70 বাইট

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

এটি অনলাইন চেষ্টা করুন! ব্যাখ্যা: প্রথম দুটি পর্যায় উপরে হিসাবে রয়েছে। তৃতীয় স্তরটি সরাসরি দুটি বন্ধনী সংযোগকারী বন্ধনীগুলির মেলানোর ফলাফল মুদ্রণ করে। এটি। নেট এর ব্যালেন্সিং গ্রুপগুলি ব্যবহার করে। ম্যাচের প্রতিটি পর্যায়ে, রেজেক্স একটি চরিত্রের সাথে মেলে দেখার চেষ্টা করে, তারপরে জোড়া জোড়া ব্র্যাকেটের জন্য ফিরে তাকান, তারপরে পরীক্ষা করুন যে স্ট্যাকের শীর্ষটি খোলা বন্ধনীটির সাথে মেলে। যদি এটি এটি করতে পারে তবে এর অর্থ হ'ল বন্ধনীটি ভারসাম্য বজায় রাখে এবং খোলা বন্ধনী স্ট্যাক থেকে পপ হয়। অন্যথায়, অনুমানটি হ'ল আমরা একটি খোলা বন্ধনীতে এসেছি যা স্ট্যাকের দিকে ঠেলাঠেলি করা দরকার। যদি এই অনুমানগুলি ধরে না রাখে তবে স্ট্যাকটি শেষে খালি হবে না এবং ম্যাচটি ব্যর্থ হবে।

বিকল্প পদ্ধতি, এছাড়াও 74 71 বাইট:

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

এখানে, আমরা হয় জন্য সামনে তাকাও <... >বা {... }, তারপর পিছনে তাকান ধাক্কা ক্লোজিং স্ট্যাকের উপর বন্ধনী। অন্যথায়, আমাদের আগে বন্ধ হওয়া বন্ধনী বন্ধনীটি মেলাতে এবং পপ করতে হবে। এই সংস্করণে রেজেক্স এমনকি স্ট্রিংয়ের শেষ পর্যন্ত নাও তৈরি করতে পারে তবে কিছু স্ট্রিং যেমন <<<>নেট থেকে পিছলে যায় যদি আমরা খালি স্ট্যাকটি না পরীক্ষা করি।

— নিল
সূত্র

1

আপনি বিভিন্ন অক্ষর ব্যবহার করে পালানোর ক্ষেত্রে কিছু বাইট সংরক্ষণ করতে পারেন

— এইচপিউইজ

@ এইচ.পি.উইজ আহ, বিকল্প ব্র্যাকেট জোড়া ব্যবহার করার বিষয়ে অবশ্যই আমি এই বিটটিকে অবশ্যই উপেক্ষা করেছি, ধন্যবাদ!

— নীল

এছাড়াও আপনি পরিবর্তন করতে পারেন |ইনপুটে

— H.PWiz

2

হুশ , 19 বাইট

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

এটি অনলাইন চেষ্টা করুন! dsইনপুট এবং একই বন্ধনী জোড়া deএবং stআউটপুটে অক্ষর ব্যবহার করে ।

ব্যাখ্যা

ধারণাটি হ'ল ইনপুটটির সমস্ত সম্ভাব্য বন্ধনী উত্পন্ন করা এবং যখন আমরা বার বার সংলগ্ন বন্ধনীগুলি সরিয়ে ফেলি তখন এটি খালি স্ট্রিংয়ে হ্রাস পায়। ¨÷₂¨একটি সংকুচিত স্ট্রিং যে মধ্যে বিস্তৃতি "dest", যা কারণ এটি একটি সংক্ষিপ্ত সংকুচিত ফর্ম এবং সংলগ্ন codepoints সঙ্গে চরিত্র জোড়া নিয়ে গঠিত মনোনীত হন। সুতরাং প্রোগ্রামটি নিম্নলিখিতগুলির সমতুল্য।

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.

— Zgarb
সূত্র

2

পার্ল, 56 55 53 বাইট

+1জন্য অন্তর্ভুক্তn

ব্যবহারসমূহ [জন্য []এবং {জন্য{}

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

সমস্ত 2 ^ N সম্ভাবনা তৈরি করে, তারপরে পার্ল ব্যবহার করে eval'+ [+ {like]' এর মতো স্ট্রিংটি কার্যকর কোড কিনা এবং তা যদি +ফলাফলটি মুছে ফেলে এবং তা মুদ্রণ করে

— টন হসপেল
সূত্র

1

এপিএল (ডায়ালগ ক্লাসিক) , 55 53 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— ngn
সূত্র

1

পরিষ্কার , 203 186 179 বাইট

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

এটি অনলাইন চেষ্টা করুন!

কেবল প্যাটার্ন-মিল এবং বোধগম্যতা ব্যবহার করে।

— Οurous
সূত্র

1

পার্ল, 56 বাইট

+জন্য অন্তর্ভুক্তn

[আউটপুট [বা ইনপুট জন্য ইনপুট ব্যবহার করে]

{আউটপুট {বা ইনপুট জন্য ইনপুট ব্যবহার করে}

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

ব্যাকট্র্যাকিংয়ের সময় করা পছন্দগুলি অনুসরণ করে ব্রেসগুলি মেলে একটি পার্ল বর্ধিত রেজেক্স ব্যবহার করে। সমস্ত 2 ^ N প্রার্থী উত্পন্ন করার চেয়ে এটি আরও কার্যকর হতে পারে যেহেতু ইনপুট স্ট্রিংয়ের মধ্য দিয়ে পার্টওয়্যার হওয়ার সময় এটি ইতিমধ্যে অনেকগুলি অসম্ভব কার্যভারতাকে প্রত্যাখ্যান করে

— টন হসপেল
সূত্র

0

কোটলিন , 240 236 234 বাইট

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}

শোভিত

    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
    }

পরীক্ষা

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

সম্পাদনাগুলি

-4 jrtapsell - পুনর্নির্মাণ চেক প্রিডিকেট
-2 jrtapsell - true-> 1>0এবং == 0->< 1

— jrtapsell
সূত্র

0

সি (জিসিসি) , 315 বাইট

19 বাইটের জন্য সিলিংক্যাটকে ধন্যবাদ ।

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

এটি অনলাইন চেষ্টা করুন!

সি (জিসিসি) , ৩৩৪ বাইট (পুরানো সংস্করণ)

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা (পুরানো সংস্করণ)

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

এটি অনলাইন চেষ্টা করুন!

— জোনাথন ফ্রেচ
সূত্র

কলোক থেকে পরিত্রাণ পেতে আপনি কি জিসিসির পরিবর্তনশীল দৈর্ঘ্যের অ্যারে ব্যবহার করতে পারবেন না?

— টন হসপেল

@ টনহোপেল আমি তবে, তবে হয় অ্যারেটিকে একটি পয়েন্টারে রূপান্তর করতে বা অন্য সূচক ভেরিয়েবলটি প্রবর্তন করতে হবে, যা আমি জানিনা যে এটির মূল্য আছে কিনা, যেহেতু আমি *s++কয়েকটি জায়গায় ব্যবহার করছি ।

— জোনাথন ফ্রেচ

char S[n],*s=Sএখনও তুলনায় ছোটchars*s=calloc(n,1)

— টন হসপেল

@ টনহোপেল আমি সত্যিই জানি না কেন এটি কাজ করছে বলে মনে হচ্ছে না ।

— জোনাথন ফ্রেচ

আপনাকে ধন্যবাদ

— জনাথন ফ্রেচ

ব্র্যাকগুলি পূরণ করুন

কার্য

আই

স্কোরিং

পরীক্ষার মামলা

পাইথন 2 , 135 বাইট

রেটিনা , 59 56 55 বাইট

রেটিনা , 74 71 70 বাইট

হুশ , 19 বাইট

ব্যাখ্যা

পার্ল, 56 55 53 বাইট

এপিএল (ডায়ালগ ক্লাসিক) , 55 53 বাইট

পরিষ্কার , 203 186 179 বাইট

পার্ল, 56 বাইট

কোটলিন , 240 236 234 বাইট

শোভিত

পরীক্ষা

সম্পাদনাগুলি

সি (জিসিসি) , 315 বাইট

সি (জিসিসি) , ৩৩৪ বাইট (পুরানো সংস্করণ)

ব্যাখ্যা (পুরানো সংস্করণ)