ভারসাম্যযুক্ত ত্রিপলি বন্ধনী

Question

একটি "ট্রিপলেট বন্ধনী" (যে আমি এই চ্যালেঞ্জের জন্য তৈরি করেছি) নিম্নলিখিতগুলির মধ্যে একটি:

(...+...)
[...:...]
{...|...}
<...-...>

ভারসাম্য ট্রিপল ব্র্যাকেট স্ট্রিং (সংক্ষেপে বিটিবিএস) হয় খালি স্ট্রিং, দুটি বিটিবিএস কনটেনটেটেড, বা ...বিটিবিএস দ্বারা প্রতিস্থাপিত প্রতিটি সহ উপরের ট্রিপল ব্র্যাকেটগুলির মধ্যে একটি one

আপনার কাজটি এমন কোনও প্রোগ্রাম বা ফাংশন লিখতে হয় যা পরীক্ষা করে যে কেবল একটি স্ট্রিং রয়েছে যা (+)[:]{|}<->ভারসাম্যযুক্ত কিনা তা পরীক্ষা করে । সংক্ষিপ্ততম কোড জিতেছে।

উদাহরণ

আপনার প্রোগ্রামটি নিম্নলিখিত স্ট্রিংগুলির জন্য সত্যবাদী হওয়া উচিত:

(+)(+)(+)
[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)
<<<<<<<<<<<<->->->->->->->->->->->->
{|(+[:<-{|(+[:<->])}>])}
[[[:]:[:]]:[[:]:[:]]]
{[:](+)|<->{|}}[(+)<->:{|}(+)]

আপনার প্রোগ্রামটি নিম্নলিখিত স্ট্রিংগুলির জন্য মিথ্যা প্রত্যাবর্তন করা উচিত:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->

Comments

কি (|)বৈধ। আমি এটি মনে করি না, তবে আমি নিশ্চিত নই

— রোমান গ্রাফ

@ রোমানগ্রাফ না, যেমন <|>মিথ্যা উদাহরণ রয়েছে।

— jimmy23013

Answer 1

জাপট, 25 বাইট

!Ue"%(%+%)|%[:]|\{%|}|<->

এটি অনলাইন পরীক্ষা!

eঅন ​​স্ট্রিং একটি পুনরাবৃত্তির-প্রতিস্থাপন ফাংশন। দ্বিতীয় প্যারামিটারটি খালি স্ট্রিংয়ের ডিফল্ট হয়, যার অর্থ এটি পুনরাবৃত্তভাবে জাপট রেজেক্সের ম্যাচগুলি সরিয়ে দেয় "%(%+%)|%[:]|\{%|}|<->"(নিয়মিত শর্তে /\(\+\)|\[:]|{\|}|<->/)। এটি ভারসাম্য ট্রিপল স্ট্রিংগুলির জন্য একটি খালি স্ট্রিং এবং ভারসাম্যহীন না হওয়ার জন্য একটি খালি খালি স্ট্রিং প্রদান করে, সুতরাং সঠিক প্রত্যাবর্তন মান এটির যৌক্তিক নয়।

Answer 2

জাভাস্ক্রিপ্ট (ES6), 77 58 57 56 বাইট

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

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

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

console.log("Testing truthy values");
console.log(f("(+)(+)(+)"));
console.log(f("[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)"));
console.log(f("<<<<<<<<<<<<->->->->->->->->->->->->"));
console.log(f("{|(+[:<-{|(+[:<->])}>])}"));
console.log(f("[[[:]:[:]]:[[:]:[:]]]"));
console.log(f("{[:](+)|<->{|}}[(+)<->:{|}(+)]"));

console.log("Testing falsy values");
console.log(f(":["));
console.log(f("<|>"));
console.log(f("(+(+)"));
console.log(f("[:][:](+[[:]):]"));
console.log(f("{|{|{|(+{|{|{|}}}}}+)}[:]{|}"));
console.log(f("{{||}}"));
console.log(f("<<->-<->-<->>"));
console.log(f("[(+):((+)+)+(+(+))]"));
console.log(f("<<<<<->->->->->->"));

Comments

রেটিনাতে

— মার্টিন

এবং পার্ল সঙ্গে 39: perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_'।

— দাদা

@ দাদা এটি 0একটি বিটিবিএস বিবেচনা করবে । পরিবর্তে এটি 38 টি ব্যবহার করুন:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'

— টন হসপেল

@ টনহোপেল সে সম্পর্কে ভাবেনি, সত্যই .. এটি দেখানোর জন্য ধন্যবাদ! (আপনি যদি চান তবে এটি পোস্ট করতে নির্দ্বিধায়, বা কমপক্ষে আমার কারণে পিছনে থাকবেন না)

— দাদা

যে এস / এস মিক্সটি কিছুটা বিভ্রান্ত হয়েছিল, সম্ভবত f=s=>s==(s=s.replace(...))?!s:f(s)?

— নীল

Answer 3

সেড, 28 27 বাইট

:
s#(+)\|\[:]\|{|}\|<->##
t

কিন্তু তাই আমি একটি খালি স্ট্রিং truthy এবং একটি খালি স্ট্রিং falsy বিবেচনা করছি, truthy / falsy একটি ধারণা নেই। আমরা শর্তসাপেক্ষ বিবেচনা করি কিনা এটি পরীক্ষা করে দেখুন /^$/।

