বন্ধনীগুলি কি পুরোপুরি মিলছে?

Question

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

বিধি এবং সংজ্ঞা:

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

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

  ()
  []{}
  

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

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

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

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

• একটি স্ট্রিংকে "সম্পূর্ণ মিলিত" হিসাবে বিবেচনা করা হয় যদি এবং কেবল যদি:

  1. প্রতিটি একক অক্ষর একটি বন্ধনী,

  2. প্রতিটি বন্ধনী বন্ধনের সঠিক উদ্বোধন এবং বন্ধ বন্ধনী এবং সঠিক ক্রমে থাকে এবং

  3. প্রতিটি বন্ধনী মিলছে।

• আপনি ধরে নিতে পারেন ইনপুটটিতে কেবল প্রিন্টযোগ্য ASCII থাকবে ।

পরীক্ষা IO

এখানে এমন কিছু ইনপুট রয়েছে যা সত্যের মানটি ফিরিয়ে আনবে:

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

এবং এখানে এমন কিছু ফলাফল রয়েছে যা একটি মিথ্যা মানটি ফিরিয়ে আনবে:

(               Has no closing ')'
}{              Wrong order
(<)>            Each pair contains only half of a matched element
(()()foobar)    Contains invalid characters
[({}<>)>        The last bracket should be ']' instead of '>'
(((()))         Has 4 opening brackets, but only 3 closing brackets.

যথারীতি এটি কোড-গল্ফ, সুতরাং মানক লুফোলগুলি প্রয়োগ হয় এবং বাইট জেতে সংক্ষিপ্ত উত্তর।

Comments

সম্পর্কিত।

— মার্টিন ইন্ডার

সম্ভাব্য নিকটতম ভোটারদের জন্য নোট: আমি যে চ্যালেঞ্জটি সংযুক্ত করেছি তাতে ব্র্যাকেট প্রকারের জন্য একটি অগ্রাধিকার অর্ডারও অন্তর্ভুক্ত রয়েছে যাতে তারা স্বেচ্ছাসেবী আদেশে বাসা বাঁধতে পারে না। আমি মনে করি এটি যথেষ্ট আলাদা করে তোলে।

— মার্টিন ইন্ডার

কি [}একটি ম্যাচ? এবং যদি তা না হয় তবে এই বিধিগুলি দিয়ে এটি বাদ দেওয়া হয় কোথায়?

— ব্যবহারকারী 207421 13

@ এজেপি না, এটি হয় না। Each pair of brackets has the correct opening and closing bracket and in the right order.

— ডিজেএমসিএমহেম

আমি প্রথম সমাধান ভোট দিন হবে বন্ধনী

— লিও

Answer 1

05 এ বি 1 ই , 19 বাইট

ইনপুট দেওয়া হয় কোট । কোড:

"[](){}<>"2÷)"":g2Q

ওয়েল ক্রেপ, প্রচুর বাগ এবং অবিরাম বৈশিষ্ট্য পাওয়া গেছে। ব্যাখ্যা:

"[](){}<>"           # Push this string
          2÷         # Split into pieces of two
            )        # Wrap it into an array (which should not be needed)
             ""      # Push an empty string
               :     # Infinite replacement

এটি আসলে একটি জটিল অংশ। সিউডোকোডে এটির মতো দেখতে হ'ল:

input().replace(['[]', '()', '{}', '<>'], "")

এটি 05AB1E কোড থেকে এই অংশটি কভার করা হয়েছে :

if type(b) is list:
    temp_string = temp_string_2 = str(a)
    while True:
        for R in b:
            temp_string = temp_string.replace(R, c)
        if temp_string == temp_string_2:
            break
        else:
            temp_string_2 = temp_string
    stack.append(temp_string)

আপনি দেখতে পাচ্ছেন, এটি অসীম প্রতিস্থাপন (স্ট্রিংটি আর পরিবর্তন না হওয়া পর্যন্ত সম্পন্ন)। সুতরাং, আমি প্রতিস্থাপনটি একটি লুপে সেট করার বিষয়ে চিন্তা করার দরকার নেই, কারণ এটি ইতিমধ্যে অন্তর্নির্মিত। তারপর:

                g    # Take the length of the final string
                 2Q  # Check if equal with 2 (which are the quotes at the end)

ব্যবহার সিপি-1252 এনকোডিং। এটি অনলাইন চেষ্টা করুন! (কিছুটা পরিবর্তিত হয়েছে কারণ উপরের সংস্করণটি অবচিত করা হয়েছে)।

Comments

দারুণভাবে গল্ফ!

— SamyQc

এটি আগে যুক্ত õকরা হয়েছিল?

— জাকারি

@ জাচারý হ্যাঁ, এটি সঠিক

— আদনান

Answer 2

ব্রেন-ফ্লাক , 1101, 1085 , 981 বাইট

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

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

এটি উত্স কোডের 980 বাইট, এবং পতাকাটির +1জন্য -aএএসসিআইআই ইনপুট (তবে দশমিক আউটপুট) সরবরাহ করে

এটি একটি উত্তর যা আমি খুব দীর্ঘ সময় ধরে লিখতে চাইছিলাম । কমপক্ষে 6 মাস। আমি এটি পোস্ট করার জন্য অপেক্ষা করছিলাম কারণ আমি জানতাম যে এই চ্যালেঞ্জটির উত্তর দেওয়া মস্তিষ্কের ঝাঁকুনিতে অতিরিক্ত শক্ত হয়ে উঠবে। তবে এটি একটি অত্যন্ত গুরুত্বপূর্ণ কারণে এটি মূল্যবান: উত্স কোড নিজেই একটি সত্যবাদী ইনপুট, যা নিজেই এই ভাষার পুরো পয়েন্ট।

এবং আমি যেমন এখানে লিখেছিলাম , এই প্রশ্নটিই আমাকে মস্তিষ্কের ঝাঁকুনি লিখতে অনুপ্রাণিত করেছিল।

আমি লেখার অল্পক্ষণের পরে কি বন্ধনীগুলি সম্পূর্ণরূপে মেলে? একটি জিনিস যা আমার কাছে দাঁড়িয়েছিল তা হ'ল যদিও আপনার কাছে মাত্র 4 "পরমাণু" রয়েছে:

(){}[]<>

আপনার কাছে সত্যিকার অর্থে 8 টি ইউনিট তথ্য পৌঁছে দেওয়ার জন্য, যেহেতু এই বন্ধনীর প্রতিটি ধরণের খালি থাকতে পারে বা এর মধ্যে অন্য বন্ধনী রয়েছে, যা মূলত তথ্যের বিভিন্ন অংশ। সুতরাং, আমি এমন একটি ভাষা লেখার সিদ্ধান্ত নিয়েছি যা কেবলমাত্র বন্ধনীর জন্য বন্ধুত্বের জন্য মঞ্জুরিপ্রাপ্ত এবং যেখানে খালি বন্ধনীর ভিতরে বন্ধনীগুলির চেয়ে পৃথক কিছু বোঝায় vey

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

একটি মিনিমালিস্ট এসোলাং ব্যবহারের জন্য বেদনাদায়ক হতে ডিজাইন করা হয়েছে

আমি পরে এটি গল্ফ করার চেষ্টা করতে যাচ্ছি, তবে আমি যাইহোক এটি এখানে পেতে চেয়েছিলাম।

আমার একটি বিশদ ব্যাখ্যা আছে তবে এটি প্রায় 6 হাজার অক্ষর দীর্ঘ, তাই আমি মনে করি পুরো উত্তরটিকে এই উত্তরের সাথে আটকানো বুদ্ধিমানের কাজ হবে না। আপনি চাইলে এটির মাধ্যমে এখানে পড়তে পারেন। আমি এখানে একটি সংক্ষিপ্ত ব্যাখ্যা যুক্ত করব।

প্রাথমিক ধারণাটি হ'ল আমরা স্ট্যাকের প্রতিটি চরিত্রের জন্য নিম্নলিখিত পদক্ষেপগুলি পুনরাবৃত্তি করছি:

• এটি প্রতিটি অক্ষর কোনও ব্রাকেটের সাথে মেলে কিনা তা দেখতে আমরা পরীক্ষা করে দেখি। যদি এটি একটি উদ্বোধনী বন্ধনী হয় তবে আমরা নীচের ম্যাপিং অনুসারে একটি নম্বরটিকে অন্য স্ট্যাকের উপরে চাপি:

  ( = 1
  < = 2
  [ = 3
  { = 4
  

• তারপরে আমরা এটি বন্ধ হওয়ার কোনও বন্ধনীটির সাথে মেলে কিনা তা পরীক্ষা করে দেখি। যদি এটি হয়, আমরা বন্ধনী খোলার মত ঠিক সমান সংখ্যাটিকে বিকল্প স্ট্যাকের উপরে চাপি। তারপরে , আমরা পরীক্ষা করব যে শীর্ষ দুটি সংখ্যা সমান কিনা। যদি তা হয় তবে উভয়ই পপড হয়ে যায় এবং প্রোগ্রামটি স্বাভাবিক হিসাবে চালিয়ে যায়। যদি তা না হয় তবে আমরা উভয় স্ট্যাকগুলি সাফ করি (লুপিং বন্ধ করতে) এবং একটিটিকে বিকল্প স্ট্যাকের উপরে চাপি। এটি মূলত একটি "বিরতি" বিবৃতি।

• 8 বন্ধনী প্রকারের পরীক্ষা করার পরে, আমরা লুপের মাধ্যমে এই রানটির মানটি চাপি। যেহেতু আমরা এর বেশিরভাগই শূন্য করে ফেলেছি, যখন বন্ধনীগুলির সাথে তুলনা করি তখন কেবলমাত্র স্নিপেটগুলির কোনও মান থাকে the সুতরাং যদি কোনও বন্ধনী মেলানো হয় তবে পুরো লুপটির মান 1 হয় them যদি তাদের কোনওটি না করে তবে পুরো লুপটির মান 0 থাকে this এক্ষেত্রে আমরা উভয় স্ট্যাক সাফ করে দেব এবং 0 টি বিকল্প স্ট্যাকের দিকে ধাক্কা দেব। আবার এটি "ব্রেক" স্টেটমেন্টের মতো।

এই প্রধান লুপটি চলার পরে, বাকিগুলি মোটামুটি সহজ। আমরা (খালি) প্রধান স্ট্যাকের উপর আছি, এবং বিকল্প স্ট্যাকটি খালি (যদি বন্ধনীগুলি মেলানো থাকে) বা খালি না থাকলে তারা খালি থাকে। সুতরাং আমরা এটি চালান:

#Toggle to the alternate stack
<>

#Push this stack-height onto main-stack
([]<>)

#Logical not
({}<(())>){((<{}{}>))}{}

এটি একটি 0 বা 1 এ মুখ্য স্ট্যাকের দিকে ঠেলে দেবে এবং প্রোগ্রামটি শেষ হলে এটি স্পষ্টভাবে মুদ্রিত হবে।

---

• ধন্যবাদ @WheatWizard একটি ভাল স্ট্যাক-পরিচ্ছন্ন নিয়ে আসছে জন্য "সমান" এবং "লজিক্যাল নয়" স্নিপেট, এবং নিয়মিত আপডেট করার জন্য GitHub উইকি দরকারী উদাহরণ।

• কেবলমাত্র অনলাইনে পূর্ণসংখ্যার মেটাগল্ফার লেখার জন্য @ এএসসিআইআই-কে ধন্যবাদ যা এই প্রোগ্রামটি লেখার ক্ষেত্রে প্রচুর সহায়তা করেছে

---

পুনর্বিবেচনা

• কিছুটা ধাক্কা পপ রিডানডেন্সি সরানো হয়েছে

• আমার শূন্য পাল্টা যুক্তি বদলেছে

Comments

Awwwwwweeeeesommmmeeeee!

— অর্জুন

Answer 3

ব্রেন-ফ্লাক , 204 196 190 বাইট

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

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

-8 বাইট উইট উইজার্ড ধন্যবাদ। -6 বাইট জো কিংকে ধন্যবাদ জানায়।

ব্যাখ্যা

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

# While there are bytes left to process
{

 # Move byte to second stack
 ({}<>)<>

 # Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
 ((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())

 ((

   # For each opening bracket type:
   {

    # Evaluate as zero
    <

     # Compute difference between bracket type and input byte
     ({}<>[({})])

    >

    # Evaluate loop iteration as -1 if equal, 0 otherwise
    [()]{()(<{}>)}{}<>

   }

   # Remove the 0 that was inserted to terminate that loop
   {}

   # Add 1 to result
   ()

   # Evaluate rest of this expression as zero
   <

    # Determine whether the byte is open parenthesis
    ({}<>[({})])

    # If not:
    {

     # Add 1 to byte and break if
     (<{}({}())>)

    }{}

    # Return to main stack
    <>

   >

 # Push result twice (0 if matched an opening bracket, 1 otherwise)
 ))

 # If byte was not an opening bracket:
 {

  # Push zero to break out of if
  (<

    # Push (open bracket + 2 - byte) below that zero
    ({}{}<>[{}]{}<>)

  >)

 }{}

 # If byte was neither an opening bracket nor the appropriate closing bracket:
 {

  # Clear alternate stack and stay there to break out of main loop early
  <>{{}}

 }{}

# End of main loop
}

# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket.  If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.

# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})

Comments

"পার্থক্যগতভাবে যৌক্তিক নয়" (সমান হিসাবেও পরিচিত) এর চেয়ে ছোট হতে পারে([{}]<>({}))((){[()](<{}>)}{})

— গম উইজার্ড

আমি মনে করি আপনি এই শেষ চেকটি ({<>[()]}())-6 বাইটের সাথে প্রতিস্থাপন করতে পারবেন

— জো কিং

@ জোকিং ধন্যবাদ আমি মনে করি না যে আমি কখনই এটি খুঁজে পেয়েছি।

— নাইট্রডন

হ্যাঁ, আমি এটি আমার নিজের জবাব দিয়ে বুঝতে পেরেছিলাম এবং বুঝতে পেরেছিলাম যে এটি আপনার ক্ষেত্রেও প্রযোজ্য ছিল

— জো কিং

Answer 4

জাভাস্ক্রিপ্ট (ES6), 52 50 বাইট

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

ফলাফলটি আসলটির মতো না হওয়া পর্যন্ত বার বার বন্ধনী সরিয়ে ফেলুন, তারপরে স্ট্রিংটি খালি না হলে মিথ্যা ফিরিয়ে দিন।

সম্পাদনা: @ বর্ধিত 2 বাইট ধন্যবাদ @ edc65।

Answer 5

রেটিনা, 20 বাইট

+`\(\)|\[]|{}|<>

^$

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

Answer 6

সিজেম, 25 24 23 21 বাইট

2 বাইট সংরক্ষণের জন্য Sp3000 ধন্যবাদ।
2 বাইট সংরক্ষণের জন্য জিমি 23013 কে ধন্যবাদ।

q_,{()<>}a`$2/*{/s}/!

পরীক্ষা স্যুট.

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

এখানে একটি মজাদার গল্ফিং ট্রিক রয়েছে: স্ট্রিংটি পেতে ()<>[]{}আমরা নিম্নলিখিতটি ব্যবহার করি:

{()<>}a`$

, {()<>}হ'ল একটি ব্লক (যেমন একটি ফাংশন), যাতে কোড হিসাবে অন্যান্য বন্ধনী রয়েছে। aআমরা একটি অ্যারে ব্লক মোড়ানো সঙ্গে । `Stringifies যে অ্যারের, যা দেয় "[{()<>}]"। শেষ পর্যন্ত, আমরা স্ট্রিংটি এর সাথে বাছাই করি $যা বন্ধনীগুলিকে পুনরায় সাজায় ()<>[]{}।

Comments

আমি আপনার ভাষার সাথে পরিচিত নই, তবে আপনার গল্ফিংয়ের কৌতুকের বিবরণ এটির মতো শোনাচ্ছে যা ()<>[]{}`ঠিক একইভাবে কাজ করবে এবং একই সংখ্যক বাইট হবে, তাই না?

— হাঁস

@ মুভিংডাক নো কারণ ()<>চারটি অপারেটর (হ্রাস, বৃদ্ধি, এবং তারপরে অপারেশনগুলির উপর নির্ভর করে তুলনা বা কাটছাঁট) রয়েছে, যা অবিলম্বে কার্যকর করা হবে, যেখানে {}একটি ব্লক (সিজেএমের সমতুল্য কোনও ক্রিয়াকলাপ) বোঝায় , যা কোডের একটি অংশ যা কেবল ধাক্কা দিয়েছে অবিলম্বে মূল্যায়ন না করে স্ট্যাকের উপরে onto এজন্যই আমাকে {}মোড়ানো দরকার ()এবং <>তবে তারপরে aসমস্ত কিছু অ্যারে রাখার জন্য ব্যবহার করা তার চেয়ে কম [...]।

— মার্টিন এন্ডার

Answer 7

পাইথন, 67 বাইট

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

উত্সাহিত করে এবং একটি মত প্রকাশ করে যা দেখায়

s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')

এবং ফলাফল খালি কিনা তা পরীক্ষা করে দেখুন।

এসপি 3000 8 টি বাইট সংরক্ষণ করে সেগুলিকে উদ্ধৃতিবিহীন সাব বেন করা [],(),{}যেতে পারে কারণ তারা পাইথন বস্তু, এবং যে দুটি প্যারেন বিনা শরণে ছিল।

Answer 8

ইয়্যাক, 119 বাইট

রিজেক্স / প্রতিস্থাপন ব্যবহার করে না।

%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}

Ungolfed

%%                              # Grammar in BNF
input:
  r;
r:
  %empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%%                              # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}

সংকলন

yacc -o bracket.c bracket.y
cc -o bracket bracket.c

ব্যবহার

~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 %                                                                         :(

Answer 9

পাইথ, 31 25 24 বাইট

FryAmTheEggMan 1 বাইট সরানো হয়েছে ধন্যবাদ 25 বাইট ডাউন গল্ফড

VQ=:Q"<>|\[]|{}|\(\)"k;!

এখানে চেষ্টা করুন: টেস্ট স্যুট !

আমি এখনও পাইথ নবাগত, যে কোনও সাহায্যের প্রশংসা হয়।

ব্যাখ্যা

VQ                         For N in range(0, len(z)), with Q being the evaluated input.
                           Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
  =:Q"<>|\[]|{}|\(\)"k     assign Q without {}, [], <> nor () (regex replacement) to Q
                      ;    End of For loop
                       !   Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
                           This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise

বিটিডাব্লু, অন্যান্য পাইথ উত্তরের (যা বর্তমানে 20 বাইটে) সংশ্লেষ

Comments

প্রোগ্রামিং ধাঁধা এবং কোড গল্ফ স্বাগতম!

— আদনান

@ আদনান আপনাকে ধন্যবাদ! এটি আমার প্রথম গল্ফ!

— FliiFe

চমৎকার প্রথম গল্ফ! কিছু পুনরায় সাজানো এবং স্টাফ দিয়ে আপনি 25: এ পেতে পারেন Vz=:z"<>|\[]|{}|\(\)"k;!z। বিশেষত দ্রষ্টব্য, আপনার যদি মূলত lসংখ্যার প্রয়োজন না হয় তবে আপনার মূলত কখনই ব্যবহার করার দরকার নেই এবং =স্বয়ংক্রিয়ভাবে কোনও এক্সপ্রেশনটিতে ব্যবহৃত প্রথম পরিবর্তনশীলটি অনুমান করে। আমাকে যদি তুমি আমাকে পছন্দ করবে অন্য কিছু ব্যাখ্যা করার যাক Pyth চ্যাটরুম :)

— FryAmTheEggman

@ ফ্রাইএইমডিজম্যান ধন্যবাদ! আমি জানতাম না lঅপ্রয়োজনীয়, এটা জেনে রাখা ভাল। প্রথমদিকে, আমি একটি ফাংশন ঘোষণা করলাম কারণ আমার যুক্তিটি ভিন্ন ছিল এবং এটি সরিয়ে দিতে ভুলে গিয়েছিলাম। আমি কি আপনার উত্তর আমার সাথে অন্তর্ভুক্ত করব? (আমি একজন নবাগত> <<)

— ফ্লাইফি

সাধারণত, যদি এটি একটি মন্তব্যে পোস্ট করা হয় তবে মন্তব্য লেখক আপনাকে এটি ব্যবহার করতে চান। সুতরাং ঠিক এগিয়ে যান! :)

— FryAmTheEggman

Answer 10

পাইথ, 20 বাইট

!uuscNTc"[](){}<>"2G

এটি অনলাইনে ব্যবহার করে দেখুন: টেস্ট স্যুট

বারবার এর ঘটনার সরিয়ে ফেলা হবে [], (), <>এবং {}বিভাজন এবং পুনরায় মার্জ দ্বারা। ফলাফলগুলি স্ট্রিং ফাঁকা আছে কিনা তা পরীক্ষা করে।

Answer 11

জাভাস্ক্রিপ্ট ES6, 54 বাইট

f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_

পুনরাবৃত্তি প্রতিস্থাপন বাস্তবায়ন ব্যবহার করে। যথেষ্ট সহজ।

Answer 12

রেজেক্স (পিসিআরই স্বাদ), 41 37 বাইট

^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$

পুনরাবৃত্তিমূলক রেগেক্স সহ কেবল একটি স্ট্যান্ডার্ড সমাধান।

4 বাইট বন্ধ শেভ করার জন্য জিমি 23013 ধন্যবাদ

Answer 13

পার্ল, 34 33 বাইট

জন্য +2 অন্তর্ভুক্ত -lp

এসটিডিনে ইনপুট দিয়ে চালান:

./brackets.pl <<< "{<>()}"

brackets.pl:

#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_

তাদের মধ্যে কোনও কিছুই ছাড়াই প্রথম বন্ধনী জুড়িটি আবিষ্কার করে এবং যতক্ষণ না থাকে এটিকে সরিয়ে দেয়। তারপরে চূড়ান্ত স্ট্রিংটি খালি আছে কিনা তা পরীক্ষা করে দেখুন।

Comments

s/\(\)|\[]|<>|{}//&&redo;$_=!$_কাজ করবে না ? :)

— দাদা

আপনি যদি ব্যাখ্যাও সরবরাহ করতে পারেন তবে এটি দুর্দান্ত হবে।

— প্রশান্ত পোখরিয়াল

@ দাদা অবশ্যই আমি অবশ্যই

— বুদ্ধিমান হয়ে উঠছি

Answer 14

ব্রেন-ফ্লাক , 204 বাইট

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

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

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

ব্যাখ্যা:

(())  Push 1 to simulate the check at the start of the loop
{  While check
	{}           Pop check
	{({}<>)<>}<> Reverse input
	({           Loop over input
		< Don't push the values of these calculations
		(<(({})<>)>)  Create a copy of the top of the input and push to the other stack
		(((((
		((([(())()()()]){}){}){}())
		(()))
		(((())()){}()){})
		){})          Push the differences in values of the end brackets 
		(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))  If the copy is the same as any of these, push the difference between the other bracket twice
		<>{}<>  Pop copy
		{  If this character is a start bracket
			{}({}[({})]<>({}))  Check if the next character is the end bracket
			{(<>)(<>)}{}          If not, push a 0 to each stack as buffer
			{}       Pop the top of the input stack, either the start bracket if they matched or the buffer 0
			(<>)     Push 0 to other stack to end check
		}{}>
		{}   Pop the top of the other stack
		         If the character was not an end bracket, pop the copy of check, which is 0
		         If it was, but didn't match the next character, pop the buffer 0
		         If the brackets matched, pop the end bracket and add it to the loop total
	<>}	Repeat with the rest of the input
	<>)	Push the loop total
		If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1

Answer 15

ব্রেইনফাক, 132 বাইট

+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.

বিন্যাসকৃত:

+>,
[
  [<-> >+>[-]<<-]
  <
  [
    not matching closing bracket
    >+>[<+<+>> >+<-]
    +++++[>--------<-]
    >
    [
      not open paren
      <<+>
      ++++[>-----<-]>
      [
        not open angle bracket
        <+++++[>------<-]>-
        [
          not open square bracket
          <++++[>--------<-]>
          [
            not open brace
            ,>
          ]
        ]
      ]
    ]
    <
  ]
  ,
]
<<[>]
>.

কোনও পূর্ববর্তী নিউলাইন ছাড়াই ইনপুট আশা করে। \x00মিথ্যা এবং \x01সত্যের জন্য প্রিন্টগুলি ।

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

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

Answer 16

গ্রিম ভি0.1, 34 বাইট

M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M

কোনও ম্যাচের জন্য প্রিন্ট করুন 1এবং 0কোনও মিল নেই। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

গ্রিম এই চ্যালেঞ্জের জন্য ডিজাইন করা আমার 2 ডি প্যাটার্ন-মেলানো ভাষা ; এটি 1 ডি স্ট্রিংগুলি ম্যাচ করার জন্যও ব্যবহার করা যেতে পারে। এটি এটির সাথে আমার প্রথম উত্তর। আমি আজ গ্রিমকে সংশোধন করেছি, তবে কেবলমাত্র একটি সিনট্যাক্স উপাদানটির `পরিবর্তে ( পরিবর্তে ,), যাতে এটি আমার স্কোরকে প্রভাবিত করে না।

M=                         Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\>      a smaller M inside matched brackets,
|MM                          or two smaller Ms concatenated,
|_                           or the empty pattern.
e`M                        Match the entire input against M.

Answer 17

রেং v.3.3, 137 বাইট, নন-কেপটিং

এখানে চেষ্টা করুন!

aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2<       <       <     +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
   \$2+)1z+#z/   ~n1/

আরও কিছু গল্ফ করার দরকার আছে, তবে কমপক্ষে এটি কার্যকর হয়। ðএই চ্যালেঞ্জের পরে খুব সহজেই / সহজেই সম্ভব হওয়ার জন্য আমি স্ট্র্যাকের সন্ধানের জন্য একটি কমান্ড যুক্ত করেছি । আমি এটিকে কিছুটা ব্যাখ্যা করব, তবে এটি সাধারণত সমস্ত স্ট্রিংগুলিকে পুনরাবৃত্ত করে এবং পুনরাবৃত্তিগুলি সন্ধান করে; যদি কোনও পুনরাবৃত্তি হয়, তবে স্ট্রিংটি অপ্রয়োজনীয়। অন্যথায়, স্ট্রিংটি খালি স্ট্রিং / স্ট্যাকের মধ্যে হ্রাস হবে এবং আউটপুট হবে 1। অন্যথায়, কোনও আউটপুট উত্পাদিত হবে না।

Answer 18

পাওয়ারশেল ভি 2 +, 63 62 বাইট

param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a

জাভাস্ক্রিপ্টটি বেশ ধরতে পারে না, তবে বর্তমানে অন্যান্য নন-এসওল্যাংগুলি প্রবাহিত করছে।

অন্যান্য উত্তর হিসাবে একই পদ্ধতির: একটি সহজ লুপ যে এতক্ষণ আমরা এক অপসারণ করতে পারেন হিসাবে চলতে [], ()কিংবা <>(কারণ আমরা Regex বিশেষ অব্যাহতি প্রয়োজন বিভিন্ন বিদেশী অক্ষর সহ)। $bআমাদের আগের লুপটি কী $aসেট করা হয়েছিল তা স্মরণে রাখতে আমরা সহায়ক হিসাবে ব্যবহার করি । একটি অনির্বাচিত ভেরিয়েবল $null, সুতরাং প্রথমবার লুপটির মুখোমুখি হওয়ার পরে $aতা অবশ্যই সমান নয় $null।

লুপের শেষে, $aহয় ফাঁকা বা না, এবং সেই স্ট্রিংয়ের বুলিয়ান না হয় হয় Trueবা হয় False।

উদাহরণ

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False

Answer 19

সি, 121 122 114 বাইট

@ এসএসটকে ধন্যবাদ 8 টি বাইট!

a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}

একটি স্ট্যাক ব্যবহার করে।

Comments

আমি চাই c%7&2। আসলে, আপনার দরকার নেই k। পরিবর্তে, আপনি কেবল বৃদ্ধি করতে পারেন iযেখানে আপনি সংশোধন করতে পারেন kযেহেতু আপনার iশেষ পর্যন্ত যাইহোক শূন্য কিনা তা পরীক্ষা করা দরকার । এই (অপরীক্ষিত কোড) মত কিছু: a[99],i;main(c){for(;read(0,&c,1);c%7&2?i+=a[i--]^c/9:(a[++i]=c/9))i+=!strchr("()[]{}<>",c);putchar(48+!i);}।

— xsot

@ এক্সসট - আমি কি ইনক্রিমেন্টিং কাজ করব? আমাদের একটি নেতিবাচক মান সহ অ্যারে সাবস্ক্রিপশন এড়ানো প্রয়োজন, সুতরাং আমাদের জন্য আই বা কে উভয় পরীক্ষা করতে হবে।

— mIllIbyte

আহ আমি দেখি. উন্নতির জন্য এখনও a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!i*!k);}

— অবকাশ আছে

@ এক্সসট - ধন্যবাদ! সঞ্চয়গুলি সারসংক্ষেপ হিসাবে, 5 টি বাইট সংরক্ষণ করুন, একটি সংরক্ষণ করা এবং শর্তসাপেক্ষ অপারেটরের মধ্যবর্তী অপ্রেন্ড 2 সংরক্ষণ করে I আমি অবাক হয়েছি যে শর্তসাপেক্ষ অপারেটরের মাঝের অপ্রেন্ডেন্ট একটি অ্যাসাইনমেন্ট হতে পারে। আমি ভেবেছিলাম যে এখানে একটি ত্রুটি হবে, "অনুপস্থিত: আগে =" এর মতো কিছু।

— mIllIbyte

@ এক্সসট - আপনার পরামর্শ অনুসারে আমি কে ব্যবহারের পরিবর্তে আমি বৃদ্ধি করার চেষ্টা করেছি: a[99],i;main(c){for(;read(0,&c,1);c%7&2?i+=a[i]^c/9?1:-1:(a[++i]=c/9))i+=!strchr("()[]{}<>",c);putchar(48+!i);}তবে এটি ইনপুট এর মতো এখনও কাজ করে না ())), কারণ স্ট্যাক থেকে "পপিং" অ্যারেতে মানগুলি শূন্য করে না।

— mIllIbyte

Answer 20

জাভা 7, 156 151 বাইট

class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}

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

প্রোগ্রামের পরামিতি হিসাবে ইনপুট দেওয়া হয়। এটি এখানে অন্যান্য উত্তরগুলির মতো একই ফর্ম্যাটটিকে অনুসরণ করে যে এটি একটি লুপে একটি রেগেক্স প্রতিস্থাপনের কাজ করে। মূলত আমি এটি এন বার লুপ করেছি যেখানে এন মূল স্ট্রিং এর দৈর্ঘ্য কিন্তু লুপিং Integer.MAX_VALUEসংক্ষিপ্ত:]। এটি ঠিক হওয়া উচিত কারণ জাভাতে এটির Integer.MAX_VALUEসর্বোচ্চ দৈর্ঘ্য Stringতাই ইনপুট দৈর্ঘ্য এমন কিছু যা জাভা দ্বারা হ্যান্ডেল সক্ষম। লুপের কারণে রানটাইমটি বেশ খারাপ (আমার ল্যাপটপটিতে প্রায় 20 মিনিট সময় নিয়েছে) তবে আমি তাতে কোনও বাধা দেখিনি।

Answer 21

হাস্কেল , 151 বাইট

infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0

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

Comments

কয়েকটি জিনিস: ফাংশনটিকে (#)দ্বিতীয় আর্গুমেন্ট হিসাবে খালি স্ট্রিংয়ের সাথে ডাকার প্রয়োজন হওয়ায় আপনাকে (#"")আপনার বাইট গণনার দিকে গুনতে হবে। এছাড়াও কেবল Trueএবং Falseসত্যবাদী / মিথ্যা হিসাবে বিবেচিত, গল্ফিং বিধি সম্পর্কিত গাইড দেখুন ।

— লাইকনি

তবে বন্ধ বন্ধনীগুলির সাথে চারটি লাইন প্রতিস্থাপন করা যেতে পারে a:x#b:y|a==b=x#y, বাইটগুলি 113 এ নামিয়ে আনুন: এটি অনলাইনে চেষ্টা করুন!

— লাইকনি

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

— লাইকনি

Answer 22

পাইথন 2.7, 96 বাইট

def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])

Comments

সাইটে স্বাগতম!

— ডিজেএমসিএমহেম

Answer 23

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

def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s

Answer 24

জুলিয়া, 51 বাইট

~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n

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

ব্যাখ্যা:

~z=                            # Define ~z to be the following:
    z==(                       # If z is equal to                                     
        n=replace(z,           # z with the replacement of 
            r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
            ""                 # with empty strings
        )                      # (which is assigned to n)
    )?z==""                    # whether z is an empty string
    :~n                        # else ~ applied to the substituted string

ফাংশনটি বার বার তার একমাত্র যুক্তি থেকে সংযুক্ত জোড়া বন্ধনী সরিয়ে ফেলে, এবং যদি খালি স্ট্রিংটি এইভাবে পাওয়া যায় তবে সত্য ফিরে আসে returns

Answer 25

সেড, 39 36 বাইট (কোডের জন্য 34, -র জন্য 2)

:a
s/\(\)|\[]|<>|\{}//;ta
/./c0
c1

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

স্ট্যান্ডার্ড পদ্ধতির বলে মনে হচ্ছে এর সেড সংস্করণ। বর্ধিত নিয়মিত এক্সপ্রেশন প্রয়োজন ( sed -r)

গরু কোয়াকে ধন্যবাদ 3 বাইট সংরক্ষিত

Comments

আপনি aহ'ল অপসারণ করতে :aএবং taবাইটগুলি সংরক্ষণ করতে পারেন

— ক্রিটিক্সি লিথোস

@ ক্রিটিক্সিলিথোস স্পষ্টতই এটি জিএনইউ সেডের একটি বাগ ছিল যা ৪.৩-এ সরিয়ে দেওয়া হয়েছিল । আমি যদি এই এন্ট্রিটি জয়ের সুযোগ পাওয়ার জন্য নেত্রীর কাছে খুব কাছাকাছি থাকত তবে আমি সম্ভবত এই চরিত্রগুলি ফেলে দেব তবে এটি যেহেতু এটি নয়, আমি কেবল এটি আরও বহনযোগ্য আকারে রেখে যাব যাতে এটি কাজ বন্ধ না করে আরও সিস্টেম 4.3-এ উন্নীত করা হয়েছে

— রায়

এটি ফিরে তাকানো, আমি নিশ্চিত যে আপনি এখান qথেকে /./বন্ধনী এবং ড্রপ করতে পারেন । এটি অনলাইন চেষ্টা করুন! এটি cহ্যাঙ্গ কীভাবে কাজ করে তার কারণ

— ক্রিটিক্সী লিথোস

ধন্যবাদ সম্পাদনা করা হয়েছে।

— রায়

Answer 26

05 এ বি 1 ই, 9 বাইট

žu2ôõ:g2Q

ইনপুট দেওয়া হয়।

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

ব্যাখ্যা:

žu          # Push "()<>[]{}"
  2ô        # Split into pieces of size 2
    õ       # Push empty string
            # Implicit input
      :     # Infinite replacement
       g2Q  # Is length equal to 2?
            # Implicit print

Answer 27

ক্লোজার, 153 বাইট

এমনকি সি এবং ব্রেইনফাকের উত্তরগুলির চেয়েও দীর্ঘ: ও

(defn f[[s & r]](if s(let[[a b](split-at(.indexOf(reductions + 1(for[c r](get(zipmap[s({\(\)\[\]\{\}\<\>}s)][1 -1])c 0)))0)r)](and(not=()a)(f(butlast a))(f b))))1)

রেজেক্স ব্যবহার করে না, পরিবর্তে প্রথম অক্ষরটি ব্যবহার করে শেষের ট্যাগটি নির্ধারণ করতে ব্যবহার করে এবং প্রথম সূচকটি খুঁজে পায় যেখানে সেই বন্ধনীটি ভারসাম্যপূর্ণ হয় (সংশ্লেষ যোগফল শূন্য হয়)। তারপরে পুনরাবৃত্তিটি পরীক্ষা করে দেখুন বন্ধনীগুলির মধ্যে এবং বন্ধনীগুলির পরে যা আছে তা বৈধ।

আরও ভাল পদ্ধতির আছে কিনা তা দেখতে পারা ...

Answer 28

লুয়া , 295 বাইট

f = false g = string.gsub t=table s={}b=io.read()for c in b:gmatch('.')do if c:find("[%[<{%(]")then s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")")elseif c:find("[%]>}%)]")then if t.remove(s)~=c then print(f)return end else print(f)return end end if#s>0 then print(f)else print(1)end

অবহেলিত সংস্করণ

f = false
g = string.gsub
t=table
s={} --Define a stack of opening brackets
b=io.read() --get the input
for c in b:gmatch('.') do   --for every character
    if c:find("[%[<{%(]") then
        s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")") --if the current character is an opening bracket, push the closing bracket onto the stack
    elseif c:find("[%]>}%)]") then
        if t.remove(s)~=c then
            print(f) --if the character is a closing bracket, pop the closing bracket off the stack and test if they match, if not print false
            return
        end
    else 
        print(f) --if the character is not a bracket print false
        return
    end
end
if #s>0 then
    print(f) --if there are still brackets on the stack print false
else
    print(1) --print 1 there are no brackets on the stack
end

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

Answer 29

জাপট ভি 2.0a0 -!, 16 বাইট

e/\[]|<>|\(\)|{}

চেষ্টা করে দেখুন

Answer 30

আর, 298

function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}

ক্রিয়াকলাপটি আর কোডে রূপান্তর করা এবং তারপরে এটি বিশ্লেষণ এবং মূল্যায়ন করার চেষ্টা করুন The যদি এটি ত্রুটি দেয় তবে ফিরে আসুন FALSE।

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

উদাহরণস্বরূপ, []রূপান্তরিত হয় S('[', {}, ']'), এস হিসাবে সংজ্ঞায়িত করা হয় ...

S=function(H,B,T)if(H!=T)stop() 

যেহেতু মাথা চেঁচানো এবং লেজ চেঁচানো ম্যাচ, কোনও ত্রুটি নিক্ষেপ করা হয় না।

আরও কয়েকটি উদাহরণ (বাম অংশটি বন্ধনীগুলির ক্রম এবং ডান অংশটি বৈধ আর কোডে রূপান্তর করা যা মূল্যায়ন করা যেতে পারে):

[}     -->  S('[', {}, '}')     # squeaks an error
[()]   -->  S('[', {S('(',{},'(')}, "[")
({[]}) -->  S('(',{S('{',{S('[',{},'[');},'{');},'(');

বন্ধনী কিছু অন্যান্য ক্রম পার্স ত্রুটি ফলাফল:

[[)    -->   S('[',{S('[',{},'('); 

সুতরাং বাকি অংশটি কেবল ত্রুটিগুলি ধরে এবং যদি কোনও থাকে তবে মিথ্যা ফিরিয়ে দেয়, এবং যদি কিছুই না থাকে তবে সত্য।

মানব-পঠনযোগ্য কোড:

 sqk <- function(.){
   s=strsplit;u=paste0
   .=s(.,"")[[1]]            # break the argument up into 1-character pieces
   p=s("><)(}{][","")[[1]]   # vector of brackets
   .[!.%in%p]="§"            # replace anything besides brackets by § (--> error)
   for(i in 1:4*2){     
     .[.==p[i]]=sprintf("S('%s',{",p[i])    # '<' -->   S('<',{     ... etc
     .[.==p[i-1]]=sprintf("},'%s');",p[i])  # '>' -->   },'<');     ... etc  
   }
   S=function(H,B,T)if(H!=T)stop()          # define the working horse
   r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
   if(inherits(r,"try-error"))FALSE else TRUE   # any errors?
   }

নমুনা ক্ষেত্রে এটি প্রয়োগ করা:

truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
                      ()                 [](){}<>                 (((()))) 
                    TRUE                     TRUE                     TRUE 
                ({[<>]})             [{()<>()}[]] [([]{})<{[()<()>]}()>{}] 
                    TRUE                     TRUE                     TRUE 
> sapply(falsy,sqk)
           (            }        (<2)> (()()foobar)     [({}<>)>      (((())) 
       FALSE        FALSE        FALSE        FALSE        FALSE        FALSE