1 বাইট বন্ধ গল্ফ করার জন্য @ নীলকে ধন্যবাদ!

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

Comments

একবারের জন্য, বিআরই আসলে একটি সুবিধা ।

— ডেনিস

আপনার কি দরকার \]বা ]যথেষ্ট আছে?

— নিল

আমি না। ধন্যবাদ!

— ডেনিস

Answer 4

পাইথন, 77 বাইট

lambda s:eval("s"+".replace('%s','')"*4%('(+)','[:]','{|}','<->')*len(s))==''

আরনাউল্ডের প্রতিস্থাপন ধারণা ব্যবহার করে । একটি দীর্ঘ স্ট্রিং তৈরি করে এবং মূল্যায়ন করে

s.replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','').replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','')

সমস্ত বন্ধনী ধরণের প্রতিস্থাপনের মধ্যে চক্র। তারপরে, ফলাফলটি খালি স্ট্রিং কিনা তা পরীক্ষা করে দেখুন।

Answer 5

গণিত, 55 বাইট

StringDelete["(+)"|"[:]"|"{|}"|"<->"]~FixedPoint~#==""&

বেনামে ফাংশন। ইনপুট এবং রিটার্ন হিসাবে Trueবা Falseআউটপুট হিসাবে একটি স্ট্রিং নেয় । এটি করার জন্য মানক পদ্ধতি ব্যবহার করে।

Answer 6

গ্রিম , 39 বাইট

e`\(_\+_\)|\[_\:_\]|\{_\|_\}|\<_\-_\>v*

এটি অনলাইন চেষ্টা করুন! দুঃখের বিষয়, বেশিরভাগ পরীক্ষার ক্ষেত্রে টিআইও সংস্করণ মেমরির বাইরে চলে যায়।

ব্যাখ্যা

এখানে খুব অভিনব কিছু না। _পুরো প্যাটার্নের জন্য সংক্ষিপ্ততর, এবং v*একইরকম *, তবে নিম্নতর প্রাধান্য সহ।

e`                                       Match entire input against this pattern:
  \(_\+_\)                               '(', match of _, '+', match of _, ')'
          |                              or
           \[_\:_\]|\{_\|_\}|\<_\-_\>    same for the other bracket types
                                     v*  repeated 0-∞ times

Answer 7

জে, 48 বাইট

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_

অন্যদের মতো, এটিও আরনাউল্ডের পদ্ধতির উপর ভিত্তি করে ।

ব্যবহার

   f =: a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_
   f '(+)(+)(+)'
1
   f '[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)'
1
   f '<<<<<<<<<<<<->->->->->->->->->->->->'
1
   f '<|>'
0
   f '[:][:](+[[:]):]'
0
   f '{|{|{|(+{|{|{|}}}}}+)}[:]{|}'
0

ব্যাখ্যা

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_  Input: string S
   (                                        )^:_  Repeat until convergence
                                         ]          Get S
                 '(+)';'[:]';'{|}';'<->';           Append to ['(+)', '[:]', '{|}', '<->']
    [:delstring&.>/                                 Reduce right-to-left by deleting
                                                    occurrences of each string on the
                                                    left from the right
                                                    Return the final string as the new S
a:=                                               Test if the final value of S is empty

Answer 8

স্কালা, 96 বাইট

def&(s:String):Any={val t=s.replaceAll(raw"\(\+\)|\[:]|\{\|}|<->","")
if(t==s)t.size<1 else&(t)}

এটি অন্যান্য উত্তরগুলির মত একই ধারণা, তবে কিছু স্কেল বয়লারপ্লেট সহ।

অন্যের কাছ থেকে ধারণা চুরি না করে (188 বাইট):

import scala.util.parsing.combinator._
val a = new RegexParsers{def r:Parser[_]="("~r~"+"~r~")"|"["~r~":"~r~"]"|"{"~r~"|"~r~"}"|"<"~r~"-"~r~">"|""
def!(s:String)= !parseAll(r,s).isEmpty}!_

Answer 9

পিপ , 26 বাইট

L#aaR:"(+)[:]{|}<->"<>3x!a

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

লুপ (ক) বার, খালি ট্রিপলেট বন্ধনীগুলির সমস্ত উপস্থিতি প্রতিস্থাপন করে ( "(+)[:]{|}<->"<>3, <>"গ্রুপ" অপারেটর কোথায় , => ["(+)"; "[:]"; "{|}"; "<->"]) খালি স্ট্রিং ( x) দিয়ে। এই বহু পুনরাবৃত্তি ওভারকিল, তবে সবসময় সঠিকভাবে গঠিত ট্রিপলেট বন্ধনীগুলি সম্পূর্ণরূপে কিছুতেই কমিয়ে আনার জন্য এটি যথেষ্ট পরিমাণে বেশি হবে। লুপটি সম্পূর্ণ হওয়ার পরে, ফলাফলগুলি !a: 0যদি aসত্যবাদী হয় (এখনও কিছু অক্ষর রয়েছে), 1যদি aমিথ্যা (খালি) হয়।